Product-Agent-Fit

TL;DR — AI agents are becoming the primary users of software. The winning products will expose deep capabilities in forms agents can reliably use. We call this Product-Agent-Fit.

The AI super-app

The dust is starting to settle. The emergence of Codex and Claude Code makes the endgame clearer:

• Coding agents are generalist agents. The tools they use to write software are the same tools needed for most knowledge work.
• Reasoning models can sustain complex, multi-step tasks over minutes or hours.
• People are starting to multitask across agents, dispatching jobs in parallel like a manager running a team.

These trends converge toward the same shape: a super-app where you launch tasks through chat, track progress, review results, and iterate. Other apps plug into it through MCP servers, tools, and skills that expand what the agent can do.

The AI super-app is the new operating system, the platform on which you should build your product.

Don’t build the agent, you already have one

Codex and Claude Code already provide the core agent loop: memory, tool use, context management, and a UI people are learning to work inside. Many teams will still try to build their own agent layer on top of this. They shouldn’t.

If you need a chatbot or task interface, keep it thin. Use the Agent SDKs, write a system prompt, connect your MCP servers, and ship. Don’t build custom memory systems, planners, or orchestration layers unless they’re central to your product. You’re competing against the labs that own the models and the runtime itself.

This is a winner-take-most market. Agent products behave more like operating systems than SaaS tools: users consolidate around one or two environments where they spend most of their time. The field will narrow to a handful of dominant platforms — Claude, Codex, maybe Google — plus a smaller layer of model-agnostic harnesses like Cursor, Devin, or OpenClaw. That is probably most of the market.

The harness wars

OpenAI and Anthropic are now openly fighting over harness distribution, and the economics are brutal for outsiders:

• Distribution. They already have the brand and the user base.
• Price. Labs are willing to subsidize aggressively to lock users into their platform, even at the expense of margins. Part of the reason Anthropic restricted subscription-powered third-party harnesses like OpenClaw and Hermes earlier this year was to protect that layer.
• Co-design. Models are post-trained on their own harnesses.

Models are drifting toward commodity. Harnesses are where switching costs and stickiness get built. If you’re not a frontier lab, that’s not the layer to compete on.

So what should you build?

Start from the new stack.

Above your software now sits a general-purpose intelligence the user talks to. It's good at planning, summarizing, dispatching, and holding ambiguous goals across many steps — and bad at specialized domain work, deterministic guarantees, or anything that requires capabilities it wasn't trained on. Broad and shallow.

Your job is the inverse: narrow and deep. A capability — something exposed in a form an agent can reliably use. Extracting data from an obscure document. Compliance-grade execution of a financial transaction. A deterministic search index over a company's data. Domain-specific reasoning trained on real-world examples.

Does the agent need you? Is your product’s capability difficult for the agent itself to reproduce natively?

Can the agent reach you? The job humans used to do in software, more than anything else, was glue. We copied data between SaaS apps, clicked through dashboards, held processes in our heads — a huge share of knowledge work was effectively runtime error correction, humans absorbing the complexity that software systems themselves couldn't handle. That role is moving to agents, which means software now has to serve a customer it never had to serve before.

That changes what software has to optimize for. Agents need systems that are legible: small, well-named APIs; predictable behavior; explicit state; self-explanatory errors; docs they can parse. A backend built from years of patches and exceptions doesn’t become usable just because you add MCP on top. The system itself has to become simpler, more consistent, and easier to reason about.

Algorithmic workflows — a billing pipeline, a Zapier-style automation, a deterministic document processor — are great complements to agents. They provide a capability and expose it cleanly. Agentic workflows are the ones at risk: if your pitch is "we put an LLM in the middle and it reasons for you," the capability you're offering is generic reasoning, which is exactly what the layer above already has, with a better model and a longer context. The winners will be the systems agents can reliably understand and interact with.

So: pick a capability the agent above you doesn't have. Make it the best in the world. Expose it in a form the agent can actually use. Let the agents find you.

Product-Agent-Fit

Over the last four months, we’ve rebuilt Retab from the ground up around a simple assumption: agents are becoming first-class users of software. We rethought the primitives themselves, removed complexity, and made the platform easier for both humans and agents to reason about.

Now Codex and Claude Code are better at using our product than we ever were.

Previously, every implementation required a long translation process. We understood document processing; our clients understood their business, workflows, and edge cases. Building a solution meant constant back-and-forth to translate domain knowledge into working systems. Now the agent sits in the middle, understands both sides, and builds the solution directly on top of Retab. It feels like having a forward-deployed engineer for every customer. We’re building in minutes what used to take us days.

It really feels profoundly different. Like we’ve crossed a qualitative threshold. We call it Product-Agent-Fit.