Goose + Ertas

Build coding agents with Goose — Block's open-source agent that runs on the desktop with extensible tooling, configurable to call Ertas-trained code models running locally for zero-cost engineering automation.

Overview

Goose is Block's open-source coding agent, originally developed inside Cash App and Square engineering and released to the broader community in 2025. It is designed to run locally on a developer's machine, connect to whatever models the user prefers, and automate engineering tasks through an extensible tool system based on the Model Context Protocol (MCP). Goose is positioned squarely against closed-source competitors like Cursor and Windsurf — same coding-agent value proposition, but open source and bring-your-own-model.

The framework's defining traits are extensibility and model-agnosticism. Goose's tools (called 'extensions') are MCP servers, which means any MCP-compatible tool — file system access, GitHub APIs, JIRA integration, custom company tools — can be added to the agent without modifying Goose itself. The model layer is configurable across Anthropic, OpenAI, Google, AWS Bedrock, Databricks, and any OpenAI-compatible endpoint, including local Ollama and vLLM servers.

For teams that want Cursor-style productivity without the per-seat subscription costs and without sending their codebase to a third-party API, Goose is the most credible open-source path. The combination of MCP extensibility, model flexibility, and desktop-native deployment makes it particularly attractive to engineering organizations with strong code-confidentiality requirements.

How Ertas Integrates

Ertas-trained code models work with Goose through its OpenAI-compatible model provider. After fine-tuning a code-specialized model in Studio (Qwen3-Coder-Next, CodeLlama, StarCoder, or a custom base) and exporting to GGUF, you serve it via Ollama or vLLM and configure Goose to call your endpoint. Goose's coding-agent loop, MCP extensions, and tool calls all run against your fine-tuned model.

The combination is particularly valuable for engineering teams with codebase-specific patterns. A general-purpose code model produces code that follows generic conventions; an Ertas-trained model whose training data includes the team's actual code, tests, and review patterns produces code that fits the codebase's style, uses the codebase's internal libraries correctly, and follows the team's specific testing conventions. For teams with substantial internal code, the productivity delta is meaningful — autocompletions and agent-generated code that match local patterns reduce review burden and improve merge rates.

For enterprises that need on-premise development tooling for regulatory or IP-protection reasons, Goose + Ertas-trained model on local infrastructure removes the cloud dependency entirely. No code leaves the building, no API tokens are billed, and the agent improves over time as the team's traces feed back into Studio for incremental fine-tuning.

Getting Started

1
Fine-tune a code model in Ertas Studio
Use a code-specialized base (Qwen3-Coder-Next, CodeLlama, Devstral 2). Train on your codebase, internal libraries, test patterns, and code-review history. Studio handles the code-token training format natively.
2
Deploy to an OpenAI-compatible endpoint
Export to GGUF and serve via Ollama or vLLM on a development machine, build server, or shared GPU host. Goose calls any OpenAI-compatible endpoint.
3
Install Goose and configure the provider
Install Goose's desktop client. In configuration, set the provider to 'openai' with the base URL pointing at your Ertas inference endpoint and your model name.
4
Add MCP extensions for your tooling
Goose's tools are MCP servers. Add file system, GitHub, JIRA, and custom company tool extensions. Each is configured independently and the agent picks them up automatically.
5
Use Goose for coding tasks and feed traces back
Run Goose against engineering tasks: refactoring, test writing, bug fixing, code review. Tracing data captures the patterns your team values, which feeds back into the next Studio fine-tuning round.

yaml

# ~/.config/goose/config.yaml — point Goose at your Ertas-trained code model

provider: openai
model: ertas-codebase-specialist-14b

openai:
  base_url: http://localhost:11434/v1
  api_key: not-needed

extensions:
  - name: developer
    type: builtin  # filesystem, shell, etc.
  - name: github
    type: stdio
    cmd: npx
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_TOKEN: ${GITHUB_TOKEN}
  - name: company-jira
    type: sse
    url: http://internal-tools/mcp/jira/sse

# Run from terminal:
#   goose session --name "feature-XYZ"
#   > Add a rate limiter to the public API endpoints. Follow our middleware patterns.

Configure Goose to use an Ertas-trained 14B code model fine-tuned on your codebase, with GitHub and company JIRA extensions for full engineering workflow automation.

Benefits

Open-source coding agent — no per-seat subscription costs
Bring-your-own-model — works with any OpenAI-compatible endpoint
MCP-based extensibility — add any company tool without modifying Goose
Desktop-native — your code stays on your machine
Pairs naturally with fine-tuned code models for codebase-specific competence
Strong fit for enterprises with code-confidentiality or IP-protection requirements
Active development backed by Block's engineering investment