Q1 2026
AI-First Infrastructure and a Team of Ghosts
A house fire will clarify your priorities real fast.
In early March 2025, shoddy electrical work hidden for two decades ignited my attic. The fire department tore through the ceiling. Toxic smoke and water ruined everything. My wife and I landed in a chaotic string of temporary housing while I sold the charred husk, bought 20 acres, and started building a new life from dirt. I lost months to insurance claims, ruined possessions, and the kind of decisions nobody should have to make while standing barefoot on a street watching their home burn.
But the fire burned away something else too: my attachment to outcomes. I stopped caring about building an empire. I stopped trying to be CEO. I'm an inventor. That's the truth I kept running from.
So I came back to Adama with fresh eyes and a question that had been nagging me since late 2024: what if the platform I spent years building is accidentally the right foundation for the thing everyone is trying to build right now?
Here's what I built over the last five years, originally for board games and real-time collaboration:
Read that list again, but this time imagine the "document" is an AI agent session. The "connected clients" are users watching an agent think. The "privacy-filtered views" are audit boundaries. The "service integrations" are LLM API calls. The "durable state machines" are multi-step agent workflows that can't lose progress.
This is not a coincidence I manufactured. I didn't pivot to AI. The architecture I built for real-time multiplayer games turns out to be almost exactly what you need for persistent, stateful, observable AI agents. Living documents are agent sessions. Delta sync is streaming agent output. Privacy controls are access policies. The compiler that prevents you from leaking a player's hand in a card game also prevents an agent from leaking patient data.
I spent the first months of 2026 building the agent construct directly into the Adama language. Not as a library. Not as a service wrapper. As a reactive type, the same way record defines data and table defines collections.
agent Researcher {
max_tool_rounds = 5;
model = "claude-sonnet-4-20250514";
max_history = 50;
instructions = "You specialize in " + specialty;
mutable string specialty = "general";
mutable int papers_reviewed = 0;
@description("Search articles by topic")
tool<SearchQuery, SearchResults> search_articles {
return { answer: "found results for: " + request.query };
}
@description("Record a finding")
mutating tool<FindingInput, FindingAck> record_finding {
papers_reviewed++;
return { recorded: true };
}
}
session<Researcher> lead;
That max_tool_rounds = 5 is not optional. The compiler rejects agents without it. You cannot deploy an agent that can loop forever. This is the kind of safety property that sounds boring until you get the bill from an LLM provider because your agent went into an infinite tool-call spiral at $0.03 per thousand tokens.
Tools are read-only on document state by default. A mutating tool can write to the document. These rules are enforced at compile time. Not at runtime. Not by convention. By the compiler. A prompt injection that tries to use read only tools to mutate will fail.
Sessions persist through crashes. The conversation history, the mutable state, the pending work queue -- all committed atomically with the document. If the server dies mid-conversation, the agent picks up exactly where it left off. On a standard stack, you'd build this from scratch and probably get it wrong the first three times.
Dynamic agent creation works through tables. table<PanelMember> where PanelMember contains a session<Specialist> means you can spin up new agent instances at runtime without redeployment. Configure them, ask them questions, tear them down. The reactive system handles the rest -- every connected client sees the new agents appear, watches their conversations unfold, all through the same delta sync that was already handling game state updates.
The aichat service supports OpenAI, Anthropic, and xAI with format normalization happening transparently. Tool call formats, message schemas, the annoying differences between Claude's content blocks and OpenAI's delta chunks -- all normalized into a canonical {id, name, input} representation. Swap models by changing a config string. No code changes.
Streaming is in progress. Token-by-token deltas flowing through the existing reactive pipeline to connected clients. The architecture already handles backpressure for slow clients (this was a solved problem for game state updates). An LLM generating tokens at 100/second is trivial compared to the throughput I built for real-time multiplayer.
Here's the dirty secret of 2026: I have a team.
Not a team I hired. Not a team I manage. A team of about ten good engineers that costs me roughly the price of API calls and shows up every day ready to work. I put in about two hours of direction and review, and they produce.
AI didn't just change what I'm building. It changed how I build. The bus factor problem that every panel review flagged -- "what happens if the solo developer is unavailable?" -- is now irrelevant. Not because I cloned myself, but because the work that used to require me sitting at a keyboard for twelve hours can now be directed in two. I read the diffs. I steer the architecture. I make the judgment calls. The typing, the boilerplate, the test generation, the documentation, the refactoring -- that's handled.
This means a solo founder bootstrapping a 97,000-line Java platform with 9,858 tests is no longer a crazy bet. It's a Tuesday. The math that made investors nervous -- one person, too much code, too little time -- doesn't hold when that one person has a team of ghosts.
I'm not anti-VC. I'm anti-unnecessary-VC. Taking money when you don't need it means giving up control, and control is the thing that lets me make the weird architectural decisions that turn out to be right five years later. Nobody would have funded "build a custom programming language for board games." And yet here I am with an agent infrastructure that a panel of simulated experts scored 9.4 out of 10 as a strategic boom, with compile-time safety properties that save $100-200K in compliance costs on a $300K budget.
The money I would have spent on a team of five engineers for a year, I'm spending on API calls for a fraction of the cost. The time I would have spent in standup meetings, I'm spending reviewing code. The energy I would have spent managing humans, I'm spending on architecture.
I'm building OpinionPanel.AI as the first real product on this stack. A health research tool where a panel of AI specialists discusses a patient's situation and produces a structured document they can bring to their doctor. Not medical advice. Information. The same legal category as WebMD or asking ChatGPT about your symptoms, but with five competing perspectives, cited research, and a physician-ready format.
The architecture maps perfectly: each consultation is a document, each specialist is a session in a table, the panel discussion streams to the patient in real time via delta sync, and the privacy model ensures different users see different things. Everything Adama was built to do, applied to a problem people will pay $29.99 to solve.
Meanwhile, Adama keeps getting weird. Vectors and matrices landed for game development. Height-fields and dungeon maps are coming. The game studio dream didn't die -- it just got a sibling. Some days I build agent infrastructure. Some days I build game systems. Both run on the same reactive document engine, and that convergence is the thing nobody else has.
The fire burned away my old life. AI gave me a new team. Adama gave me the infrastructure. Now I build.