Goose
Goose is an open-source autonomous AI coding agent that runs on your machine, reads your code, edits files, runs commands, and iterates with you on software tasks. It operates locally with direct filesystem access, supporting both interactive and headless modes while you maintain control over every action.
itArtificial intelligence and machine learning | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Goose
Goose is a coding agent that lives on your machine and is willing to read files, change them, and run commands after you ask. That makes it more useful than a box that suggests the next few characters, and more demanding than one too. The important unit is not the sentence it writes. It is the sequence it starts: request, inspection, proposed action, review, and another request when the result needs work.
The familiar pre-Goose routine is a person opening files, running a command, changing code, and discovering what the test suite thinks of the plan. Goose can carry part of that routine across a session. It remembers the work it has inspected and the request it is pursuing, which is handy because software projects are rarely improved by one isolated clever line. It is less handy if the request is vague, because the agent has no ceremonial bell that rings when a human decision has been smuggled into a prompt.
Interactive mode is the close-up version: the terminal shows proposed changes and commands while you review them. Headless mode removes that terminal interface for scripted work and CI pipelines. The machinery lives in the Goose configuration directory, where provider settings and tool policies decide what the agent can connect to. .goosehints adds project conventions, build commands, and architectural guidance from the project root down to the current directory, so the agent has fewer excuses to mistake local habits for archaeology.
Extensions are where Goose stops being only a code reader. Built-in extensions handle development work; stdio extensions run locally; remote extensions connect over HTTP through MCP. That expands what a task can reach, which is excellent news right up to the moment it becomes a reason to stop reading approval prompts. Approval policies and restricted shell commands exist because direct filesystem and shell access are capabilities, not decorations on a chat window.
Read the Introduction when you need the full map of sessions, modes, configuration, extensions, and security choices. Use the Slides for the short route through their relationships. Keep the Cheatsheet nearby when the question is a command, a configuration location, or an extension type. The Quiz tests whether the mental model has survived contact with four plausible answers. Then try a small, inspectable task, review what changes, and retain ownership of the code. The goose is helpful. It does not become responsible for the branch merely by standing near it.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://github.com/aaif-goose/goose
Supports
- Installation methods (Homebrew, Cargo, desktop app)
- CLI commands and options
- Configuration file structure
- .goosehints discovery rules
- Extension system architecture
- Running modes (interactive, headless)
- Security considerations
- https://block-goose.mintlify.app/installation
Supports
- CLI installation guide
- Desktop application setup
- Platform-specific instructions
- Initial configuration
- https://block-goose.mintlify.app/concepts/extensions
Supports
- Extension types (built-in, stdio, remote)
- MCP integration
- Tool configuration
- Extension development
- https://block-goose.mintlify.app/guides/mcp-integration
Supports
- MCP server configuration
- Authentication methods
- Tool registration
- Best practices
- https://block-goose.mintlify.app/api/extensions/builtin
Supports
- Built-in extension capabilities
- File operations
- Shell execution
- Code editing
- https://modelcontextprotocol.io/
Supports
- MCP architecture and concepts
- Server configuration
- Protocol integration
- Tool and resource definitions
- https://github.com/shakahl/aaif-goose/blob/main/documentation/docs/guides/context-engineering/using-goosehints.md
Supports
- .goosehints file format
- Context engineering patterns
- Project instruction examples
- Discovery mechanism
- https://formulae.brew.sh/formula/block-goose-cli
Supports
- Installation command
- Version history
- Dependencies
- https://goose-docs.ai/blog/2025/12/28/goose-maintains-goose/
Supports
- Task phases for agent-driven maintenance
- Verification and confirmation practices
- https://goose-docs.ai/blog/2025/03/06/goose-tips/
Supports
- Context cost of active extensions
- Focused session and extension practices
- https://goose-docs.ai/blog/2026/03/31/adversary-mode/
Supports
- Approval fatigue
- Adversary mode as a security layer
- https://github.com/aaif-goose/goose/discussions/7159
Supports
- Risk from untrusted content in privileged sessions
- Read-only delegates with filtered extensions
- https://engineering.block.xyz/blog/how-we-red-teamed-our-own-ai-agent-
Supports
- Red-team lessons for Goose
- Limits of context isolation by instruction alone
- https://goose-docs.ai/
Supports
- Current Goose product documentation
- https://www.anthropic.com/claude-code
Supports
- Claude Code product and access information
- https://openai.com/codex/
Supports
- Codex product and access information
- https://cursor.com/
Supports
- Cursor product and access information
- https://aider.chat/
Supports
- Aider product and licensing information
