What versions of Go does Goose support?

Goose does not require, support, or depend on any specific Go version because the project is implemented entirely in Rust, though you can interact with the AI agent from Go applications via its CLI or HTTP API endpoints.

The aaif-goose/goose repository is an AI agent framework and desktop application built primarily in Rust, not Go. Despite its name suggesting a potential connection to the Go programming language (often called Golang), the codebase contains no Go source files, version constraints, or Go module definitions.

Why Goose has no Go version requirements

Goose is a Rust-centric project. The source code resides under the crates/ directory with standard Rust project files (Cargo.toml, Cargo.lock), and the build system relies entirely on Cargo.

• No Go source files: The repository contains no go.mod, go.sum, or *.go files that would indicate Go language support or version constraints.
• Rust toolchain only: Continuous integration workflows in .github/workflows/*.yml configure Rust toolchains (specifically Rust 1.78+ as of the current CI configuration) via dtolnay/rust-toolchain, with no references to Go versions or the Go toolchain.
• Generic tool reference: The only mention of Go appears in recipe-scanner/base_recipe.yaml, which lists go get as a generic development tool for fetching modules. This is unrelated to Goose's own compilation or runtime requirements.

How to integrate Goose with Go applications

While Goose itself requires no Go version, you can invoke it from Go projects using two primary integration patterns.

Executing the Goose CLI from Go

Since Goose installs as a binary (goose) and a desktop application (goose-desktop), you can execute it from Go using standard library process execution.

package main

import (
    "os"
    "os/exec"
)

func runGoose(prompt string) error {
    cmd := exec.Command("goose", "run", prompt)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    return cmd.Run()
}

Your Go version has no impact on Goose's execution; any modern Go release capable of os/exec operations will suffice.

Using the MCP HTTP API

Goose exposes functionality via the Model Context Protocol (MCP) HTTP server. You can interact with this API from Go using standard HTTP clients without version constraints.

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func queryGooseServer(endpoint string, payload map[string]interface{}) (*http.Response, error) {
    jsonData, _ := json.Marshal(payload)
    return http.Post(endpoint, "application/json", bytes.NewBuffer(jsonData))
}

Actual system requirements for Goose

To build or run Goose from source, you need the Rust toolchain rather than Go.

• Rust 1.78+: As specified in the project's CI workflows and Cargo configuration, Goose requires Rust version 1.78 or newer to compile the crates/ workspace.
• Cargo: The build and dependency management rely on Cargo commands (cargo build, cargo run), not go build or Go modules.

Summary

• Goose contains no Go code and therefore defines no supported Go versions.
• The project is a Rust codebase requiring Rust 1.78+ to build from source.
• You can invoke Goose from any Go version via CLI execution or HTTP API calls to the MCP server.
• The only Go reference in the repository is a generic tool mention in recipe-scanner/base_recipe.yaml.

Frequently Asked Questions

Is Goose written in Go?

No. Goose is written in Rust, with source code organized under the crates/ directory. The project uses Cargo for builds and dependency management, not Go modules.

Can I use Goose with my Go application?

Yes. While Goose is not written in Go, you can integrate it into Go applications by executing the goose CLI binary via os/exec or by making HTTP requests to Goose's MCP server endpoint. The Go version you use in your application does not affect Goose's operation.

What programming language is Goose built with?

Goose is built with Rust. The repository includes Cargo.toml files and Rust source files within the crates/ directory, requiring the Rust toolchain (version 1.78+) for compilation.

Do I need to install Go to build Goose from source?

No. Building Goose from source requires only the Rust toolchain (Rust 1.78+ and Cargo). Go is not required for compilation, development, or running the Goose binary.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}