Evan has been building things in Airtable for ten years. Tables, views, linked records — the works. He knows his way around a database.
So when he came to me wanting to build a meeting processing agent, I skipped the usual explanation of how AI agents work and just asked him one question:
“If you were building a meeting table in Airtable, what columns would you want?”
He listed them without hesitating. Meeting ID. Date. Attendees. Action items. Who owns each one. Deadline. Project.
Thirty seconds, maybe.
“That’s your schema,” I told him. “Give that structure to the agent, and it’ll know exactly what to produce every single time.”
He got it immediately. Because it wasn’t really a new concept — it was the same thing he’d been doing in databases for a decade, just applied to an AI workflow.
The Problem Most People Have With AI Agents
When an agent produces inconsistent results — sometimes capturing action items, sometimes not; sometimes including owners, sometimes leaving them blank — the instinct is to fix the prompt.
So people rewrite the prompt. Try different phrasing. Add more instructions. Maybe switch models.
And they get marginally better results for a few runs before the inconsistency comes back.
Here’s the thing: inconsistency in AI output is almost never a prompt problem. It’s a schema problem.
The agent is inconsistent because it hasn’t been given a clear structure to fill. It’s improvising. Deciding for itself, run by run, what the output should look like.
The fix isn’t a better prompt. It’s a defined schema — the exact structure you want the agent to produce, every time, without exception.
Schema First, Execution Second
Think of it like building an Airtable table. Before you enter a single record, you define your columns. You decide what fields matter, what format they take, what’s required versus optional.
Once those columns exist, data entry is just execution. You’re not reinventing the table structure every time you add a row.
AI agents work the same way.
Define the output structure first — as a JSON schema, a markdown template, a set of required fields, whatever format fits the tool. Once the agent has that schema, it’s not guessing what you want. It’s filling in the blanks.
Meeting ID: [extract from transcript]
Date: [extract from transcript]
Attendees: [list names]
Action items: [list each item]
Owner: [assign from context]
Deadline: [extract or mark TBD]
That’s it. The agent runs the same logic, produces the same structure, every time.
What Happens When You Get This Right
I work with someone who was spending $9 per query on an AI workflow. The prompt was detailed. The model was good. But the architecture was wrong — the agent was trying to do too much in one shot, without a defined structure for what it should produce.
We didn’t change the prompt. We redesigned the schema. Broke the task into stages. Defined exactly what each stage should output. Gave the agent clear structured targets at each step.
Same AI. Same task. $0.07 per query.
That’s a 99% cost reduction from a schema fix, not a prompt fix.
The bottleneck was never the AI. It was the architecture.
The Agent Design Backwards Principle
My approach to building agents starts with the output artifact — the exact thing the agent should produce — and works backward from there.
What does the finished product look like? What fields does it have? What format does it take?
Once you can answer that, you define: what does the agent need to produce it? What inputs, what steps, what rules?
Most people do this in the wrong order. They start with the tool or the prompt and work forward, hoping a consistent output emerges.
It rarely does. Because the output structure was never defined. The agent is making it up each time.
Start with the schema. Everything else follows from there.
The Practical Question
Before you write another prompt, ask yourself: what is the exact output I want this agent to produce?
Not “summarize the meeting.” Not “extract the key points.”
What specific fields? What format? What’s required? What happens if something is missing?
Write that down. Turn it into a template. Give the agent that structure.
If you’ve ever built a spreadsheet or a database table, you already know how to do this. The skill transfers directly.
Evan got it in thirty seconds. His agent has been running consistently ever since.
I help founders and operators design and build AI systems that run reliably. My consulting and workshop programs are built around this design-first methodology. If you’re building agents for your own business, the process starts with getting the schema right.
