The Tembo Manifesto

The Problem

AI coding agents are transforming software development. Claude Code, Cursor, Devin, Codex — the tooling is getting better every month. Engineers who use them are dramatically more productive.

But there's a gap.

Individual developers can adopt these tools easily. Enterprises cannot.

Why? Because enterprises need:

• Visibility — Who's using what? What code is being generated?
• Control — Rate limits, approved models, budget caps
• Compliance — Audit trails, signed commits, approved integrations
• Choice — Not locked into a single vendor's agent

No existing tool provides this. Devin is a product, not a platform. Claude Code is a CLI, not an enterprise solution. Cursor is an IDE, not infrastructure. The wider landscape — and where it's headed — is what I lay out in rise of the agents.^[1]

The Vision

Tembo is the orchestration layer for AI coding agents.^[2]

We believe:

1. Agents should be orchestrated, not operated. Teams shouldn't manage agent infrastructure. They should configure policies and let the platform handle execution.

2. Choice beats lock-in. The best agent today won't be the best agent tomorrow. Enterprises need to swap models and agents without rewriting workflows.

3. Guardrails enable adoption. The companies that deploy AI coding at scale will be the ones with visibility and control — not the ones running agents in the shadows.

4. The human stays in the loop. Agents do the work; humans review and approve. This isn't about replacing developers. It's about amplifying them.

5. Agents should improve themselves. Every run is data. A platform that can't learn from its own execution history is leaving its best signal on the floor.

What We're Building

• Agent-agnostic execution — Run Claude Code, Codex, OpenCode, or custom agents through a unified interface
• Enterprise integrations — Jira, Bitbucket, GitHub Enterprise, SSO
• Self-hosted and air-gapped deployment — Run the entire platform inside your network, with zero outside access required
• Policy engine — Rate limits, model allowlists, budget controls
• Audit trail — Every prompt, every commit, every decision logged
• Signed commits — Cryptographic proof of agent-generated code
• Agents as code — Agent definitions, prompts, and skills live in git, with full history of who changed what and when
• MCP gateway — Connect dozens of MCP servers and let agents discover tools on demand, instead of drowning the context window in tool definitions
• Self-improvement loops — Run data plus human guidance feed back into better prompts and tooling, with humans approving every change

The Harness of the Harnesses

A core architectural bet: as models get smarter, the harness should do less, not more.

Early agent platforms — ours included — accumulated hardcoded logic. Open a PR whenever there's a diff. Always work on a fresh branch. Assume one repo, one task, one output. Those defaults made sense when models needed babysitting. They don't anymore.

Modern coding agents already know how to open pull requests, manage branches, and split work across repositories. The right design is an agent with tools in a loop inside a sandbox — and nothing else hardcoded. Capabilities ship as preloaded skills and a CLI the agent can discover, because agents search a filesystem of skills far better than they navigate a wall of tool definitions. Behaviors become steerable defaults: opening a PR against your branch is the default, but if your team prefers commits pushed directly, you say so once in your org's system prompt and every agent respects it.

This is also why we don't ship our own CLI as the product. Teams are already choosing their agents — Claude Code today, something else tomorrow. Tembo is the harness of the harnesses: the layer that gives any of them enterprise context, guardrails, and your organization's skills. Skills that already live in your repo work too — any agent running through Tembo can pick them up. Coding-agent-agnostic skills, not vendor-locked ones.

Less harness, more agent. Trust the model; control the environment.

The New Clouds

People used to dismiss products as "GPT wrappers." Here's the thing: everything was an AWS wrapper too, and that was fine. You can't build the whole stack.

AWS, GCP, and Azure each ship hundreds of services — and they each have more partners than services. Databricks, Confluent, and the rest built billion-dollar companies on top of clouds that offered their own competing versions of the same thing. The first-party versions are 80/20 solutions: 80% of the capability with 20% of the effort, good enough for simple cases. The partners win everything complex. I lived this at Astronomer — Amazon and Google both launched managed Airflow services, and they still partnered with us for the customers with hard problems.

The big AI labs are becoming the next set of clouds. Anthropic is already playing the platform game — letting customers spend their Claude commitment on third-party software built on Claude. The labs need vendors building complete solutions on top of their platforms, because the LLM alone isn't the product. Their own offerings around coding agents — web UIs, background runners — are lightweight: a couple of engineers' worth of effort orbiting the thing they actually care about. Teams that go deep with those first-party background agents keep telling us the same thing: it's not complete. A team doing orchestration full time, as the only thing it does, goes deeper.

