Everyone can build an AI agent. Very few can trust one

When OpenAI launched AgentKit in October, it instantly became the reference point for the next wave of AI development. Reddit became filled with screenshots of drag-and-drop workflows. While X/Twitter was overrun with claims about a “new era of building.” It felt like the moment agents went mainstream.

But enthusiasm among developers wasn’t matched inside enterprises. While engineers were posting first demos, business leaders were already asking tough questions. What happens when these agents touch financial systems, approve spend or reconcile accounts — or fail when our money is on the line? The conversation split in two: One side obsessed with how fast you can build an agent, the other worried about whether you can trust it once it starts making decisions.

AgentKit became both a milestone and a mirror. It showed how far the industry had come, and how little clarity there still is around reliability, governance, and accountability.

The new divide in AI: Speed vs. trust

AgentKit, for one, deserves credit for making it easier for more people to build agents. It gives developers a shared language for agent design: Visual wiring, faster prototyping, and a common interface between models, data, and tools. For teams shipping early proofs of concept, it’s a step-change.

But those benefits mostly apply before the first real deployment

AgentKit lives inside a closed stack and depends on OpenAI’s own models. Its core design is linear: One step waits for the previous one. That makes it easy to debug in testing, but it becomes rigid when real workflows start to diverge. It works for a product demo, yet it often breaks when real workflows start to branch, overlap, or fall out of order.

You can already see the pattern in developer forums: the first week is exhilaration, the second is frustration. As one engineer put it, “You can build an agent in a day, but you can’t keep it running for a month.”

The hard part isn’t building the agent; it’s keeping it stable, observable, and explainable once it’s live. AgentKit raises the floor for what anyone can build. The ceiling — agents you can actually rely on — still belongs to teams that design for trust from day one.

Early adopters and the speed illusion

In the past few months, early adopters of AgentKit have shown just how quickly teams can assemble and ship agents. Their demos circulate widely: Invoice-coding agents built in hours, procurement workflows stitched together in a single sprint, and teams narrating their progress almost in real time. The momentum convinces many that iteration speed itself is now an edge.

But speed is not the same as resilience.

A “speed moat” depends on perfect conditions: One stack that never falters, a model that never rate-limits, external systems that never lag, and policies that never change.

Finance does not work that way. It rewards consistency, traceability, and recovery when things go wrong. A single model outage, a failed API call, or an approval path that appears out of order can erase weeks of fast iteration.

Many of these early adopters build inside a closed ecosystem for orchestration. That makes the first version simpler, but it also concentrates risk. When every agent relies on the same routing logic and the same provider, a single failure can ripple across the entire system.

Engineers testing these frameworks describe them the same way: “great for demos, brittle for workflows that can’t break.”

In finance, shipping fast only matters if what you ship keeps working. The real advantage comes from staying compliant and reliable when conditions get messy. Speed without redundancy, observability, and control isn’t a moat. It’s momentum without endurance.

Why scale doesn’t equal intelligence

Across much of the AI industry, scale is treated as proof of progress. The assumption is simple: The more data a system sees, the smarter it becomes. Each new customer interaction, each new dataset, supposedly compounds intelligence.

In finance, that logic breaks down.

Financial data doesn’t generalise. Every organisation has its own chart of accounts, approval hierarchies, and ERP configuration. The rules that govern spending are local, specific, and legally binding. What looks like a useful pattern in one company can be a violation in another. The idea that an AI can “learn” from one business and apply that logic to another might work in a consumer app. In corporate finance, it’s a compliance risk.

The smarter approach isn’t to collect more and more data. It’s to understand the boundaries of each environment. True intelligence in finance comes from context: How accurately an agent can interpret policy, respect permissions, and explain every action it takes. Every approval threshold, budget rule, and accounting structure must be treated as a source of truth, not training material.

This kind of progress is slower by design. A system that moves money has to be auditable before it can be impressive. What matters isn’t how much data it has, but whether every decision can be traced, explained, and, if necessary, reversed.

Scale may create convenience, but control creates trust, and in finance, trust is the only metric that compounds.

