How to Use Novita AI with Goose: 200+ LLM Models

Goose, the open-source AI agent with 45.5k GitHub stars, lets you run any LLM as a fully autonomous coding and workflow agent — and Novita AI is a native first-class provider, giving you access to 200+ models at a fraction of the cost of proprietary APIs.

What Is Goose?

Goose is a free, open-source AI agent that runs locally on macOS, Linux, and Windows. Built in Rust for low memory overhead and high performance, Goose goes beyond a code assistant — it can execute shell commands, install packages, edit files, run tests, browse the web, query databases, and automate complex multi-step workflows, all driven by the LLM of your choice.

Unlike ChatGPT or Claude’s web interfaces, Goose runs on your machine with full access to your local environment. It connects to the LLM via API and uses a powerful extension ecosystem (70+ MCP tools) to bridge text generation with real system actions.

Under the hood, Goose works as a three-component loop:

• Interface — Desktop app (GUI) or CLI
• Agent — Core loop that manages LLM calls, tool execution, and context
• Extensions — MCP-based tool servers (GitHub, Google Drive, shell, browsers, databases, and more)

Goose is maintained by AAIF (Agentic AI Foundation), part of the Linux Foundation, with 460+ contributors and active development.

Why Choose Novita AI for Goose?

200+ Models with Tool-Calling Support

Goose agents rely heavily on tool-calling — the LLM must reliably invoke shell commands, file edits, and API calls. The platform provides 200+ open-source models with tool-calling support, spanning context windows from 32K to 262K tokens. You can switch models per task without changing providers.

Last verified: 2026-04-20. Full model list at novita.ai/models.

Cost-Effective API Access

Proprietary model APIs (Claude, GPT-4o) cost $3–$15 per million input tokens. Open-source models on the platform start at $0.02 per million tokens, ranging up to $0.80 for capable agentic models, making long Goose sessions dramatically more affordable.

OpenAI-Compatible API

The API is fully OpenAI-compatible, meaning Goose can use it with zero custom code. The same base_url pattern works across all 200+ models with a single key.

First-Class Provider Support

It is listed as a native provider in Goose’s official documentation — no workarounds, no custom configuration required. Just goose configure, select Novita AI, and you’re running.

Installing Goose

macOS / Linux (recommended):

curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash

Homebrew:

brew install block-goose-cli

Windows: Download Goose-win32-x64.zip from the GitHub releases page and follow the setup prompts.

Verify the installation:

goose --version

Configuring Novita AI in Goose

Step 1: Get Your Novita AI API Key

• Sign up or log in at novita.ai
• Navigate to Settings → API Key Management
• Click Create New Key and copy it

Step 2: Connect Novita AI via goose configure

Run the interactive setup wizard:

goose configure

When prompted: select “Configure Providers” → choose “Novita AI” → enter your NOVITA_API_KEY → select a model.

Step 3: Verify the Configuration

Goose stores your config in ~/.config/goose/config.yaml (Linux/macOS). It should look like:

GOOSE_PROVIDER: "novita"
GOOSE_MODEL: "your-chosen-model-id"

Start a session to confirm:

goose session

Alternative: Environment Variable Setup

For CI/CD pipelines, Docker containers, or headless servers:

export GOOSE_PROVIDER=novita
export GOOSE_MODEL=your-chosen-model-id
export NOVITA_API_KEY=your_api_key_here
goose session

Environment variables take highest priority and override config.yaml.

One-off model override:

goose run --model deepseek/deepseek-v3.2 -t "Refactor this function for performance"

Working with Goose’s Features on Novita AI

Agentic Coding Sessions

Start a session and give Goose a high-level task — it handles tool calls automatically:

goose session
> Write a Python FastAPI service that reads from PostgreSQL and exposes a REST API.
  Set up the project structure, install dependencies, and add unit tests.

Goose will create directories, install packages via pip, write code, run tests, and iterate — all driven by the LLM backend.

Running Recipes (Shareable Workflows)

Goose Recipes are YAML files that define reusable, parameterized workflows. Your team can share and run the same recipe with the same model:

goose run --recipe ./code-review.yaml --params '{"repo_path": "./my-project"}'

Parallel Subagents

Goose supports spawning independent subagents for parallel tasks, each with isolated context. This is particularly effective with high-context models (200K+ tokens) that can hold large codebases in a single session.

Multi-Model Configuration

Set a separate planner model for high-level reasoning and an execution model for tool calls:

export GOOSE_PLANNER_PROVIDER=novita
export GOOSE_PLANNER_MODEL=your-reasoning-model
export GOOSE_PROVIDER=novita
export GOOSE_MODEL=your-execution-model

Goose vs. Other AI Agent Frameworks

Last verified: 2026-04-20

Conclusion

Goose is a highly capable open-source AI agent — 45.5k stars, 460+ contributors, and an active release cadence. With Novita AI as a native provider, you get access to 200+ open-source models with tool-calling support and pricing that makes long agentic sessions genuinely economical.

Whether you’re automating your dev workflow, running CI/CD-integrated code reviews, or building multi-agent research pipelines, the Goose + Novita AI combination gives you a production-grade setup in under 5 minutes.

Novita AI is a leading AI & agent cloud platform for developers, offering 200+ open-source models via OpenAI-compatible API, agent sandbox infrastructure, and GPU cloud — all through a single account.

Recommended Articles

• How to Use Claude Code with Novita AI — Connect Claude Code to 200+ open-source models via Novita AI
• How to Use Cursor with Novita AI — Configure Novita AI as your LLM backend in Cursor IDE
• How to Use Roo Code with Novita AI — Run Roo Code with Novita AI’s OpenAI-compatible API

FAQ