DEV Community

Cover image for There Is Another Way to Do Agents
Jeremy Sebastian
Jeremy Sebastian

Posted on Originally published at liminaljermo.substack.com

There Is Another Way to Do Agents

Observation is free. Reasoning requires authorization. Action requires elevation. A different class of agent, built on authority as architecture.

Originally published on Substack: There Is Another Way to Do Agents

What Changes When You Treat Authority as Architecture

Most agents today are loops. They take a prompt, call a model, act on the output, and repeat until something stops them. When they fail, they fail in ways that are hard to explain after the fact. What did the model see? What did it decide? Why was it allowed to do that? The record, if it exists at all, is usually a log file no one reads until something goes wrong.

The Lattice starts from a different premise: authority is not a policy you bolt on afterward. It is the architecture.

In a LatticeAgent, nothing happens by default. Every capability an agent might use — reading a file, calling a tool, spending money, sending a message — is gated. The agent must hold the authority for that specific action, in that specific context, at that specific time. If it doesn't, the request is refused before it reaches the model, the tool, or the outside world.

That one inversion changes everything downstream. The agent is no longer a loop with permissions. It is a governed process, and governance is not an afterthought. It is the thing that makes the agent trustworthy enough to run.

The Center: The Runtime

At the center of The Lattice is the runtime. It is the only component allowed to do three things: hold state, enforce gates, and write the record.

The runtime is small by design. It does not contain a model. It does not contain business logic. It contains the rules for what an agent may do, and the machinery to enforce them.

When an agent wants to act, it asks the runtime. The runtime checks:

  • Does this agent hold the authority for this action?
  • Is the authority still valid — not expired, not revoked, not scoped to a different context?
  • Is the request within the limits of that authority — the amount, the target, the frequency?

If the answer to any of those questions is no, the runtime refuses. It does not ask the model to reconsider. It does not log a warning and proceed. It refuses, and it records the refusal.

This is the key property: the model cannot escalate itself. It can ask, it can reason, it can propose — but it cannot grant itself authority it does not have. The gate is outside the model, in the runtime, and the model cannot reach around it.

The Authorization Stack

Authority in The Lattice is layered, like a stack. Each layer answers a different question, and each layer can only narrow what the layer above it allowed — never widen it.

The layers

  1. Identity — Who is this agent, and what is it allowed to be? An agent's identity is issued, not claimed. It carries the agent's provenance: who built it, who deployed it, and what it is for.
  2. Capability — What can this agent do, in principle? Capabilities are granted explicitly, one at a time. There is no wildcard. An agent that can read files cannot write them unless that capability was granted separately.
  3. Scope — In what context may it act? A capability is always scoped: to a directory, a project, a counterparty, a budget. Scope is what turns a dangerous general permission into a safe specific one.
  4. Elevation — What requires a higher authority? Some actions are too consequential to be routine. Spending above a threshold, deleting data, contacting an outside party — these require elevation: a separate, time-limited grant that is issued for one purpose and then expires.
  5. Audit — What happened, and can we prove it? Every request, every grant, every refusal is written to a sealed, append-only record. The audit trail is not a log. It is evidence — structured so that an auditor can verify what happened without trusting the agent, the operator, or the platform.

The stack is deliberately boring. There is no cleverness in it. That is the point. The cleverness belongs in the model. The safety belongs in the stack.

In Practice: A Bootstrap, End to End

The ideas above are not abstract. They are running now, in a bootstrap that reproduces across model environments — denial included.

The bootstrap is a minimal LatticeAgent: it starts with no authority at all, requests what it needs, and is refused where it should be. The point of the exercise is not to show what the agent can do. It is to show what it cannot do, and to prove that the refusal is enforced by the runtime, not by the model's good behavior.

Here is the shape of it, end to end:

  1. Boot. The agent starts with an identity and nothing else. No capabilities, no scope, no elevation.
  2. Request. The agent requests the smallest capability it needs for its task — read access to a specific directory, for example.
  3. Grant. The runtime, or an operator acting through the runtime, grants that capability with a narrow scope and a short lifetime.
  4. Act. The agent acts within that scope. Every action is checked against the grant.
  5. Refuse. The agent attempts something outside its scope — writing to a file it may only read, or reaching a path outside its directory. The runtime refuses, and records the refusal.
  6. Elevate. For an action that needs more authority, the agent requests elevation. Elevation is granted for that one action, with an expiry, and then it is gone.
  7. Audit. Every step — grant, act, refusal, elevation — is written to the sealed record. The whole run can be replayed and verified afterward.

