DealiOS Architecture Library
The Architecture Library
Quick reads on how AI should actually work in the real world. Written for the people building it, buying it, and betting their business on it. No theory. No hype. Just the decisions that make the difference.
Season One
The Architecture Series
Thirty-six papers on why architecture is the moat for the customer. How AI should actually work in the real world.
The Architecture Series
Getting the Math Right
Why the numbers in your proposals need to be backed by real math, not AI guesswork.
The Calculator Must Win the Argument
AI is great with words. It's terrible with math. Here's why every number in a proposal needs a real calculator behind it.
When Two Calculators Disagree
Your browser says one price. Your server says another. How a $400 discrepancy becomes a trust crisis.
Scoring Deals Without a Black Box
Why simple math that everyone can explain beats a machine learning model that nobody can.
Why the Defensible Number Wins
Why the defensible number closes more deals than the impressive one. Turns out, buyers trust the vendor who leaves money on the table.
AI That Says "I Don't Know"
What happens when you build an AI that flags its own uncertainty instead of faking confidence.
The Architecture Series
Building Better Documents
How the structure of a document changes whether it closes the deal.
Don't Touch the Client's Format
When a client sends you a 150-question RFP in their template, the answer goes back in their template. Every font. Every margin. Every table.
One Document, Five Architectures
A proposal isn't a contract isn't a presentation. Why the AI that writes each one needs a completely different personality.
Why Editing Is Harder Than Writing
AI can generate a 15-page proposal in 60 seconds. Changing one paragraph without breaking the other 14? That's the real problem.
Documents That Close Themselves
How the structure of a proposal quietly guides a buyer toward "yes" without anyone feeling manipulated.
The Architecture Series
Shipping AI That Works
What it actually takes to get AI from demo to production.
It's Not a Prompt. It's Five Prompts.
The difference between a ChatGPT wrapper and production AI is five layers of prompt architecture nobody talks about. Identity, capability, domain, customer, and intent. Each with its own cache boundary and its own ownership.
The Tighter the Leash, the Better the Output
Open-ended prompts produce open-ended garbage. Here's why the best AI writing comes from giving it less freedom, not more.
Watch It Think
Why streaming AI output in real time isn't just a UX trick. It changes what AI can actually build.
Show the Problem, Not the Roadblock
"That discount isn't allowed" kills momentum. "That discount needs VP approval. Here's the button" keeps the deal moving.
Caching Context, Not Data
The fastest AI system isn't the one with the best model. It's the one that remembers who it's talking to.
The Architecture Series
Sounding Human
Why the best AI output is the kind nobody suspects is AI.
Never Sound Like AI
Your clients can smell machine-generated text in two seconds. Here's why, and how to make it stop.
Contracts and Proposals Need Opposite Voices
A proposal should inspire. A contract should bore you to sleep with precision. Same AI. Completely different personality.
The Best AI Disappears
The end goal isn't impressive AI. It's a platform so good that nobody asks "is this AI?" They just ask "how'd you do that so fast?"
The Architecture Series
Reading the Room
How systems pick up on buyer behavior and act on it before anyone asks.
One Click, Seven Systems
A client opens your proposal. In 400 milliseconds, seven systems respond: engagement records, score recalculates, qualification updates, pipeline advances, status flips, activity logs, CRM syncs. The client's behavior moved the pipeline.
Digital Body Language
They opened the proposal three times but only read page 12. That's not a view count. That's a buying signal.
What Happens After They Sign
One signature should trigger onboarding, billing, provisioning, and five other systems. In most companies, it triggers an email to ops asking them to set things up manually.
The Pipeline That Doesn't Lie
What happens when you stop letting reps drag deals between stages and start letting outcomes do it automatically.
The Architecture Series
Influence & Honesty
What AI should argue, what it shouldn't, and how to know the difference.
How Architecture Decides What AI Argues
Every AI system has a persuasion philosophy baked in, whether the builders chose one or not. Here's how to choose on purpose.
The Convergence Thesis
Your CRM bought a CPQ that bought an e-sign tool. That's consolidation. It's not the same thing as convergence.
The Architecture Series
What AI Remembers (and Forgets)
How to give AI the right context without drowning it in the wrong context.
Bigger Context Windows Won't Save You
Giving AI a million tokens of context is like giving a hoarder a bigger house. The problem was never the space.
Stop Feeding AI Sentence Fragments
Most AI retrieval systems chop documents into tiny pieces and hope the AI can reassemble the story. It can't.
The Architecture Series
When Things Break
What goes wrong, what survives, and why your users never notice.
Never Lose Work
The server crashes. The browser refreshes. The connection drops. Your document is still there. Here's how.
Most Errors Shouldn't Stop Anything
A formatting glitch in the appendix shouldn't crash the whole proposal. Why most AI systems treat every error like a fatal one, and how to stop.
Plan A Fails. Plan B Fails. Now What?
Production AI needs three layers of fallback because in the real world, your primary model goes down during the demo.
Where AI Stops and Humans Start
AI can draft the contract. AI cannot approve the discount. The line between those two things needs to be explicit, not vibes.
Why One Security Layer Isn't Enough
If the only thing between your client's data and a prompt injection attack is one filter, you don't have security. You have hope.
The Architecture Series
What Users Actually See
Loading screens, onboarding flows, and every other moment where trust is won or lost.
Two State Machines in a Trench Coat
A proposal can be "draft" and "approved" and "sent" at the same time. Managing that isn't a UX problem. It's a state management problem wearing a UX costume.
Why Your Loading Screen Is a Sales Pitch
60 seconds of a spinning wheel says "please wait." 60 seconds of "Assembling pricing... Checking margins... Formatting deck..." says "watch what I'm doing for you."
Two People, One Document, Zero Conflicts
When Sarah and Mike both edit the proposal at 11pm, the system doesn't lock anyone out. It just makes sure they don't overwrite each other.
Five Minutes to a Fully Configured Workspace
What if onboarding wasn't a 47-step setup wizard but a conversation that builds your entire workspace while you talk?
Setup Wizards Are Punishment
Every enterprise setup wizard was designed by someone who hates you. What happens when you replace the form with a conversation.
Your Brand in Every Pixel
Set your colors, fonts, and tone once. Every proposal, contract, and deck that comes out of the system looks like your agency built it.
Season Two
Rise of the Agent Org
Ten papers on what happens when you build the team the same way you build the platform. The arc starts at the structural inversion and ends at why incumbents structurally cannot copy it.
Rise of the Agent Org
Rise of the Agent Org
Ten papers in sequence. What it takes to build a company that runs on an agent org, and why the next decade of software belongs to platforms built around it.
Trust Scales with Structure
Why the most reliable agent orgs run on the tightest constraints, and what the structural moves look like in practice.
The Org Chart Is Code
Why putting your org chart in code, not on a slide, changes what the structure can do. The structural anatomy of an agent org in plain English.
The Builder Can't Be the Inspector
How auditor-implementer separation works in an agent org, why two independent agents catch what one agent misses, and what most AI demos hide from you.
The Artifact Protocol
Why every agent invocation is a discrete session, why the handoff between agents is an artifact instead of a conversation, and what that lets you inspect.
The Sacred Files Registry
Why some code is constitutionally frozen, what gets on the list, and how a build designed to fail on contact protects what convention cannot.
A Customer In Every Room
How a per-customer agent listening inside one workspace turns customer feedback from a monthly readout into a daily structural input. Why a survey is theater and a finding is a row.
The Wall Between Customers
How the privacy contract between customers is enforced structurally, what gets aggregated and what never leaves, and why the boundary has to hold by design rather than by promise.
The Ratifier Role
The human's job in an agent org is to approve, not to operate. The principle that everything which can be a rule should be one. Why the work that's left is harder than the work that left.
The Calibrated Brief
The mechanics of the morning brief that makes a ratifier role workable. Why dashboards fail. Why 400 words is a hard ceiling. How the brief gets better at you over time.
The Foundation Problem
Why most boards are making foundation decisions they think are feature decisions. The five structural problems that lock incumbents out of serious AI. The historical pattern, the diagnostic questions, and why the Fortune 500 of 2030 is being decided right now.
Stay Current
StAIy
A weekly newsletter on AI for execs who want to be in the know on how to build AI at scale. By Ed Hoehn.
Subscribe on LinkedIn