Built-in Extensions

Reference for Goose’s bundled extension capabilities

Goose includes several built-in extensions that provide core capabilities. These extensions are ready to use without installation.

Available Extensions

developer

Code editing, file operations, and shell access.

Enable:

goose session --with-builtin developer

Capabilities:

• Read, write, and edit files
• Execute shell commands
• Navigate file systems
• Search code
• Run tests and builds

Platform Extension: This is a platform-level extension with OS-specific implementations.

Configuration:

extensions:
  developer:
    enabled: true
    config:
      type: platform
      name: developer
      description: Code editing and shell access
      bundled: true

autovisualiser

Data visualization and UI generation tools.

Enable:

goose session --with-builtin autovisualiser

Capabilities:

• Generate charts (bar, line, pie, scatter)
• Create interactive dashboards
• Visualize data from JSON/CSV
• Build UI components

Use Cases:

• Data analysis visualization
• Report generation
• Interactive data exploration
• Dashboard creation

Configuration:

extensions:
  autovisualiser:
    enabled: true
    config:
      type: builtin
      name: autovisualiser
      description: Data visualisation and UI generation tools
      timeout: 120
      bundled: true

computercontroller

Web scraping, file caching, and system automation.

Enable:

goose session --with-builtin computercontroller

Tools:

web_scrape

Fetch and parse web content.

Example:

# In a Goose session:
"Scrape the latest news from https://example.com/news"

Parameters:

• url - URL to fetch
• save_as - Format: text, json, or binary

Features:

• HTML to text conversion
• JSON API responses
• Binary downloads
• Automatic caching

cache

Manage cached web content.

Operations:

• list - Show cached files
• view - Display file content
• delete - Remove specific file
• clear - Delete all cached files

Example:

"Show me what's in the cache"
"Clear the web scraping cache"

automation_script

Execute automation scripts in various languages.

Supported Languages:

• Shell/Bash (Linux/macOS)
• Batch (Windows)
• PowerShell (all platforms)
• Ruby (if installed)

Example:

"Run a shell script to process the log files"
"Execute this PowerShell command to check disk space"

Document Readers

read_pdf - Extract text from PDF files read_docx - Extract text from Word documents
read_xlsx - Extract data from Excel spreadsheets

Example:

"Extract the text from report.pdf"
"Read the data from spreadsheet.xlsx"

Configuration:

extensions:
  computercontroller:
    enabled: true
    config:
      type: builtin
      name: computercontroller
      description: Controls for webscraping, file caching, and automations
      timeout: 120
      bundled: true

memory

Persistent memory storage across sessions.

Enable:

goose session --with-builtin memory

Capabilities:

• Store categorized information
• Tag-based retrieval
• Global and project-local storage
• Persistent across sessions

Storage Types:

Global Memory: Stored in ~/.config/goose/memory/global/
Available across all projects.

Local Memory: Stored in <project>/.goose/memory/
Project-specific information.

Operations:

Store Memory

"Remember that I prefer TypeScript for new projects"
"Save this API endpoint to memory: https://api.example.com"

Parameters:

• category - Organization category
• data - Information to store
• tags - Optional tags
• is_global - Global or local storage

Retrieve Memory

"What do you remember about my coding preferences?"
"Retrieve all API endpoints from memory"

Parameters:

• category - Category to retrieve (”*” for all)
• is_global - Global or local storage

Remove Memory

"Delete the user_preferences category from memory"
"Remove that old API endpoint from memory"

When to Use:

• User preferences and habits
• Project configuration details
• Recurring workflow patterns
• API keys and endpoints
• Team conventions

Configuration:

extensions:
  memory:
    enabled: true
    config:
      type: builtin
      name: memory
      description: Tools to save and retrieve durable memories
      timeout: 120
      bundled: true

tutorial

Interactive tutorials and learning guides.

Enable:

goose session --with-builtin tutorial

Capabilities:

• Step-by-step guides
• Interactive examples
• Best practices
• Learning resources

Use Cases:

• Learning Goose features
• Understanding extension development
• Exploring MCP protocol
• Recipe creation guidance

Configuration:

extensions:
  tutorial:
    enabled: true
    config:
      type: builtin
      name: tutorial
      description: Access interactive tutorials and guides
      timeout: 120
      bundled: true

Using Built-in Extensions

Command Line

Single Extension:

goose session --with-builtin developer

Multiple Extensions:

goose session --with-builtin developer,memory,computercontroller

With Other Options:

goose run --recipe analyze.yaml --with-builtin developer,memory

Configuration File

Add to ~/.config/goose/config.yaml:

extensions:
  developer:
    enabled: true
    config:
      type: platform
      name: developer
      description: Code editing and shell access
      bundled: true

  memory:
    enabled: true
    config:
      type: builtin
      name: memory
      description: Persistent memory storage
      timeout: 120
      bundled: true

Interactive Configuration

goose configure
# Select: Add Extension
# Choose: Built-in Extension
# Select desired extension

Extension Registry

Built-in extensions are registered at startup:

use goose::builtin_extension::register_builtin_extensions;
use goose_mcp::BUILTIN_EXTENSIONS;

register_builtin_extensions(BUILTIN_EXTENSIONS.clone());

Registry maps extension names to spawn functions:

pub static BUILTIN_EXTENSIONS: Lazy<HashMap<&'static str, SpawnServerFn>> = 
    Lazy::new(|| {
        HashMap::from([
            builtin!(autovisualiser, AutoVisualiserRouter),
            builtin!(computercontroller, ComputerControllerServer),
            builtin!(memory, MemoryServer),
            builtin!(tutorial, TutorialServer),
        ])
    });

Container Support

Run extensions inside Docker containers:

goose session --container my-container --with-builtin developer

Requirements:

• Extension must exist in container
• For built-in extensions, Goose must be installed in container
• Container must be running

Disabling Profile Extensions

Skip default profile extensions:

goose session --no-profile --with-builtin developer

This uses only the specified extensions, ignoring your profile defaults.

Timeout Configuration

Set custom timeouts for long operations:

config:
  type: builtin
  name: computercontroller
  timeout: 300  # 5 minutes

Default timeout is 120 seconds.

Platform Extensions

The developer extension is a platform extension with OS-specific implementations:

• Linux: Native file operations and shell
• macOS: Native file operations and Terminal integration
• Windows: Native file operations and PowerShell/CMD

See Also

• Extensions Overview - Extension system concepts
• MCP Servers - MCP server implementation details
• Configure Command - Managing extensions
• Session Command - Using extensions in sessions