Install Goose with Ollama Locally: Extensible On‑Device AI Agent

Goose is an on-device, open-source AI agent designed to automate complex development workflows. It goes far beyond simple code suggestions: it can create full software projects, execute and debug code, interact with APIs, and coordinate engineering tasks across a pipeline.

In this guide, I install and run Goose locally with Ollama-based models for a private, offline setup. The Goose team recommends Claude 4 models for their code capabilities, but my goal here is to show a fully local configuration with Ollama. I’ll walk through installation, provider configuration, basic usage, recipes, the scheduler, extensions, and the core architecture that makes Goose practical for real work.

If you want to keep everything on your machine, this setup keeps data local while still giving you a capable agent for code and automation.

What is Goose with Ollama?

Goose integrates directly into your development environment as a desktop application or via CLI. It supports multiple LLM providers, and you can connect it through the Model Context Protocol (MCP) for interoperability with other tools and systems.

At its core, Goose acts as an autonomous developer assistant. It adapts to your workflows, handles repeatable tasks, and can manage everything from quick prototypes to larger, multi-step automations.

While Goose works with local and API-based models, performance and capabilities will vary by model. Larger API models often produce stronger results due to their size and training. This article focuses on running Goose locally with Ollama to keep the workflow private and offline.

Goose with Ollama Overview

Key Features of Goose

• Autonomous coding agent that plans, executes, and iterates within an agent loop.
• Desktop UI and CLI for flexible workflows.
• Multi-model provider support, including local Ollama models.
• MCP-based extensions for tools such as file I/O, code execution, and API access.
• Recipes to define reusable agent behaviors and task templates.
• Scheduler to run scripts and automations on a timetable.
• Memory features to maintain long-term context across sessions.

Install Locally with Ollama

You can install Goose on macOS, Linux, or Windows. I’m using Ubuntu with a downloaded .deb package and running models through Ollama. A GPU helps for larger local models, but Goose also works with smaller CPU-friendly models. If you use API-based models, you don’t need a GPU.

Goose runs well with API models due to their capacity. For a fully local setup, Ollama makes it practical to keep everything on your system.

Prerequisites

• Operating system: macOS, Linux, or Windows.
• For local models: Ollama installed and running.
• Hardware: GPU recommended for larger models; CPU is sufficient for small models.
• Network: Not required for local-only usage, except to download the app and models.

Download and Install

You’ll find installers for macOS (.dmg), Linux (.deb/.rpm/AppImage), and Windows (.exe) on the official install page. After downloading, use the platform-specific steps below.

Ubuntu/Debian

1. Open a terminal in the folder where the .deb file was downloaded.
2. Install the package:

   sudo dpkg -i goose_<version>.deb

3. If dpkg reports missing dependencies, run:

   sudo apt -f install

4. Launch Goose:

   goose

   You might see minor warnings in the terminal; they don’t block the app from starting.

macOS

1. Open the .dmg and drag the app to Applications.
2. Launch Goose from Applications or Spotlight.

Windows

1. Run the .exe installer.
2. Launch Goose from the Start menu.

Launch Goose and Configure Providers

When Goose launches, you’ll see provider options. By default, an API provider may appear selected. Since we want a local setup, we’ll add and prioritize Ollama.

Add Ollama

• Go to Settings → Providers.
• Choose Ollama and click Configure.
• Set the host to:
  • Host: http://localhost
  • Port: 11434
• Submit the configuration. You should see a success indicator.

Make sure the Ollama service is running. If you haven’t set up any models yet, pull one before selecting it in Goose:

# Install Ollama (if not installed) from the official site
# Then pull a model to use locally, for example:
ollama pull gpt-oss:20b
# or pull a lighter model if you’re on CPU
ollama pull codellama:7b

Switch Models

• Go to Settings → Switch Models.
• Select your provider: Ollama.
• Choose a model (e.g., a coder-focused model or your custom local model name).
• Save the selection to make it the default for new sessions.

Note: The specific model names depend on what you’ve pulled into Ollama (for example, gpt-oss:20b, codellama:13b, or another local model you prefer).

Run a Quick Task Locally

With Ollama configured as the provider and a local model selected, open a new session in the Goose interface:

1. Start a chat and confirm the agent responds.
2. Give it a practical request. For instance, ask for a self-contained HTML file for a fireworks animation.
3. Goose will plan, create the file, and write it to your local system.

Output quality depends on your model. Larger or more capable models typically produce stronger code. The interface is straightforward; at the time of testing, theme options like dark mode weren’t visible.

GUI and CLI Options

The desktop app is easy to use for most workflows. Goose also includes a CLI, which is useful for scripting and headless environments. You can launch sessions, run recipes, and integrate Goose into your terminal-based tooling.

If you prefer the CLI approach, install the package as above and then invoke the Goose command from your shell. From there, you can pass tasks or run saved recipes.

Recipes

