Authority, shared state, and controlled execution
This week, several apparently separate projects converged on the same question: how do you let agents do real work without giving them unlimited authority or forcing a human to babysit every step?
AI-assisted synthesis from public session evidence, commits, decisions, and reading notes. Reviewed and published by Connor.
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.
The important change is conceptual: an approval is not simply a yes-or-no button. It has a principal, scope, evidence requirements, risk level, delivery channel, expiration state, and an auditable result.
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 several positioning passes. The stronger version centers the actual story: I am building Kai, the systems around him, and the infrastructure that lets a small operator run a much larger software and business surface.
This exposed a useful tension: the portfolio is broad, but the public narrative cannot be a flat list of everything I have touched. It needs to explain the common architecture connecting the products.
Adding quality control to the content factory
The content system can already generate more material than I can manually review. Volume is no longer the problem. The problem is preventing technically valid but generic material from reaching publication.
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.
The lesson is similar to the approval work: a production loop is incomplete unless quality evidence exists before the next action fires.
What changed my mind
I had been treating “human in the loop” as if it described one implementation pattern. It does not.
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.
The goal is not to insert a confirmation dialog everywhere. That recreates agent babysitting. The goal is to make authority explicit enough that routine work continues while unusual, expensive, irreversible, or poorly supported actions stop safely.
This is an editorial inference from repeated approval, awareness, rollback, and evidence work—not a quote from a single session.
What I was reading
The Making of Claude Code ↗
The harness around the model—persistent execution, tools, search, timeouts, and editing interfaces—matters as much as model capability.
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 ↗
Semantic, episodic, and procedural memory clarify the harder problem: deciding what becomes a fact, a past example, or a reusable rule.
Next bets
- 01Connect Zehrava Gate to more consequential agent actions and test where risk-tiered authority helps versus obstructs.
- 02Continue joining Kai’s call, text, CRM, callback, and configuration history into shared operational awareness.
- 03Turn the brain’s session and commit evidence into this recurring public synthesis.
- 04Promote the strongest recurring idea—likely agent authority or shared memory—into a full technical essay.