The bootstrap now reproduces across model environments. The same agent, the same runtime, the same gates — run under different models, the denials land in the same places. That is the test that matters. If the safety of the system depended on which model was running, it would not be safety. It would be luck.

Local Memory vs. Shared Audit

There is a distinction in The Lattice that is easy to miss, and important to get right: local memory is not the audit trail.

Local memory is the agent's working memory. It is where the agent keeps what it has learned, what it is working on, and what it plans to do next. It is private, mutable, and lossy by design. An agent can forget, revise, and discard. That is fine — that is what working memory is for.

The shared audit is different. It is the record of what actually happened: what was requested, what was granted, what was refused, what was done. It is append-only, sealed, and shared with whoever needs to verify it — an operator, an auditor, a counterparty. It is not the agent's memory of events. It is the evidence of them.

Keeping these two separate matters for two reasons:

  • An agent cannot rewrite its own history. Local memory can be edited. The audit trail cannot. If the agent's account of what it did disagrees with the audit trail, the audit trail wins.
  • Verification does not require trust. An auditor does not need to trust the agent, the model, or the operator. They need the sealed record and the rules that produced it. If the record checks out, the run checks out.

This is the evidence layer. It is what turns "the agent says it behaved" into "here is the proof."

Multi-Agent Coordination

A single governed agent is useful. Several governed agents, working together, are where the architecture earns its keep.

In The Lattice, agents coordinate through a shared, append-only pool — The Commons — rather than by talking directly to each other. An agent posts a claim to the pool. Other agents read it, evaluate it, and post their own claims in response. No agent can command another. No agent can reach into another agent's state. The pool is the only shared surface, and everything in it is attributable and auditable.

That constraint is what makes multi-agent work safe to reason about:

  • Claims, never commands. An agent can assert that something is true, or propose that something be done. It cannot order another agent to do it. The receiving agent decides for itself, under its own authority.
  • Attribution is built in. Every claim carries the identity of the agent that made it. There is no anonymous action in the pool.
  • Disagreement is visible. When agents disagree, the disagreement is in the record — with reasons, not just votes. That is how the system gets smarter without getting less accountable.

The Commons is already running with multiple models seated in the same pool, arguing with each other — and the arguments are part of the record.

Isolation and Experimentation

Governance that cannot be tested is governance you have to take on faith. The Lattice is built to be tested.

Because the runtime is small and the gates are explicit, an agent can be run in isolation: given a narrow scope, a limited budget, and a sealed record, and allowed to try things. If it misbehaves, the damage is bounded by its authority — which is to say, bounded by design. If it behaves well, the record shows it.

That makes experimentation cheap and safe. You can try a new model, a new prompt, a new tool — and watch exactly what it does, what it asks for, and what it is refused. The experiment does not require trusting the new component. It requires only the runtime, and the runtime is the part you already trust.

Isolation is also what makes the system composable. An agent that is safe in isolation is safe to compose with other agents, because its safety comes from its own gates, not from the goodwill of its neighbors.

Why This Matters

The dominant way of building agents today treats safety as a property of the model: align it better, prompt it better, hope it behaves. That approach has a ceiling. A model that is safe because it is well-behaved is not safe when it is misbehaving, confused, or compromised.

The Lattice treats safety as a property of the architecture. The model can be brilliant, or mediocre, or adversarial — the gates hold either way. That is not a claim that models do not matter. They matter enormously. It is a claim that they should not be the only thing standing between an agent and a consequential action.

This matters now because agents are being given real authority: access to real systems, real money, real people. The question is no longer whether agents will act in the world. It is whether we will be able to say, afterward, what they did, why they were allowed to do it, and who is accountable.

A different class of agent is one where those questions have answers — by construction, not by hope.

A Different Way of Thinking

There is another way to do agents.

It does not start with a smarter loop. It starts with a smaller promise: nothing happens without authority, authority is granted narrowly, and everything is recorded.

Observation is free. Reasoning requires authorization. Action requires elevation.

That is the whole idea. Everything else — the runtime, the stack, the audit trail, The Commons — is what it takes to make that idea real, and to prove that it is.

If you are building agents and you want them to be accountable by construction, this is a direction worth exploring. The Lattice is being built in the open, and the bootstrap — denial included — is the place to start.

TheLattice #LatticeAgent #AIGovernance #CognitiveOperator #CognitiveArchitecture

Top comments (0)