How much am I willing to let an agent do on its own?
Three things I was working on this week turned out to be the same problem. How do you let an agent do real work without either handing it the keys or watching every step it takes?
Put together from public session evidence, commits, decisions and reading notes. I review it before it goes up.
The workstreams
Building an authority layer for agents
I expanded Zehrava Gate from a basic approval mechanism into an authority system that can sit between agents and consequential actions.
The system now supports standing approvals, delegation, N-of-M policies, risk-tiered assurance, configurable providers, signed callbacks, typed action profiles, expiration behavior, an interaction ledger, and an MCP server agents can call before acting.
An approval used to be a yes-or-no button. Now it carries who is approving, what exactly they are approving, what proof it needs, how risky it is, where it gets sent, when it expires, and what happened in the end.
Making Kai aware of what has already happened
KaiCalls has callbacks, email, integrations, call handling, and agent actions. The risk is that each system acts from its own partial view of the customer.
I worked on shared awareness so those systems can see whether a customer was already contacted, whether the last attempt succeeded, whether another channel is handling the lead, and whether configuration can be rolled back.
Concrete changes included gating follow-ups on recent outcomes, adding callback delivery events, propagating lead corrections to connected CRMs, exposing configuration history through CallMCP, monitoring caller-identity drift, and creating agents synchronously during intake.
Turning ConnorGallic.com into the explanation layer
The personal site went through a few passes. The one that worked just tells the actual story. I am building Kai and the systems around him, so one person can run more than one person should be able to.
I build a lot of different things, but a list of everything I’ve touched doesn’t tell anyone anything. The site has to say what they have in common.
Adding quality control to the content factory
The content system can already make more than I can read. Getting enough of it stopped being the hard part. Now the hard part is keeping the technically-fine-but-generic stuff from going out.
This week I closed creative-QA gaps, rewrote KaiCalls carousels using verified product facts, added publish-ready assets and manifests, and created an event-driven loop that introduces one carousel after every five videos.
Same lesson as the approval work. If there’s no proof of quality before the next step fires, the loop isn’t finished.
What changed my mind
I had been using “human in the loop” like it meant one thing. It doesn’t.
A human can approve authority in advance, approve one action, review evidence after execution, intervene only above a risk threshold, require multiple approvers, or delegate authority to another person or agent.
Putting a confirm dialog on everything just puts me back to watching it work. What I want is for the routine stuff to keep going, and for the expensive, irreversible or badly evidenced stuff to stop and ask.
This is my read across a few weeks of approval, awareness, rollback and evidence work, not a quote from one session.
What I was reading
The Making of Claude Code ↗
What you build around the model matters as much as the model. Keeping it running, giving it tools and search, handling timeouts, letting it edit.
Building a Software Factory That Actually Works ↗
Treating the issue tracker as the seam between finding work and implementing it maps closely to my own observation and execution loops.
Google Voice AI call notes ↗
Turning calls into summaries and action items validates the post-call artifact pattern. The next question is how those artifacts become scoped memory.
Building a Moat: Self Learning Agents ↗
The three kinds of memory are useful mostly because they force the real question. When something happens, is it a fact, an example, or a rule?
Next bets
- 01Connect Zehrava Gate to more consequential agent actions and test where risk-tiered authority helps versus obstructs.
- 02Keep joining up Kai’s calls, texts, CRM, callbacks and config history so everything can see what everything else did.
- 03Turn the brain’s session and commit evidence into this recurring public synthesis.
- 04Turn whichever of these keeps coming back, probably agent authority or shared memory, into a real essay.