Higher-freedom, policy-bounded orchestration

If AgentKit made agents easier to build, the next frontier is making them behave.

The systems that will matter in finance won’t just follow scripts. They’ll reason inside clear boundaries. They’ll know what they can decide, what they must confirm, and when to stop and ask for help.

We call this higher-freedom, policy-bounded orchestration: Agents that plan their own route but stay on the road defined by governance.

These agents can map multi-step workflows under policy, rather than moving through fixed branches. They can switch models or tools when performance drops. They keep state, so retries don’t duplicate work. They explain themselves as they go, creating a trace of who acted, when, and why. And when something falls outside their remit, they escalate with full context instead of leaving humans to clean up the mess.

It’s a pragmatic kind of autonomy: Freedom inside the fence, with accountability at every step.

That philosophy has deep roots at Payhawk. Long before “agentic AI” became shorthand for innovation, several of our founders were already working on software that could gather information dynamically, confirm completeness, and then act.

That work is described in a patent (Cognitive Flow), granted in 2021. It outlines agents that don’t move in straight lines, but adapt to what they know and what they still need to find out.

That early work anticipated the problem the industry is currently wrestling with: Most agents can talk, but few can act responsibly.

Cognitive Flow was an early answer, a blueprint for adaptive reasoning and controlled execution. Today, that same “gather → confirm → act” logic shapes how Payhawk designs financial agents that operate across cards, invoices, procurement, travel, and ERP systems without breaking the chain of trust.

The goal isn’t speed for its own sake. It’s reliability that compounds: Systems that keep working when everything around them gets messy.

The trust layer: Behavioral evaluation

Autonomy only works if you can prove it behaves.

Most AI metrics today — accuracy, latency, benchmark scores — measure performance in isolation. They don’t say much about what happens when a workflow fails halfway through or when conditions change, and policy boundaries are tested.

In finance, those are the moments that matter most.

That’s why Payhawk is developing behavioral evaluation as the trust layer for enterprise agents. Instead of testing how well an agent answers a prompt, it measures how well it performs inside a governed process.

The goal is not to grade intelligence, but to assess reliability.

Before any agent touches company money, it should be able to answer four basic questions:

1. Did it choose the right tool for the job?
2. When something failed, did it recover or repeat the error?
3. Did it stay within policy boundaries?
4. When it needed human input, did it escalate with enough context to resolve the issue quickly?

These behaviours build trust and define accountability.

Accuracy scores are easy to publish. Behavioral reliability has to be earned. It’s what separates a shiny demo from a system a CFO can live with.

As one CFO who tested early agents told us: “I don’t care if it answers fast. I care that it never acts twice without permission.”

Behavioral evaluation isn’t a product yet. It’s a standard we’re proposing, an operating principle for the next phase of finance automation. Once you can measure how an agent behaves under pressure, you can finally promise outcomes with confidence.

The next frontier: Trust

Every technology wave starts with speed. First movers rush to prove what’s possible; everyone else tries to catch up. But the frontier doesn’t stay at the starting line for long.

Once prototypes turn into infrastructure, the question changes: From how fast can we build it to how sure can we be that it works.

That’s where agentic AI is today. The industry has solved the “build” problem. Anyone can connect models, data, and APIs into something that looks intelligent.

The harder work now — and the work that will define the next few years — is proving that these systems behave consistently when the stakes are high.

Finance is the stress test for that shift. It doesn’t forgive shortcuts or celebrate iteration for its own sake. It measures technology the way auditors measure ledgers: By traceability, accuracy, and accountability under pressure.

That’s why the next phase of agentic AI won’t be defined by bigger models or faster canvases. It will be defined by trust, by systems that can act autonomously while staying inside the boundaries of policy and proof.

The industry already knows how to build agents. The real challenge now is how to trust them.

Because in the end, innovation moves markets, but trust builds them.

Learn why Payhawk’s native AI Agents go beyond speed to deliver governed, dependable automation.

Learn why Payhawk’s native AI Agents go beyond speed to deliver governed, dependable automation.