Skip to main content
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

Build docs developers (and LLMs) love

Get started for freeTalk to us