The pilot-to-production wall finally has a name
On July 23 Nuggets launched the Authority Control Plane, and the pitch cuts straight to the reason most agent programs stall. Seema Khinda Johnson, Co-founder and Chief Commercial Officer at Nuggets, framed it from customer conversations: "Customers told us they can't move agents to production, because they can't prove what an agent was allowed to do." That sentence describes the wall every enterprise hits. Agents that work in a demo become ungovernable the moment they can act on real systems with real money and real data, because no one can attest to the boundaries afterward.
The ACP is built to answer that specific objection. It sits in the runtime execution path between autonomous agents and enterprise systems, and for every action it decides allow, deny, or escalate. This is enforcement at the moment of action rather than policy written in a document and hoped for. For CIOs who have watched agentic projects die in security review, the framing is exactly right. The blocker was never model capability, it was the inability to prove authority, and this product is aimed at that gap.
Runtime enforcement beats configuration governance
The architectural choice matters. By sitting in the runtime path, the ACP evaluates each action against agent identity, authority, organizational policy, intent, and runtime context before the action executes. That is a meaningful shift from the way most agent governance works today, which is static permissions granted at setup and rarely checked again. A control plane that reasons about intent and context at execution time can catch the case where an agent does something technically permitted but contextually wrong, which is precisely where autonomous systems cause damage.
The tradeoff is that anything in the runtime path becomes a dependency and a potential bottleneck. Every agent action now waits on a decision from the plane, which raises questions about latency, availability, and what happens when the control plane itself is down. Enterprises evaluating this class of product should press hard on those failure modes. A governance layer that becomes a single point of failure in front of every agent action is a different risk than the one it was bought to solve, and the operational answer matters as much as the security story.
The Action Receipt turns governance into evidence
The most interesting piece is the Action Receipt. Every decision the plane makes is recorded as a cryptographically signed receipt, described as durable proof of what an agent was allowed to do. This directly answers the co-founder's framing of the core problem. Proof is what auditors, regulators, and internal risk committees demand, and a signed, tamper-evident record of each authorization decision is the artifact that lets a CISO sign off on production deployment. It converts governance from a promise into evidence you can produce on demand.
For regulated industries, this is the load-bearing feature. When an agent moves money or touches protected data, the question after the fact is always who authorized it and under what policy. A signed receipt trail answers that question in a way logs alone often cannot, because logs can be altered and receipts are designed to resist it. If the cryptographic claims hold up under scrutiny, this is the kind of primitive that compliance teams have been asking for since the first agent pilot went to review.
Admin controls address the CFO as much as the CISO
The admin surface widens the buyer beyond security. The ACP offers spending thresholds, expiration dates, and approval requirements, which are financial and operational controls, not just technical ones. Spending thresholds in particular speak to the CFO's fear about autonomous agents: an agent with payment authority and a bug is a budget event. Putting hard ceilings and mandatory approvals in the runtime path means the finance function gets enforceable guardrails rather than a dashboard it checks after the money is gone.
Central visibility rounds it out. The plane offers a single view of which agents exist, who runs them, and what they attempted. That inventory problem is quietly one of the biggest governance gaps in enterprises adopting agents team by team, because shadow agents proliferate faster than anyone catalogs them. A registry of every agent and its attempted actions is the unglamorous foundation that real oversight requires, and it may prove more valuable in practice than the cryptographic sophistication that gets the headlines.
Standards support hints at an interoperability bet
Nuggets built the ACP to support decentralized identifiers and verifiable credentials, which signals a bet on open identity standards rather than a proprietary walled garden. For enterprises wary of lock-in, that is a point in its favor. Agent identity is going to be a contested layer, and a governance product that speaks standard identity primitives is easier to reconcile with existing identity infrastructure and less likely to strand you if the vendor landscape shifts. It suggests the company sees itself as plumbing that interoperates rather than a destination platform.
That said, standards support is a design choice, not yet a proven ecosystem. Decentralized identifiers and verifiable credentials remain early in enterprise adoption, and betting on them is a wager on where the market goes. CIOs should welcome the openness while keeping expectations grounded. The value today is the enforcement and the receipts. The standards alignment is insurance against future lock-in, and it will only pay off if the broader agent identity ecosystem matures in the direction Nuggets is anticipating.
A category to watch, with proof still pending
The honest caveat is that Nuggets disclosed no launch customers and no adoption figures. That makes this a strong category signal and a weak traction signal. The problem it names is real, and the architecture is coherent, but enterprises should treat it as a promising entrant rather than a proven standard. We would expect larger identity and security vendors to move into runtime agent authorization quickly, because the gap is obvious and the demand is loud. First to articulate the problem is not always first to own the market.
For your roadmap, the decision is whether runtime agent governance is something you buy now or build toward. If agents are stuck in your pilot backlog for exactly the reason Johnson described, a product like this is worth a serious evaluation, with hard questions about latency, failure modes, and the strength of the cryptographic proof. If you are earlier, the more useful takeaway is the requirement itself: no agent should reach production until you can prove, on demand, what it was allowed to do. That standard is the real deliverable, whoever supplies the plane.
