Build vs Buy: Should Your Team Build Its Own AI Coding Harness?

Published August 23, 2026 · by the AQ team

Most engineering teams should not build their own AI coding harness. The results that make in-house harnesses look mandatory (agents that run real tests, read production telemetry, check feature flags, and verify their own work) come mostly from where the harness runs and what it is allowed to reach: a full development environment inside the company's network, holding real credentials. That is a property of the execution environment, not of owning the agent loop. A team that runs vendor CLIs like Claude Code or Codex on its own infrastructure, with internal systems wired in through MCP, captures most of the same advantage without staffing a harness team. Building from scratch makes sense only for companies with unusual scale, unusual workflows, and engineers to spare.

Why this question is suddenly live

The trigger is Ramp. In January 2026 Ramp published "Why We Built Our Own Background Agent" on its engineering blog, introducing Inspect: an internal background coding agent running each session in a sandboxed VM with everything an engineer would have locally, wired into Sentry, Datadog, LaunchDarkly, GitHub, Slack, and Buildkite. At announcement, roughly 30 percent of merged pull requests to Ramp's frontend and backend repositories were written by Inspect; public case studies since put the share above half as of mid 2026. The story spread precisely because Ramp had access to Claude Code and Codex and built anyway.

Since then, "do serious companies build their own harness?" has become a recurring argument on Hacker News and X. One side points at Inspect's numbers; the other notes that frontier labs ship harness improvements weekly and an internal tool must keep up forever. The way through is to unbundle what an in-house harness actually buys.

What Ramp actually bought by building

Strip Inspect down to the properties that generated its results and you get a short list:

• A real development environment. Each session runs in a sandboxed VM that mirrors what an engineer has: dependencies installed, services reachable, tests runnable.
• Internal integrations. The agent reads error trackers, monitoring, and feature flags because it holds credentials for them and runs somewhere that can reach them.
• The verification loop. Because both properties above hold, the agent can make a change, run the tests, check telemetry, and look at the result.
• Workflow fit. Intake from the tools the team already uses, output as ordinary pull requests, visible to everyone.

Notice what is not on the list: a proprietary agent loop. The loop (prompting, tool calling, context management) is the part vendors and open source have commoditized. What made Inspect work is that it runs inside Ramp's world with Ramp's access: the advantage is placement and credentials, not authorship.

What building actually costs

The build side of the ledger is easy to underestimate, because the demo is the cheap part.

The harness is a product, not a project. Martin Fowler's April 2026 essay on harness engineering frames a harness as feedforward guides plus feedback sensors, and stresses that it is an ongoing discipline: a harness encodes assumptions about what current models cannot do, so every model generation invalidates part of it. Anthropic's own engineering posts on harness design for long-running agents (late 2025 through March 2026) say the same from the vendor side: continuous redesign, not a fixed recipe.

You are racing the vendors' roadmaps. As of August 2026, Claude Code alone ships hooks for deterministic policy enforcement, MCP client support, subagents, skills, sandboxing, and managed enterprise settings, and it changes monthly. An internal harness team signs up to reimplement or deliberately skip every one of those, forever, while also chasing model releases.

Evaluation is the hidden line item. An internal harness needs its own evals to know whether a model upgrade helped or hurt, because published benchmarks measure a model inside someone else's harness, not yours.

Ramp can pay this because the payoff at their scale is large and the harness is treated as real product surface. The question for everyone else is whether the same properties are purchasable.

Closing the integration gap without a harness team

In 2026, most of it closes with off-the-shelf parts:

• Run the agent inside your network. Put the CLI on a VM in your own cloud instead of a laptop or a vendor's multi-tenant sandbox, and it can reach staging databases, internal registries, and services behind your VPN. The self-hosted options guide covers the patterns.
• Wire in observability through MCP. Datadog's MCP server went GA in March 2026 and feeds live logs, metrics, and traces to Claude Code, Codex CLI, Cursor, and Copilot; Sentry ships an official MCP server. The telemetry access that was Inspect's headline feature is becoming a config entry.
• Encode policy in hooks and instruction files. Pre-tool-use hooks give you deterministic guardrails; CLAUDE.md and AGENTS.md carry your conventions. This is the thin, genuinely yours layer of harness engineering, and it is kilobytes, not a codebase.
• Isolate parallel work with git worktrees. One worktree per task is the standard answer to agents trampling each other, scriptable in an afternoon.

There is also a middle path: fork an open-source harness instead of writing one. As of August 2026, OpenCode is the most active open-source agent CLI (about 165k GitHub stars); OpenHands targets ticket-to-PR autonomy and deploys into your own VPC. You inherit the loop and own the integrations, at the cost of operating and upgrading the fork.

The decision in one table

A useful tiebreaker: if your reason to build is "the agent needs to reach our systems," that is placement, and you can buy it. If your reason is "no vendor's loop can express our workflow," prototype that claim against a current CLI with hooks and MCP first. For choosing among the CLIs themselves, see how to choose a coding harness and the coding harness definition.

Whichever way you decide, the bottleneck moves to people

Neither building nor buying fixes one thing on its own: agent output still lands on one human at a time. A July 2026 LeadDev analysis of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found that in 79 percent of agentic PRs the same developer both reviewed and modified the agent's contribution, and only about one in eight workflows involved multiple humans. Most build-vs-buy analyses skip this axis entirely, and it is where the day-to-day pain shows up: sessions nobody else can see, work that dies with a closed laptop, and verification that rests on trusting the agent's own summary.

Where AQ fits

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. In this guide's terms, AQ is the third row of the table, operationalized: you keep the vendors' harnesses (agents run as the real CLIs: Claude Code, Codex, Cursor Agent, Kimi, Grok, or plain shells), and AQ supplies the placement and the team layer that an in-house harness would otherwise justify.

Placement first: agents run in persistent tmux sessions on your team's VM, in your own cloud account and network position, so the internal-access advantage this guide describes applies, and there is no shared multi-tenant execution tier. Sessions survive a closed laptop and resume from any device. Each workspace gets its own isolated git worktree with dependencies installed automatically; agents commit and open PRs with per-user GitHub auth. Engineers sign into the CLIs with their own Claude or OpenAI accounts, and AQ never marks up model usage.

Then the part the LeadDev numbers point at: teammates open the same workspace and watch the same live session, and typing into someone else's terminal is delegated explicitly, by the owner approving a control request in one click. Live dev-server previews get shareable links that work without an account for viewing, and comments pinned on the preview can be sent to the agent as prompts. Label a Linear issue ai-task and a workspace appears, with status syncing both ways; a human starts the agent, nothing auto-launches. The Free plan is a personal sandbox (AQ creates a private machine in an isolated network, nothing to install, no time limit). The Team plan is $50 per user per month in early access (standard $200, billed monthly), covering VMs you connect from your own cloud or a dedicated always-on AQ-managed VM, rate locked for your first 12 months.

Plainly: if you are Ramp-shaped, with a product team to spare and harness quality as a strategic bet, building is defensible and the results are real. For everyone else, the question dissolves once you notice the advantage was placement all along. Buy the harness, own the machine it runs on.