Get the app

A Future Enabled by AI, Not Run by It

spirograph

A Future Enabled by AI, Not Run by It

By Trey Reeme, Trabian's Chief Operating Officer

 

A colleague in our industry has a phrase for where a lot of organizations are right now. She was talking about year-end budgets, the tightening of belts, and an already long sales cycle that has seemed to stretch longer over these summer months. She called it "the miserable middle".

As our leadership team discussed this Matt added an additional thought:

I think we're also in the miserable middle of banks and fintechs believing, ‘I think we can do this ourselves with AI' before understanding the limitations.


What the middle actually is

A few months ago I wrote about building an app in 30 minutes, which (spoiler alert) detailed the nearly 300 hours spent afterward to turn a demo into something I'd actually trust. It was where I slogged through security hardening, data isolation, error handling and the other mundane invisible things that turn a prototype into a system.

Where my initial 30 minutes were the top of the curve, the 300 hours were my climb out of the trough, and my miserable middle was the distance between those points. It was the stretch where the demo already worked so the thing felt finished, but anytime I pressed on it, the cake was still raw in the center of the pan.

AI has made the top of the curve intoxicating to reach but it's arguably lengthened the middle if you’re going to DIY it. Consider this a warning: the demo now arrives so early and so convincingly that it's easier than ever to mistake demos for destinations.


Build as much as possible, run as little as possible

Matt has a thesis he’s repeated for the better part of a year to our customers, partners, and anyone who's AI-curious:

Agents should build as many systems as possible and run as few systems as possible.


What many AI vendors pitch is the opposite: agents will do the work. Describe what you need, and agents run it in production, indefinitely.

Notice who benefits when a business model is tied to token usage. More agent activity means more token consumption. When an agent runs a workflow, every execution sends the work back through the model, tokens ticking each time.

Cost is a visible problem but a deeper one is control. You want determinism when running critical processes repeatedly. So, in a bank or a fintech, a model improvising in production becomes a risk nightmare.


The model never tells you no

Here's why the middle is miserable now, and not five years ago.

A bank CEO had been iterating on business ideas with an AI assistant, thrilled with the results. Matt asked him: has any AI platform ever told you that was a bad idea? That you were wrong?

At least in my experience with ChatGPT and Claude, every plan I outline is automatically a great plan and every idea a sure bet. (I follow @husk.irl on Instagram and you should too if you want to see this in action.)

The models are agreeable by design. They’re trained to be helpful, encouraging, and forward-moving. In many contexts that's fine (like when I ask for help with a food recipe) but in a regulated industry like banking, confident and agreeable is exactly the wrong failure mode.

There’s a huge trap in thinking, "We can do this ourselves with AI." It isn't that the AI is wrong, it's that it will never tell you when you are. It removes the friction that used to warn you: the skeptical engineer, the compliance officer who'd frown, the reviewer who'd say you can't ship this. The demo works, the model cheers, and nothing's left in the loop to say not yet.


The record is the product

I sat in a Zoom recently with some people building something new, one of them a former regulator. In the regulator's old world, the rule was brutally simple:

"It didn't exist if it's not documented."

 

You get no partial credit with an examiner. There’s no "we do this, we just never wrote it down." The regulator described real compliance as a toll booth: even if a transaction clears in a millisecond, that millisecond should leave a documented, independent, regulator-readable trail.

What has to get built in the miserable middle between the napkin sketch and the production release is recordkeeping that proves what actually occurred: which version ran, what data it used, who approved it, where it encountered an exception, and how that exception was resolved. This trail lets someone who wasn’t in the room reconstruct the decision without relying on the people who built the system to explain it.

Compliance is not a story you tell after the fact. It’s evidence that’s produced as the work happens. The record is the product, and it’s exactly what you’re tempted to skip in the miserable middle. Audit trails, approval histories, versioning, exception handling: none of them improve the demo. They only make the demo defensible.

The middle is also where so-called non-functional requirements stop looking very non-functional. The functional requirement might be simple: reconcile two systems and flag a mismatch. But who can run it? Which data can it access? What happens when one system times out? Does it retry, halt, or silently produce an incomplete answer? Who approves an exception, how long is the evidence retained, and can someone reconstruct the exact decision six months later?

AI is exceptionally good at generating the happy path; the miserable middle is where you define and prove everything that must remain true once you stray off that path into the weeds.


The better question

Many institutions are asking "how much can we do ourselves with AI now?". I think there's a better one: "where should AI be building and where should it be running?" That's answered in the middle, not at the peak, and what an examiner, a board, or a customer with money on the line should actually care about.


How we're building the way out

Having agents build instead of run is what we've spent the last year building into Mesh, and this summer, it’s what we’ve started actually shipping.

We've been describing Mesh as having three layers, with value rising as you climb. At the base, connectivity and constraints: integrations, authorization, security. In the middle, capabilities and context: fit-for-purpose APIs, tools, and data. At the top, coordination and collaboration: the applications, workflows, and agents an institution actually builds. The whole reason the lower layers exist is so that operational folks can create at the top with confidence, on a foundation that's already secure, governed, and production-ready.

And "with confidence" in the full sense: not just that a thing is usable and solves the right problem, but that it's operationally mature enough to put your name on it in front of an examiner.

Here's what that looks like in practice: A subject-matter expert, not an engineer, in Mesh can describe a workflow in plain language: reconcile two systems that are supposed to agree, alert on a mismatch, wait for a human to sign off. An agent drafts the structured process using an LLM like Claude. A human then works with the agent during the design process to refine it, then approves it, cryptographically signing the exact version they approved, and from that point on it runs on deterministic infrastructure, with retries, human-in-the-loop checkpoints, and a full audit trail of what happened and why. The AI drives the analysis and the building. The workflow governs execution and accountability.

It’s not just the upfront design process where there’s value; policy changes are where this can be really useful. When a governing policy needs updating (say a new rule just changed what one of your controls must look like), an agent can draft the new version. But nothing is accepted until a human explicitly approves it, and that approval is written to the audit log. Whatever produced the change, human or artificial, clears the same bar. And if a step hasn't been built yet, the system doesn't improvise; it halts. Fail-closed.

The governance isn't bolted on. It's how the thing is built: every action tied to a real identity, every sensitive step gated behind a human yes. That answers the regulator's questions because there’s documentation built into execution, not added after. And it answers the agreeableness problem: you don't wait for the model to say no, you build a system that requires a human to say yes.


The way out isn't more AI, or less

The way out of the miserable middle isn't more AI, and it isn't retreat. It's the unglamorous infrastructure that turns an exciting idea into something you can document, run, and defend: the part that was always the actual work, that AI made easier to start and no easier to finish.

Our friend Ron Shevlin once told us Trabian's value prop should be stated, "We operationalize fintech." The more time we spend in meetings with our customers and potential partners, the more right that sounds. The sizzle is real, and the operational reality underneath it is ours: the reconciliation, the audit trail, the human sign-off, the record an examiner can read. Twenty-plus years of financial-institution delivery, productized into a platform.

We're still in the middle of it ourselves. The tooling that lets a non-engineer design a governed workflow is real and running, and it's the piece we're refining hardest right now. The line between what AI should build and what a human must approve is one that feels right today, but we recognize it's in pencil, not pen.

And we believe the institutions that perform best will be the ones that use agents aggressively to build systems they themselves still fundamentally govern. A future enabled by AI. Not run by it.

 

The middle is only miserable if you're trying to skip it.