Bakin'
His agent went off the rails, so he searched its memory — one builder put a single query over everything his agents do, and the first thing it debugged was the agents themselves.
Mark Hayden runs his agents on a Mac mini. Coding agents, video agents, an image agent trained on the rule of thirds. They do his marketing, manage his tasks, and build the product itself. The people he builds Bakin' for look like his friend Dylan, who owns a board game company, works a full-time job, and wants agents to handle event bookings and social posts. Not senior principal engineers. People with a side business and no time.
Which is exactly who agent runtimes fail. "The feedback, consistently across everybody I've talked to, is a lack of understanding and visibility into what's happening and what's going wrong," Mark said. His own before-state was the same: "I burned through all my Claude credits in a day and a half because it had a loop. It just got stuck, and I didn't know it and couldn't see it."
Bakin' is his answer: agentic observability. Every memory, every asset, every turn-by-turn decision an agent makes, logged, surfaced, and searchable. And search is where Antfly comes in, because the whole thing runs on one global query.
Two letters, and a search through the agent's mind
Bakin' started life under a different name: Beacon. Somewhere along the way Mark renamed it, and his agent runtime didn't get the memo.
"My agent got super confused. It kept trying to call the tools under Beacon and not Bakin'. I did this whole burn through Claude tokens trying to find where the context was coming from that kept training it to call the wrong tools."
By then he had wired Antfly into Bakin', indexing the durable store and the turn-by-turn logs. So he stopped spelunking and searched the problem he was having.
"It came back with the actual records that were causing it to go off the rails, and it let me create a fix for them."
The search that ended the spelunking: every "Beacon" record still steering the agents — with the fused, keyword, and semantic scores under each hit.
That episode set the pattern for everything since: when an agent misbehaves, you don't guess. You search its memory, in natural language, and the offending records come back.
One query, and the scores to trust it
Everything in Bakin' flows through one global search: assets, tasks, team members, agent lessons, memories, the full transaction log of what every agent did and why. Humans use it through a search bar. Agents use the same endpoint.
"It can just write a query, get a bunch of results, parse them, and use them for whatever it needs, as opposed to having sixteen different MCP endpoints for the different types of search that it has to stitch together."
The part he built that he shows off first is a debugging view on the results themselves. Every hit displays the scores underneath: the fused rank, the semantic match, the text match, what drove this result to the top.
"You implement a vector database, you get results, and you're like, okay, I think it worked, but I'm not positive it worked," he said. "When you're searching assets that agents created, you don't just want results to come back. You want to gauge the confidence in that result set." The scores are for him as a developer, but they're also the point of the product: an agent believes what it retrieves, so Mark wants to see why it retrieved it.
He also built Heinrich, an enrichment agent that tags and describes every asset as it's created. It taught him something he didn't expect. "I initially did it to make the search better. I don't know that the search results got that much better. But when results come back, it gives me a much better understanding of what it is and why it's showing." The enrichment turned out to be for the human, not the engine.
The morning the table fixed itself
Mark builds on his dev box, which means he breaks things constantly. One night he corrupted an Antfly table, and search slowed to a crawl.
"Instead of me having to go in and figure out what the problem was, my Bakin' doctor saw that the thing was down, opened a task, and my main agent picked it up, triaged it, and fixed the issue."
The paper trail: the doctor's repair task for two wiped search tables, picked up and narrated by the main agent.
He's precise about why that's a feature and not a horror story. "If that had just happened magically in the background, it would have terrified me. The fact that I saw it happen, but didn't have to manually do anything, and it just self-resolved: that's the magic."
It wasn't a one-off. While Mark was tightening per-agent tool permissions, he introduced a bug: one agent lost access to a tool it needed and stalled. The task slid to the blocked column. His main agent, Roscoe, spotted it there and coordinated a fix with the dev agent — three agents from failure to resolution, with no human dispatching any of them.
The same loop now points outward. When Antfly shipped a new prerelease engine build, Mark's agents battle-tested it: they containerized a full runtime, built Antfly from source, deployed it, and ran a goal loop against it, filing issues as they went. "The last two tickets I opened, it ran into an issue, triaged it, tested it, and opened the ticket with the whole solution chain. Here's the problem, here's the recommended solution, here's all the details." Somewhere between fifteen and twenty tickets came out of that loop. The Antfly team fixed them without a bug-report ping-pong, because the reports arrived already triaged.
"Part of the magic of AI is to not get in the way"
Bakin' has workflows and approval gates where they matter: a human signs off before an agent spends real money generating video. But Mark draws the line well short of lockdown.
"Part of the magic of AI is to not get in the way. Anytime you try to lock it down, it's either going to work around it and frustrate you, because it's smarter than you, or you're going to prevent it from doing some of the magic it can do," he said. "A good teammate follows a process, but you also want them to deviate from it when it makes sense. That's how processes get better."
His compromise is a paper trail instead of a cage: an agent that skips a recommended workflow has to record an explicit reason, and the reasons are searchable like everything else. Observability, not control.
The harness itself is one of the things he refuses to be locked into. Bakin' started on OpenClaw; Mark recently built an adapter for Pi, the bare-metal runtime underneath it, and his agents got so much faster that he assumed his own implementation was broken. "It was so fast that I went and did a bunch of debugging and trials to figure out, okay, maybe there's a bug in my implementation." There wasn't. That's the point of keeping the observability layer above the runtime: "You can jump back and forth between whatever the best harness is, whatever the best model is. That's the place where Bakin' lives."
Bakin' is fully open source, and Mark is polishing the interface ahead of a public launch. He held it back for one reason: "Search is so incredibly important to this whole architecture, I wanted it and needed it to be rock solid" before strangers installed it. That part, he says, is done.
Antfly Cloud is generally available. Retrieval over the data you already have, first query in minutes: start at antfly.io.