Goose

Goose abstracts over multiple LLM providers (OpenAI, Anthropic, Ollama, etc.) through a canonical model registry that normalizes provider-specific APIs into a unified interface. The system maintains a canonical_models.json registry mapping provider models to a standardized schema, with message format adapters translating between provider-specific request/response formats and Goose's internal representation. This enables seamless provider switching and fallback without changing agent logic.

Goose implements a core agent loop that orchestrates LLM reasoning with tool execution through a structured pipeline. The agent receives a user prompt, calls the LLM provider, parses tool calls from the response, executes tools via the extension system, and feeds results back into the conversation context. The loop maintains full conversation history and uses context compaction to manage token budgets across long-running tasks.

Goose implements context compaction strategies to manage LLM token budgets across long-running conversations. The system monitors token usage, identifies low-value messages (e.g., old tool outputs), and summarizes or removes them to stay within provider limits. Compaction strategies are configurable and can be tuned per-session based on task requirements.

Goose provides a prompt management system that stores and templates agent prompts, system prompts, and tool descriptions. Prompts are defined in configuration files and can include variables that are substituted at runtime. The system supports prompt versioning and allows different prompts for different tasks or providers.

Goose provides comprehensive logging and observability through structured logging that captures agent reasoning, tool execution, and system events. Logs are output in JSON format for easy parsing and can be directed to files, stdout, or external logging systems. The system includes debug modes for detailed tracing and performance metrics for monitoring agent efficiency.

Goose uses a configuration system that reads from YAML/TOML files and environment variables, allowing flexible deployment across different environments. Configuration includes provider credentials, tool definitions, permission settings, and logging options. The system supports configuration inheritance and defaults, reducing boilerplate for common setups.

Goose provides a framework for implementing custom LLM providers by implementing the Provider trait. Custom providers define how to authenticate, format requests, parse responses, and handle errors for a specific LLM API. The framework includes utilities for message format translation, token counting, and retry logic. Custom providers are registered in the canonical model registry.

Goose implements the Model Context Protocol (MCP) as a first-class extension mechanism, allowing developers to define tools as MCP servers that communicate via stdio or HTTP. The extension manager dynamically loads MCP servers, translates their tool definitions into Goose's canonical schema, and executes tool calls by sending requests to the MCP server. Built-in extensions (Developer, Computer Controller) are implemented as MCP servers, and custom MCP servers can be registered via configuration.

Goose provides shell command execution through the Computer Controller extension, which runs arbitrary shell commands in the user's environment with access to the full codebase. Commands are executed with the current working directory set to the project root, enabling the agent to run build tools, tests, git commands, and file operations. The agent can parse command output and use it to inform subsequent reasoning and tool calls.

Goose implements a permission system that controls which tools the agent can execute and how. Permissions are defined per tool with modes (auto-approve, require-approval, deny) and can be configured globally or per-session. When a tool requires approval, the agent pauses and prompts the user before execution. The system tracks permission decisions and can learn from user patterns to reduce approval friction over time.

Goose provides a recipe system that defines reusable, parameterized automation workflows as YAML configurations. Recipes specify a sequence of agent prompts, tool calls, and conditional logic that can be executed on-demand or scheduled via cron expressions. The recipe engine manages recipe execution, parameter substitution, and result persistence. Recipes can be composed (one recipe calling another) and support templating for dynamic prompt generation.

Goose manages agent sessions that persist conversation history, tool execution logs, and agent state across multiple invocations. Sessions are identified by unique IDs and can be resumed, allowing users to continue conversations with the agent. The session system stores full conversation context (messages, tool calls, results) and supports session export/import for sharing or archival. Context compaction strategies manage token budgets by summarizing old conversations.

Goose includes a built-in Developer extension (implemented as an MCP server) that provides code analysis and generation capabilities. The extension can read and write files, analyze code structure, run linters and formatters, and generate code based on specifications. It integrates with language servers (LSP) for semantic analysis and supports multiple programming languages through tree-sitter AST parsing.

Goose exposes an HTTP and WebSocket API that implements the Agent Communication Protocol (ACP), allowing external clients to interact with the agent remotely. The API supports starting conversations, sending messages, receiving agent responses, and managing sessions. WebSocket connections enable real-time bidirectional communication, while HTTP endpoints provide REST-style access. The API is documented via OpenAPI specification.

Goose provides an Electron-based desktop application that offers a graphical chat interface, settings management, and session/recipe management UI. The desktop app communicates with the Goose server via the ACP protocol, enabling local or remote agent access. The UI includes syntax-highlighted code display, tool execution visualization, and permission approval dialogs.