> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/block/goose/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction

> Learn about Goose, an open source AI agent framework for automating engineering tasks

## What is Goose?

Goose is your on-machine AI agent, capable of automating complex development tasks from start to finish. More than just code suggestions, goose can build entire projects from scratch, write and execute code, debug failures, orchestrate workflows, and interact with external APIs - autonomously.

<CardGroup cols={2}>
  <Card title="Multi-Model Support" icon="brain">
    Works with any LLM provider including OpenAI, Anthropic, Ollama, Databricks, and 30+ others
  </Card>

  <Card title="Extensible" icon="puzzle-piece">
    Integrate custom tools and capabilities via the Model Context Protocol (MCP)
  </Card>

  <Card title="Flexible Deployment" icon="server">
    Available as CLI, desktop app, or server API for seamless integration
  </Card>

  <Card title="Open Source" icon="code-branch">
    Apache 2.0 licensed - build custom distributions and extend freely
  </Card>
</CardGroup>

## Key Capabilities

### Autonomous Task Execution

Goose doesn't just suggest code - it can:

* Build entire projects from scratch
* Write, execute, and debug code
* Orchestrate complex workflows
* Interact with external APIs and tools
* Manage files and system operations

### Multi-Model Architecture

<Note>
  Goose is designed for maximum flexibility, supporting 30+ LLM providers with the ability to switch between models based on your needs and budget.
</Note>

Supported provider categories:

* **Cloud Providers**: OpenAI, Anthropic, Google, Azure, AWS Bedrock
* **Enterprise**: Databricks, Snowflake, GitHub Copilot
* **Local Inference**: Ollama, llama.cpp, local models
* **API Aggregators**: OpenRouter, Together.ai, Fireworks

See the [Providers concept](/concepts/providers) page for a complete list and configuration details.

### Extension System

Extend goose's capabilities through the Model Context Protocol (MCP):

```yaml theme={null}
extensions:
  - name: "filesystem"
    enabled: true
    transport:
      type: "stdio"
      command: "npx"
      args: ["-y", "@modelcontextprotocol/server-filesystem", "./"]
```

Extensions can provide:

* Custom tools for domain-specific tasks
* Access to external data sources
* Integration with APIs and services
* Workflow automation capabilities

Learn more in the [Extensions guide](/guides/mcp-integration).

### Recipe System

Automate complex workflows with reusable recipes:

```yaml theme={null}
name: "api-development"
description: "Build a REST API with authentication"
parameters:
  - name: "language"
    type: "string"
    description: "Programming language to use"
instructions: |
  Build a REST API in {{language}} with:
  - User authentication (JWT)
  - CRUD endpoints
  - Input validation
  - Error handling
  - Tests
```

Recipes support:

* Parameterization with Jinja2 templating
* Sub-recipes for modular workflows
* Structured output validation
* Version control and distribution

Explore the [Recipes concept](/concepts/recipes) for more details.

## Use Cases

<AccordionGroup>
  <Accordion title="Full-Stack Development">
    Build complete applications from requirements to deployment:

    * Generate project scaffolding
    * Implement features across frontend and backend
    * Write tests and fix bugs
    * Deploy to production
  </Accordion>

  <Accordion title="Code Refactoring">
    Modernize and improve existing codebases:

    * Migrate to new frameworks or languages
    * Apply design patterns
    * Optimize performance
    * Update dependencies
  </Accordion>

  <Accordion title="DevOps Automation">
    Streamline deployment and infrastructure tasks:

    * Create CI/CD pipelines
    * Configure containerization
    * Manage cloud resources
    * Monitor and troubleshoot systems
  </Accordion>

  <Accordion title="Documentation">
    Generate and maintain project documentation:

    * API documentation from code
    * README files and guides
    * Code comments and docstrings
    * Architecture diagrams
  </Accordion>
</AccordionGroup>

## Architecture Overview

Goose is built on a modular architecture that separates concerns:

```mermaid theme={null}
graph TB
    UI[User Interfaces<br/>CLI / Desktop / Custom]
    Server[Goose Server<br/>REST API]
    Core[Core Framework<br/>Agent Engine]
    Providers[LLM Providers<br/>30+ Integrations]
    Extensions[Extensions<br/>MCP Tools]
    
    UI --> Server
    Server --> Core
    Core --> Providers
    Core --> Extensions
```

* **User Interfaces**: CLI, desktop app, or custom UIs via REST API
* **Server Layer**: Optional REST API for remote access and integration
* **Core Framework**: Agent logic, session management, and orchestration
* **Providers**: LLM integrations with unified interface
* **Extensions**: Tool ecosystem via MCP protocol

See the [Architecture concept](/concepts/architecture) for an in-depth explanation.

## Getting Started

Ready to start using goose? Follow our quickstart guide:

<Card title="Quickstart Guide" icon="rocket" href="/quickstart" horizontal>
  Install goose and run your first AI agent session in minutes
</Card>

## Community

Join the goose community to get help, share projects, and contribute:

<CardGroup cols={2}>
  <Card title="Discord" icon="discord" href="https://discord.gg/goose-oss">
    Join our Discord server for real-time chat and support
  </Card>

  <Card title="GitHub" icon="github" href="https://github.com/block/goose">
    Contribute code, report issues, and star the project
  </Card>
</CardGroup>

## Open Source

Goose is licensed under Apache 2.0, allowing you to:

* Use goose for any purpose, commercial or personal
* Modify and customize the codebase
* Create custom distributions with your branding
* Integrate goose into your products and services

See [Custom Distributions](/advanced/custom-distributions) to learn how to build white-labeled versions of goose for your organization.