Part 1 established that the graph decides what a set of agents can execute: fan-out and tiering turn a slow chain into a fast fleet. A separate question sits underneath every fast fleet, and enterprises that skip it end up explaining an unauthorized action to a board.
The upgrade that solved a different problem
A regional bank's operations team replaces the small model behind its exception-handling agent with a frontier model. Task time drops from most of a working day to under ten minutes (illustrative). The team calls it a governance win, since the new model also writes clearer explanations of what it did.
The upgrade changed the clock and left every other question where it was. Months from now an examiner asks who authorized releasing a hold on a flagged account. That answer has to come from a person, a process, and an authority boundary someone set on purpose, and the operations team now reaches that question in ten minutes, a trip that used to take a day. A faster model carries an organization toward its unresolved questions sooner, which helps only when someone has resolved them.
Speed and authority sit on different axes. An organization that buys the first and assumes the second came bundled has accelerated its risk while leaving the shape of that risk untouched.
What grants authority
Authority lives in the control plane wired around the model, the same way signing authority on a contract lives in a role the organization assigns. A new hire who drafts contracts at speed earns a reputation. Signing authority arrives separately, decided by people who thought about it.
Human-factors research on this has moved into the agentic era directly. A 2026 field study published at ACM FAccT interviewed seventeen experienced developers overseeing autonomous software agents in production and mapped what oversight actually involves: four distinct forms, spanning control set before the agent runs, co-planning alongside it, real-time monitoring, and review after the fact. Oversight turned out to include preventative and proactive work, ahead of the run as well as after it. In an agentic stack the supervising human is frequently absent from the step entirely, which leaves the architecture as the only place that ownership can live.
Coral Reef Nodes™ name the enterprise's distributed execution units: a resident model, a context service, an evaluation service, a policy-enforced tool adapter, whatever the deployment requires. Every one of them carries the same six-part Node Contract, and the contract holds whichever model happens to be running inside it:
Identity — who is acting? Capability — what may it touch? Policy — which rules apply to this particular run? State — what entered the step, and what left it? Authority — which actions finish on their own, and which wait for a person? Evidence — what record exists afterward?
Swap the small model inside a node for a frontier model and one of those six moves. Identity, policy, state, authority, and evidence stay exactly where the organization put them, because all five belong to the organization and always did.
Where the boundary sits
Part 1's tiering routed the frontier model to the graph's judgment nodes, the steps that carry synthesis and hold real consequence. Those are the nodes where the authority question sharpens, because judgment nodes propose consequential actions: releasing a hold, approving an exception, committing language a customer will read.
GW Slate™ sits at those nodes as the control plane around the work. It evaluates the proposed action against the node's policy, decides whether that specific action completes autonomously or waits for a human, and on completion writes the receipt: cryptographic, tamper-evident, attributable to the identity that authorized it. The model inside the node can be upgraded, downgraded, or swapped entirely while every one of those properties holds. Authority belongs to the architecture, which is why it survives a model change.
Across the governed workflows we have instrumented, capability upgrades and authority failures surface on completely separate audits, because they are separate properties. Treating them as one is how a faster model becomes a faster liability.
The graph decides what can execute. The architecture around that graph decides what proceeds without a person watching. Buyers evaluating agentic AI vendors ask the first question by default. The second is the one their compliance team will be asked.
What the harness around an agent consists of, and how far an agent can reach, is Part 3.
GlobalizeWe builds governed execution infrastructure for enterprise agentic work — Manta Graph™ to map the estate, GW Slate™ to control the run, Receipt Rail™ to prove it. Human-at-the-control, cryptographically attributable, built onto the systems an enterprise already runs.
Start from Part 1: Agent Topology: The Graph Decides What Enterprise AI Can Execute