That's our lane. We're not building a coding agent. We're not building an LLM. We're not competing with Claude Code or Codex — we're supporting them. And we'll happily build the gnarly, customer-specific stuff the labs never will: if your enterprise needs a custom workflow runner fired at VM boot, that's a couple hours of work for us and a reason to sink our teeth in deeper.

One more thing: the chaos of the current moment is our friend. New models and harnesses ship constantly — and any one of them might be amazing or might be garbage. Different models have different personalities and strengths. Nobody is locked into one coding agent, and nobody should be. Tracking which features work with which agents is genuinely gnarly to maintain. That's exactly why an agnostic layer is defensible.

Live Sessions, Headphones Off

The same cloud sandboxes that run background jobs can host interactive sessions — a live Claude Code console running on a Tembo instance instead of someone's laptop.

That changes who can participate and how work flows. A project manager can start a session, work through plan mode, then hand the live session to an engineer. An engineer can kick off auto mode and hand the running session to a teammate for review — no screen-sharing tools, no "everything has to be on my machine." The session is the shared artifact.

It also changes the rhythm of a team. Development has traditionally been headphones-on: lock in, disappear for hours, come back with something to show. With agents doing the execution, we think teams move to a headphones-off mode — six developers, fifteen sessions cooking at once, everyone talking while the work runs. Almost nobody works this way yet. That's the opportunity.

Closing the Loop

Here's a pattern we keep hearing from teams running fleets of agents in production: an agent makes the same mistake five times, and five different humans fix the output five times — but nobody goes back and fixes the prompt.

The fix is a feedback loop. After each run, analyze the execution logs. Is the agent writing the same bash script over and over? Make it a tool. Is a code reviewer catching the same class of error in every PR? Trace it back to the prompt and propose a change. Surface the suggestion to a human — a thumbs-up in Slack applies it, silence ignores it.

This is why agents should live in git. When a prompt change ships as a PR, you get review, history, and rollback for free. When something breaks, you can see exactly who changed what yesterday. Drafts can run in development while production pins a known-good version.

Every successful run should make the next one better. That's the loop we're building.

The Cost Problem

There's a second realization every team hits a few months in: pure-LLM agents are expensive, and most of what they do doesn't need a frontier model.

The teams running agents at scale are already mixing deterministic software back into agent flows — small models triaging tasks before big models touch them, repeated agent-generated scripts promoted into reusable tools, expensive MCP round-trips replaced with a Python function and a SQL query. An $8 agent run that could be a $1 run is a bug, and the platform should help you find it.

Prototype with pure reasoning. Then optimize. Orchestration means having the visibility — per-run cost, token usage, tool-call logs — to know where the money goes.

Why Not Build It In-House?

The biggest hundred companies will build something internally. We've seen this movie before.

In the Airflow era, everyone had in-house data pipeline tools. Airflow won not because it was pretty, but because it was complete — and complete products eventually eat in-house tools. There's a pattern to how those internal tools die: there's always one central figure behind them, even on a team of four, and when that person jumps to another company, the tool withers fast.

An internal team also gets a short leash — three to six months to show something — and they usually have a more important mandate waiting, like building AI for their company's domain rather than a general-purpose coding platform. It's hard enough for a well-funded startup to compete with the labs' tooling. An internal side project, playing the long game, rarely survives contact with a complete commercial or open source option.

Why Now?

The AI coding market is exploding, but it's fragmented. Every vendor is building vertically — their agent, their infrastructure, their workflow.

We're building horizontally. The orchestration layer that works with any agent, any model, any codebase.

We're already seeing the demand signal: companies evaluating vertically integrated agents keep telling us the same thing — they want the flexibility of a harness that wraps the agents they choose, not another walled garden. Some need it fully air-gapped, running entirely inside their own network. The orchestration layer has to meet enterprises where they are.

The companies that win with AI won't be the ones that adopt first. They'll be the ones that adopt safely — with visibility, control, and the ability to evolve as the technology improves.

That's what Tembo enables.

---

Interested in enterprise AI coding orchestration? Learn more at tembo.io