Frontier labs are racing to rent you the layer that turns intelligence into action. Application companies and enterprises should think hard about what they hand over.
This week, OpenAI launched the Agents API in public beta: the same harness that runs Codex, available to any developer behind a single API call.
It’s easy to read that as another developer tool. I read it as the clearest signal yet that the AI industry has found its next battleground.
Models still matter. But access to capable models is now widespread, and leadership changes with every release. A model advantage that looks decisive today can narrow within a quarter.
The more durable battle has moved one layer down. It’s the harness.
What is an AI harness?
A model on its own is a brain in a jar. It can think, but it can’t do anything. Ask it to fix a bug, book a job, or send an invoice, and all it can produce is text describing what someone else should do.
Anthropic’s engineering team gives the simplest definition: the harness is “the loop that calls Claude and routes Claude’s tool calls to the relevant infrastructure.” In practice, that loop looks like this:
- Receive a goal from your application (“follow up with every lead from last week who didn’t book”) and assemble the right context for it.
- Ask the model what to do next. The model replies with a tool call: “query the CRM,” “run this script,” “send this SMS.”
- Execute the tool call in a sandbox: an isolated machine where commands run and files live.
- Feed the result back to the model and repeat until the job is done.
- Verify the result and stream events back to the application, so a human can watch, approve, or step in.
That’s the architecture OpenAI published with the launch: Application → Agents API → Sandbox. Think of it as three layers:
- The brain: the model, which provides the intelligence.
- The harness: the coordination layer, which turns that intelligence into reliable action.
- The hands: sandboxes and connected systems, which let the agent work with files, software, data and outside services.
Your application sits on top, giving users the experience and the business outcome they care about.
The loop sounds simple. Making it reliable is not. A production harness has to handle:
- Context management. Long jobs overflow the model’s memory, so the harness compacts older history without losing the plot.
- Tool routing. Loading only the tools that matter right now, calling several in parallel, and chaining outputs into inputs.
- State and checkpointing. A job that runs for hours has to survive crashes and resume where it left off.
- Permissions and approvals. Deciding what the agent may touch, and when a human must say yes first.
- Sub-agent orchestration. Splitting big work across specialist agents and merging the results.
- Recovery and verification. Detecting failures, retrying steps, and checking the output before calling it done.
The providers have learned that separating these layers matters. Anthropic describes decoupling the “brain” from the “hands” so each can fail, scale and be replaced independently as models improve. One early OpenAI customer, Hypha, reported that separating the harness from the sandbox cut failed agent responses by 86%.
For the past two years, nearly every team building agents rebuilt this layer from scratch. The same compaction logic, the same retry loops, the same tool-calling glue, duplicated across thousands of companies. That’s the waste the labs now want to eliminate, and the market they want to own.
The land grab is already underway
Look at what has shipped in 2026 alone:
- Perplexity launched Perplexity Computer in February, describing it as “a model agnostic harness” that runs Claude Opus as its core reasoning engine and orchestrates sub-agents across Gemini, Grok, GPT and others. Perplexity doesn’t need to win the model race. Its product is the harness. In August it shipped Portable Computer, a local harness on NVIDIA DGX Spark with an OS-enforced sandbox and its own post-trained model, tuned specifically for its own harness.
- Anthropic launched Claude Managed Agents in April: a hosted harness with sandboxing, durable sessions, credential management and long-running execution, priced at standard token rates plus $0.08 per session-hour. Notion, Rakuten, Asana, Sentry and Atlassian were among the launch customers.
- Google launched Managed Agents in the Gemini API in May: “with a single call,” an agent that reasons, uses tools and executes code in an isolated Linux environment, with state that persists across calls.
- OpenAI launched the Agents API on September 10: the Codex harness with automatic context compaction, tool search, programmatic tool calling and sub-agents, running on OpenAI-hosted sandboxes or your own via Modal, Cloudflare, E2B, Vercel, Daytona and others.
- The hyperscalers are in too: AWS Bedrock AgentCore, Microsoft Foundry Agent Service and Google’s Vertex AI Agent Engine all sell managed agent runtimes.
One detail stands out. OpenAI charges nothing extra for the harness. You pay only for the tokens and tools your agents use.
When a company gives something away, it’s usually because that thing is the funnel for what it actually sells.
Harness-as-a-Service is the new cloud
We’ve seen this movie before.
- IaaS removed the need to operate physical servers.
- PaaS removed the need to manage runtimes.
- SaaS removed the need to install and maintain business software.
- Harness-as-a-Service removes much of the repeated engineering needed to run reliable AI agents.
The reason every lab wants this layer is simple. As model advantages become less durable, the harness is where stickiness lives. Your sessions, state, tool configurations, memory, traces and approval flows all accumulate there. It’s also where providers learn how their models behave in real work, and where they tune the next model to perform best inside their runtime. Perplexity said it out loud: a model post-trained for its own harness.
Model and harness, co-designed and sold together. That’s the new moat for the labs.
For builders, the upside is real. You ship faster. You stop duplicating plumbing. Tool-calling intelligence gets built once, by the people who know the models best.
But there’s a cost that isn’t on the pricing page.
The risk: your moat becomes their config file
If your product is a user interface on top of a frontier model and a standard managed harness, it’s easy to reproduce. A competitor can rent the same model, use the same orchestration layer, connect similar tools, and ship a rival interface in a weekend. Your differentiation shrinks to a system prompt and a tool list.
In that world, the application isn’t a moat. It’s a replaceable surface.
It gets worse. Your agent’s state lives in their session store. Your traces live in their dashboard. Your memory lives in their format. Every workflow you run teaches the platform what your product does and where it creates value. And the same labs selling you the harness are shipping first-party agents that sell directly to your customers.
So what does stay defensible? The durable moats look like this:
- Proprietary systems of record and the historical decisions and outcomes inside them.
- Domain-specific execution logic: how work gets routed, what gets remembered, when to escalate to a human.
- Your own policies, permissions and verification methods.
- Workflows embedded deep in how customers operate.
- Feedback loops that make execution better with every outcome.
- Trust earned inside a specific industry.
Notice that owning data alone isn’t on that list. The advantage comes from knowing how to interpret the data, make the right decision, take the right action, and learn from the result. Call it execution intelligence. It’s exactly what a managed harness asks you to hand over.
The stakes are even higher for enterprises that run on proprietary knowledge:
- A pharma company’s edge is the knowledge encoded in its research, evidence, regulatory processes and validated SOPs.
- A healthcare system’s edge includes its care pathways, clinical context, permissions and audit requirements.
- A retailer’s edge lives in how it understands inventory, customers, merchandising, pricing and fulfillment.
Outsource too much of that execution and years of proprietary operating knowledge become inputs sent through someone else’s general-purpose system, one that also serves your competitors. That’s before you get to data residency and the regulatory need to explain exactly why an agent did what it did.
None of this means “don’t use managed harnesses.” Even OpenAI’s own diagram carries a telling note along the bottom: “Application controls self-hosted compute.” Control still matters.
It means knowing which layers you rent and which you own. Here’s a simple test: if your harness provider shipped your product tomorrow, what would they be missing?
If the answer is “nothing,” you don’t have a moat.
Why Supernila owns both layers
This is the bet behind Supernila, the agentic AI platform I’m building for owner-led home service businesses: painters, cleaners, HVAC techs and the other trades where the owner is also the estimator, crew lead, bookkeeper and salesperson.
We’re not building a generic AI wrapper or a collection of disconnected tools. After more than 200 conversations with owners, one thing was clear: they don’t want more software to operate. They want the work around the work taken off their plate: chasing leads, scoping jobs, writing estimates, sending invoices, collecting payments. Supernila is an AI-managed team of specialized agents that runs those commercial operations for them.
We’re building it in horizons:
- Today: lead generation and lead management, from getting found to capturing, qualifying and following up with every lead.
- Next: scoping, estimates, invoicing and payments, so the path from first call to paid job runs through one system.
- Future: the full commercial operations of the business, run by agents, with the owner approving what matters.
Our execution layer: harness and orchestration. At the center is Nila, the agentic brain of the platform. An orchestrator coordinates specialist agents, each responsible for one part of the job, across two loops:
- A Creation Loop that turns an owner’s goal (“fill my calendar for spring”) into a plan the agents execute.
- An Optimization Loop that watches what’s working and surfaces the Next Best Action for the owner, based on what the data says.
This is where our execution intelligence lives. A no-heat HVAC call in January needs different questions and a different urgency than an exterior painting estimate in April. Nila responds to a new lead in under 60 seconds, because speed-to-lead decides who gets the job. It works within tiered autonomy, with one-tap owner approval gates, because the owner is on a job site, not at a desk. And its layered memory (working, episodic, semantic and procedural) holds each business’s service area, seasonality, past customers, approval boundaries and what has worked before.
Our application layer: purpose-built workflows. Today that means a conversational website that captures and qualifies leads, instant SMS and email follow-up, booking-software sync, outbound campaigns, and AI Visibility, which helps a local business get cited when customers ask ChatGPT, Claude, Gemini or Perplexity for a recommendation. Scope, estimate, invoice and payment workflows come next, on the same execution layer.
Our system of record ties it together: leads, conversations, jobs and outcomes today, and estimates, invoices and payments as we expand, in one closed loop from first contact to paid job. Every job won makes the next decision sharper for that specific business.
We use frontier models where they reason best, and we’ll adopt any infrastructure that makes us faster or more reliable. But we own the business logic, the operating context, the application experience and the learning loop. That’s what makes Supernila valuable to the owners who rely on it.
The closing thought
Every platform shift follows the same plot. The infrastructure layer consolidates, gets cheaper, and gets rented. Value moves to whoever owns the customer, the data, and the judgment.
AWS didn’t kill software companies. It killed the ones whose only advantage was running servers. Harness-as-a-Service won’t kill AI application companies either. It will kill the ones whose only advantage was wiring a model to a few tools.
Models are becoming something you access. Generic harnesses are becoming something you rent. But the operating knowledge of a business can’t be downloaded through an API.
The winners in agentic AI will own the layer that knows what should happen, how it should happen, when it’s safe to act, and what a good outcome looks like.
Rent the commodity layers. Own the execution intelligence.
Because in the age of AI agents, the most valuable company won’t be the one that generates the best answer. It will be the one that turns intelligence into outcomes, reliably, repeatedly, and better than anyone else.
That’s the company we’re building. Owners run their craft. Nila runs the operations around it. And we run Nila.
I’m Arun Thachi, founder of Supernila. If you’re building agents on a managed harness or deciding what to own versus rent, I’d like to hear where you’re drawing that line. Leave a comment or DM me.
