# Main Objectives of the Goose Project: Building a Native, Extensible AI Agent

> Discover the main objectives of the Goose project: a native AI agent with cross-platform support, LLM integration, and extensible protocols for a flexible AI ecosystem.

- Repository: [goose/goose](https://github.com/aaif-goose/goose)
- Tags: architecture
- Published: 2026-04-07

---

**The Goose project maintains four primary objectives: delivering a native cross-platform AI agent, supporting multiple entry points including CLI and desktop apps, enabling provider-agnostic LLM integration through the Agent Client Protocol, and fostering an extensible ecosystem via the Model Context Protocol.**

The `aaif-goose/goose` repository is an open-source AI agent framework written in Rust, designed to run locally across macOS, Linux, and Windows. Unlike cloud-dependent assistants, Goose emphasizes local execution, modular architecture, and user control through its four main objectives.

## Objective 1: Native, Cross-Platform AI Agent

Goose targets **native performance** without cloud-only dependencies. The core agent logic resides in the `crates/goose` crate, written in Rust for speed and portability across operating systems.

The architecture places shared functionality in [`crates/goose/src/lib.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose/src/lib.rs), which handles task orchestration and tool monitoring. Both the desktop interface and command-line tools depend on this crate, ensuring consistent behavior regardless of how users interact with the system.

## Objective 2: Multiple Entry Points for Flexible Interaction

Goose provides **three distinct interfaces** to accommodate different workflows:

- **Command-Line Interface (CLI):** Entry point at [`crates/goose-cli/src/main.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-cli/src/main.rs), parsing subcommands like `run` implemented in [`crates/goose-cli/src/commands/run.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-cli/src/commands/run.rs).
- **Desktop Application:** Electron-based client bootstrapped in [`ui/desktop/src/main.ts`](https://github.com/aaif-goose/goose/blob/main/ui/desktop/src/main.ts), offering a graphical interface.
- **HTTP API:** JSON-over-HTTP server defined in [`crates/goose-server/src/main.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-server/src/main.rs) for programmatic integration.

This multi-modal approach allows developers to script Goose in CI pipelines, interact with it via GUI, or embed it within other applications through the REST API.

## Objective 3: Provider-Agnostic LLM Support via the Agent Client Protocol

The **Agent Client Protocol (ACP)** enables Goose to support 15+ LLM providers including OpenAI, Anthropic, Google, Ollama, Azure, and AWS Bedrock. Rather than hardcoding vendor APIs, Goose defines a trait-based interface in [`crates/goose-acp/src/lib.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-acp/src/lib.rs).

New providers implement the `Provider` trait:

```rust
use goose_acp::{Provider, ProviderConfig, CompletionRequest};

pub struct CustomProvider;

#[async_trait::async_trait]
impl Provider for CustomProvider {
    async fn complete(&self, req: CompletionRequest) -> anyhow::Result<String> {
        Ok(format!("Echo: {}", req.prompt))
    }

    fn config(&self) -> ProviderConfig {
        ProviderConfig {
            name: "custom".into(),
            supports_chat: true,
            ..Default::default()
        }
    }
}

```

Registration occurs in [`crates/goose-cli/src/main.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-cli/src/main.rs), making the provider available via `--provider custom` immediately.

## Objective 4: Extensible Tool Ecosystem Through the Model Context Protocol

Goose implements the **Model Context Protocol (MCP)** to support 70+ community extensions for tasks like code search, data wrangling, and tool monitoring. Extensions reside in `crates/goose-mcp` and are discovered at runtime via a plugin registry.

The `ExtensionRegistry` aggregates capabilities:

```rust
use goose_mcp::{ExtensionRegistry, Extension};

fn main() -> anyhow::Result<()> {
    let registry = ExtensionRegistry::default();
    
    let agent = goose::Agent::builder()
        .with_extension_registry(registry)
        .build()?;

    let result = agent.execute("search my notes for \"budget\"")?;
    println!("{result}");
    Ok(())
}

```

Modules like `tool_inspection` and `tool_monitor` demonstrate how extensions hook into the agent's execution pipeline defined in [`crates/goose-mcp/src/lib.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-mcp/src/lib.rs).

## Running Goose from the Command Line

The CLI provides immediate access to the core agent. For example, summarizing a document:

```bash
goose run \
  --provider openai \
  --model gpt-4o-mini \
  --prompt "Summarize the following document:" \
  --input ./docs/project_spec.md

```

This command parses flags in [`crates/goose-cli/src/commands/run.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-cli/src/commands/run.rs) and forwards requests to `goose::Agent::execute` in the core crate.

## Summary

- **Native Performance:** Core Rust implementation in `crates/goose` ensures cross-platform speed without cloud dependencies.
- **Flexible Interfaces:** CLI (`crates/goose-cli`), Electron desktop (`ui/desktop`), and HTTP API (`crates/goose-server`) serve different user needs.
- **Provider Independence:** The Agent Client Protocol trait system in `crates/goose-acp` supports 15+ LLM backends through a pluggable adapter pattern.
- **Extensible Architecture:** The Model Context Protocol implementation in `crates/goose-mcp` enables runtime discovery of 70+ community extensions.

## Frequently Asked Questions

### What programming language powers the Goose AI agent?

Goose is written primarily in **Rust**, with the core logic housed in [`crates/goose/src/lib.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose/src/lib.rs). The desktop application uses TypeScript for the Electron frontend in [`ui/desktop/src/main.ts`](https://github.com/aaif-goose/goose/blob/main/ui/desktop/src/main.ts), while the backend server and CLI are pure Rust.

### How does Goose handle different LLM providers without vendor lock-in?

According to the source code in `aaif-goose/goose`, the project uses the **Agent Client Protocol (ACP)** defined in [`crates/goose-acp/src/lib.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-acp/src/lib.rs). This provides a `Provider` trait that abstracts LLM interactions, allowing users to swap between OpenAI, Anthropic, Ollama, or custom backends by implementing a single interface.

### Can developers add custom tools to extend Goose's capabilities?

Yes. Goose supports the **Model Context Protocol (MCP)**, which allows developers to create extensions that the agent discovers at runtime. Extensions live in `crates/goose-mcp` and integrate through the `ExtensionRegistry`, enabling capabilities like code search or custom tool monitoring without modifying core agent code.

### Is Goose suitable for self-hosted environments without internet connectivity?

Absolutely. One of the main objectives of the Goose project is **native, cross-platform execution** without cloud-only dependencies. When configured with local providers like Ollama, Goose runs entirely offline using the core Rust implementation in `crates/goose`, making it ideal for air-gapped or privacy-sensitive deployments.