Recipes allow you to define agent behaviors and capabilities that you can reuse. Instead of typing your requirements every time, you save them once and run them whenever you need that specific behavior.

Common use cases include saving prompts for language preferences, coding standards, or project scaffolding rules. You can build a recipe for a particular role (for example, a JavaScript-focused agent) and then reuse it across sessions.

Create and Save a Recipe

• Open the Recipes section.
• Click Create Recipe.
• Define the agent’s role, objectives, constraints, and any tools or extensions it should use.
• Save the recipe with a clear name.
• Run the recipe from the Recipes menu when needed.

Scheduler

The Scheduler lets you run scripts and automations on a timetable. You can configure a task, choose a schedule, and have Goose execute it on demand or at recurring intervals. This is handy for routine code maintenance, file generation, or timed builds.

Extensions and MCP

Extensions expand Goose’s abilities with tools and functions. They enable actions such as running code, managing files, interacting with external APIs, and visualizing outputs.

Goose follows the MCP standard for its extensions. That interoperability makes it easier to connect Goose with other systems that speak MCP. If your workflow depends on specific tools, look for or develop extensions that expose those tools as MCP-compatible interfaces.

On the extensions page, you can enable or disable capabilities like developer mode, memory persistence, and visualization aids. Configure only what you need to keep the system focused and efficient.

Common Extension Capabilities

• Code execution in supported runtimes.
• File and directory operations for project work.
• API calls for external services through MCP-enabled connectors.
• Visualization features to inspect outputs or intermediate steps.
• Memory settings to retain context across sessions and tasks.

Architecture at a Glance

Goose centers on three main components: the interface, the agent, and extensions.

Interface

The desktop UI collects your input and displays results, logs, and artifacts. It’s where you configure providers, choose models, manage recipes, and monitor the agent’s progress. You can refine tasks directly in the chat, which feeds the agent update loop.

Agent

The agent manages an interactive loop that governs planning, action, observation, and iteration. It decides what to do next based on your instructions and the tools available through extensions. This loop allows it to draft code, run it, check results, and fix issues in the next step.

Extensions

Extensions act as the agent’s hands and eyes. They provide concrete actions like running code, editing files, calling APIs, and connecting to other systems over MCP. By adding or removing extensions, you define what the agent can and cannot do in your environment.

End-to-End Setup: Step-by-Step Summary

Follow these steps to reproduce a private, local setup with Ollama:

1. Install Goose:

   • macOS: Install the app from the .dmg.
   • Linux (Ubuntu/Debian): sudo dpkg -i goose_<version>.deb then sudo apt -f install if needed.
   • Windows: Run the .exe installer.

2. Install Ollama and pull a model:

   # Install Ollama per your OS
   # Pull a local model to use with Goose
   ollama pull gpt-oss:20b      # larger, stronger
   # or
   ollama pull codellama:7b     # lighter, CPU-friendly

3. Launch Goose and configure Ollama:

   • Settings → Providers → Ollama → Configure.
   • Host: http://localhost, Port: 11434 → Submit.

4. Choose your model:

   • Settings → Switch Models → Provider: Ollama → Select model.
   • Save as default.

5. Run a task:

   • Open a new chat.
   • Request a concrete deliverable (e.g., a self-contained HTML file).
   • Inspect generated files on your local system.

6. Optional: Set up your workflow tools:

   • Build a Recipe with your coding standards and goals.
   • Enable Extensions you need for code execution and file operations.
   • Configure the Scheduler for recurring tasks.
   • Toggle memory settings for longer-lived context.

Notes on Models and Performance

• Local model size: Larger models tend to produce better code but require more VRAM and CPU/GPU resources.
• CPU-only usage: Choose a smaller model if you don’t have a GPU or want to keep resource use low.
• API-based models: If you switch to an API provider, expect stronger performance and capabilities with larger models. This can be helpful for complex tasks that local models may struggle with.
• Quality varies by model: If results aren’t great, try a different model or adjust your instructions to be more specific.

Privacy and Local-Only Workflows

Running Goose with Ollama keeps inputs, outputs, and artifacts on your machine. This is useful for sensitive projects or environments where external data sharing isn’t acceptable. Extensions and file operations remain local unless you explicitly connect an external API provider.

Troubleshooting

• App warnings at launch: Minor terminal warnings typically don’t block usage.
• No response from Ollama: Confirm the service is running and the host is set to http://localhost:11434.
• Model not listed in Goose: Make sure you pulled it with Ollama and that the name matches.
• Slow performance: Switch to a smaller model, close unused apps, or run on a machine with more RAM/VRAM.

Conclusion

Goose is a capable coding agent that can plan, write, execute, and refine code across an end-to-end workflow. Configured with Ollama, it runs locally and privately while still offering a flexible toolset through extensions, recipes, a scheduler, and MCP-based integrations. If you need an autonomous assistant that fits into your development environment and keeps work on your machine, this setup delivers a practical path without relying on external APIs.