# What Programming Language Is Goose Written In? A Deep Dive into the Rust-Based AI Agent Framework

> Discover what programming language Goose, the AI agent framework, is written in. Explore its Rust foundation and learn how its components are built with Cargo workspaces.

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

---

**Goose is written primarily in Rust**, utilizing a Cargo workspace architecture with all core components—including the agent logic, CLI, server, and SDK—implemented as Rust crates.

The `aaif-goose/goose` repository is an AI agent framework designed for performance and portability. According to the project's own documentation in [`AGENTS.md`](https://github.com/aaif-goose/goose/blob/main/AGENTS.md), Goose is "an AI agent framework **in Rust** with CLI and Electron desktop interfaces," while the [`README.md`](https://github.com/aaif-goose/goose/blob/main/README.md) confirms it is "Built **in Rust** for performance and portability." The entire codebase compiles under a unified Cargo workspace defined in the top-level [`Cargo.toml`](https://github.com/aaif-goose/goose/blob/main/Cargo.toml).

## Evidence from the Source Code

### Workspace Structure and Configuration

The repository root contains a [`Cargo.toml`](https://github.com/aaif-goose/goose/blob/main/Cargo.toml) file that defines a Rust workspace, listing all member crates under the `crates/` directory. This configuration confirms that Rust is the sole programming language used for the core implementation. The workspace includes crates for the core agent, CLI binary, HTTP server, MCP extensions, and the embeddable SDK.

### Core Implementation Files

All source files use the `.rs` extension, confirming Rust as the implementation language:

- **[`crates/goose/src/agents/agent.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose/src/agents/agent.rs)** – Contains the core agent implementation handling conversation flow, tool orchestration, and session management
- **[`crates/goose-cli/src/main.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-cli/src/main.rs)** – Entry point for the command-line interface binary
- **[`crates/goose-server/src/main.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-server/src/main.rs)** – Entry point for the HTTP server backend
- **[`crates/goose-sdk/examples/acp_client.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-sdk/examples/acp_client.rs)** – Demonstrates SDK usage for embedding Goose in other Rust applications

## Architectural Components Written in Rust

The Goose codebase is organized into distinct Rust crates, each serving a specific architectural layer:

- **Core Agent Logic** – Located in `crates/goose/`, this crate handles conversation flow, tool orchestration, retry logic, security features, and session management
- **CLI Interface** – The `crates/goose-cli/` crate provides the user-facing command-line interface, with the main entry point at [`src/main.rs`](https://github.com/aaif-goose/goose/blob/main/src/main.rs)
- **Server Backend** – `crates/goose-server/` implements an HTTP API using the Axum web framework, exposing the agent for external clients
- **MCP Extensions** – The `crates/goose-mcp/` crate implements the plugin system using the Model Context Protocol
- **Rust SDK** – `crates/goose-sdk/` provides a library for embedding Goose functionality in other Rust projects
- **Test Utilities** – Supporting crates like `goose-test/` and `goose-test-support/` provide integration testing frameworks

## Working with Goose's Rust Codebase

### Using the SDK in Rust Applications

The Goose SDK allows you to embed agent capabilities directly into Rust programs. The following example from [`crates/goose-sdk/examples/acp_client.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-sdk/examples/acp_client.rs) demonstrates spawning a Goose binary and querying available extensions:

```rust
use goose_sdk::custom_requests::GetExtensionsRequest;
use sacp::Client;

// A minimal async function that starts a Goose ACP session and prints available extensions.
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Spawn the Goose binary (assumes `goose` is on $PATH)
    let child = goose_sdk::acp::spawn_goose_binary().await?;
    let transport = child.transport();

    // Connect the ACP client
    let client = Client::builder()
        .name("sdk-example")
        .on_receive_notification(|_, _| Ok(()), sacp::on_receive_notification!())
        .connect_with(transport, async move |cx| {
            // Initialise the agent
            cx.send_request(sacp::schema::InitializeRequest::new(
                sacp::schema::ProtocolVersion::LATEST,
            ))
            .await?;

            // Query installed extensions
            let resp = cx.send_request(GetExtensionsRequest {}).await?;
            println!("Installed extensions: {:?}", resp.extensions);
            Ok(())
        })
        .await?;

    client.shutdown().await;
    Ok(())
}

```

### Building and Running the CLI

Since Goose is a Rust project, you compile and install it using Cargo. The CLI logic resides in [`crates/goose-cli/src/main.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-cli/src/main.rs):

```bash

# Install the latest binary from the local source

cargo install --path crates/goose-cli

# Show the help menu to verify installation

goose --help

# Start an interactive chat session

goose

```

### Embedding the HTTP Server

The Goose server is implemented as an Axum-based HTTP API. You can embed it directly in Rust applications using the server crate:

```rust
use goose_server::server::run_server;

#[tokio::main]
async fn main() {
    // The server reads the global config and starts an HTTP API on port 8080.
    run_server().await.expect("Failed to start Goose server");
}

```

The server entry point is defined in [`crates/goose-server/src/main.rs`](https://github.com/aaif-goose/goose/blob/main/crates/goose-server/src/main.rs).

## Summary

- **Goose is implemented entirely in Rust**, using a Cargo workspace structure for modular development.
- The repository `aaif-goose/goose` organizes code into specialized crates under the `crates/` directory.
- Core components—including the agent logic (`crates/goose/`), CLI (`crates/goose-cli/`), server (`crates/goose-server/`), and SDK (`crates/goose-sdk/`)—are all Rust-based.
- Documentation in [`AGENTS.md`](https://github.com/aaif-goose/goose/blob/main/AGENTS.md) and [`README.md`](https://github.com/aaif-goose/goose/blob/main/README.md) explicitly confirms the Rust implementation choice for performance and portability.
- The project compiles as a unified workspace defined in the top-level [`Cargo.toml`](https://github.com/aaif-goose/goose/blob/main/Cargo.toml).

## Frequently Asked Questions

### Is Goose written entirely in Rust?

Yes, the core Goose framework is written entirely in Rust. All agent logic, CLI tools, HTTP server, MCP extensions, and the SDK are implemented as Rust crates within a Cargo workspace. The [`Cargo.toml`](https://github.com/aaif-goose/goose/blob/main/Cargo.toml) workspace configuration and the presence of `.rs` source files throughout the repository confirm this.

### Why did Goose choose Rust as its programming language?

According to the project's [`README.md`](https://github.com/aaif-goose/goose/blob/main/README.md), Goose chose Rust for **performance and portability**. Rust's memory safety guarantees, zero-cost abstractions, and ability to compile to native binaries across platforms make it ideal for an AI agent framework that requires reliable, high-performance execution.

### Can I extend Goose using other programming languages?

While Goose's core is written in Rust, it exposes interfaces that may allow interaction with other languages. The Model Context Protocol (MCP) extensions in `crates/goose-mcp/` provide a plugin system that could theoretically support extensions written in other languages, though the primary extension mechanism and all core APIs are Rust-based.

### How do I build Goose from source?

Since Goose is a Rust project, you build it using Cargo. Clone the `aaif-goose/goose` repository and run `cargo build --release` from the workspace root. Individual components can be installed using `cargo install --path crates/goose-cli` for the CLI or `cargo install --path crates/goose-server` for the server binary.