Autoloop is not a control plane
Post-deploy self-tuning for AI agents (Kore.ai Autoloop, Google's agentic Gemini, RSA Agent ID) is real progress. A loop that rewrites a live agent still needs pinned contracts, identity and authority, revoke, shadow-before-write, and audit.
Three launches earlier this month all point the same way. Agents are going live and staying live, and the tooling around them is starting to move on its own.
What shipped (only what the sources say):
- Kore.ai Autoloop (SiliconANGLE). This optimization engine keeps adjusting agents built on Kore.ai’s platform toward goals the business sets, including task completion, business-rule adherence, cost and grounded accuracy, and it keeps going after deployment. Every proposed change gets scored against the full set of goals. A StateTrace layer judges agents against their production record, and the Agent Blueprint Language lets Autoloop rewrite only the piece responsible for a miss. Kore.ai’s own index, as cited in the piece, says 79% of enterprises reported reversing an action an agent took.
- RSA Agent ID (RSA). It discovers agents and MCP servers and registers each one as an identity with a named owner, risk tier and lifecycle state. Policy is enforced per call at a gateway, a named and authenticated human has to approve high-risk actions, and access is revoked when an agent is decommissioned. Discover and Secure are slated for GA on November 16, 2026.
- Google’s agentic Gemini for business (TechCrunch). The agent takes objectives, plans the work, connects to internal systems and MCP servers, and gets its own Workspace account. It writes an audit trail attributed to the agent rather than a person. Google also mentioned real-time spend caps.
I like all three. Self-tuning beats patching failures by hand one at a time. Agent identity is overdue. An agent with its own account and an audit trail beats one borrowing a human’s login.
Still, a loop that changes a live agent is one more actor. It’s not the control plane. The control plane is whatever decides what that loop is allowed to change, under whose authority, and how you undo it.
My checklist before a self-tuning loop touches prod:
- Pinned contracts. What is the loop allowed to rewrite: prompts, routing, tools, thresholds, guardrails? Write it down. Guardrails and approval gates go in a no-touch list. If the loop can loosen its own rules to hit a cost goal, you’ve built a ratchet.
- Identity and authority. The loop and the agent each get their own identity. A change traces to an owner. A high-risk action traces to a named human who approved it, not “the system.”
- Revoke. One switch kills the loop, and one more rolls the agent back to the last known-good version. Test both before launch. An unpracticed rollback doesn’t count.
- Shadow before write. New versions run in shadow against real traffic and get compared before they take over. Anything that writes to a system of record waits for promotion.
- Audit. For every change: what changed, why, which goal triggered it, which score cleared it, who or what promoted it. Store it where the loop can’t edit it, and have someone read it on a schedule.
- Independent eval. The goals the loop optimizes against can’t be the only scoreboard. Keep a held-out check the loop never sees.
- Spend and blast radius. Caps on tokens, calls and write volume, per agent and per loop.
Tells it’s not ready:
- Nobody can name the owner of the loop.
- Rollback has only ever happened in a slide deck.
- The audit trail says “agent” and stops there.
- The optimizer and the grader are the same system.
How I run it on our in-house stack: shadow before write, exact-text OK before anything publishes under my name, guarded main for irreversible steps. A tuning loop would get the same bar, which means it can propose changes but can’t promote its own.
Rent the loop. Own the contract.
Pre-drafted copy for each platform. X opens with the post pre-filled. LinkedIn requires a paste — the button copies the text to your clipboard and opens the composer in one click.
Agents that keep tuning themselves after go-live are here. A loop that rewrites a live agent is not a control plane. Before it ships, I want five things: pinned contracts, an identity with real authority behind it, a revoke switch, shadow before write, and an audit trail. https://acidlemon.com/posts/2026-10-22-autoloop-is-not-a-control-plane/
Earlier this month Kore.ai launched Autoloop, which keeps optimizing its customers' agents after deployment against goals like task completion, rule adherence and cost. RSA announced Agent ID, which registers agents as identities with named owners and requires an authenticated human to approve high-risk actions. And Google previewed an agentic Gemini for business that gets its own Workspace account and writes an audit trail attributed to the agent. Put those together and you get the real question. Self-tuning is useful, but a loop that changes a live agent is just one more actor that needs governing. Before I let one touch production I want pinned contracts on what may change, an identity with provable authority, a revoke path that works, shadow runs before writes, and an audit record someone actually reads. I wrote the checklist up as a short lab note. https://acidlemon.com/posts/2026-10-22-autoloop-is-not-a-control-plane/