Agents

The worker and the action

An agent gets neither the onboarding a new hire gets nor the sign-offs a transaction gets. How to build both, and why one without the other fails.

When a company hires a person, it builds two kinds of structure. Standing structure: a role, a manager, permissions, reviews. Per-transaction structure: the purchase order, the approval, the second signature on the wire. Neither replaces the other.

Agents get neither. They arrive with a prompt and an API key. Their actions execute with no record of what they meant, who approved them, or how to undo them. The technology to act is here. The structure around the acting is not.

No one selling you AI is paid to point this out. Model vendors improve models, platforms grow usage, and the structure that decides whether any of it sticks is yours to build.

Building it means answering two kinds of questions, on two clocks.

Standing questions. What job does this agent do? What may it touch? Has it earned more trust? These change slowly, like onboarding and reviews.

Runtime questions. What is this action? Who allowed it? How does it get reversed? These arrive hundreds of times a day.

We built one project for each. Lattice onboards the agent like a worker: context to do the job, limits on what it can touch, a named owner for the outcome. Concord puts a contract on each action: meaning, authority, undo.

The organization people, policies, accountability Lattice — governs the worker Ground · Govern · Graduate standing structure: role, context, permissions, trust level Concord — governs the action propose → authorize → execute → record per-action contract: meaning, authority, undo Enterprise systems — tools, data, workflows policy, enforced per action ledger feeds the scorecard

Rules go down, proof comes up

The layers close a loop. Downward: a policy like "credits over a threshold need approval" is a sentence in a binder until something checks it at the moment an agent acts. That checkpoint is the contract. Upward: deciding whether an agent deserves more trust takes evidence: how many actions were approved unchanged, corrected, reversed. That evidence is the contract ledger.

One without the other fails predictably. Onboarding without contracts: well-documented agents whose actions nobody can explain. Contracts without onboarding: perfectly audited actions by agents nobody decided to trust.

Trust level sets the ceremony

An agent's trust level should set how much contract ceremony each action gets.

Lattice level What the agent may do What each Concord contract does
0 · Observe Read context only No contracts; nothing executes
1 · Recommend Suggest actions Records the recommendation; a human decides
2 · Draft Prepare the artifact Carries the draft; a human executes the contract
3 · Act with approval Execute after sign-off Full contract with a human approval gate per action
4 · Act within guardrails Execute inside hard limits Auto-approved within policy; exceptions escalate with full ceremony
5 · Autonomous in bounds Operate within a domain Auto-approved in domain; audit and reversal intact, sampled review

Promotion changes the ceremony, not the accountability. The audit trail never thins. What thins is how often a human stands in the path.

What comes next

Each piece of the stack opens a question we haven't finished answering:

  • Autonomy levels as a shared scale. Like driving automation: one vocabulary for "how much do you trust this agent."
  • Performance reviews for agents. What an agent costs against what it returns.
  • Context packs. How business knowledge, including the kind that lives in people's heads, gets handed to an agent.
  • The flipped org chart. What management looks like when a few people oversee many agents.
  • The delegation you didn't sanction. Most employees already hand work to personal AI tools, off the books. The same structure can bring it on the books.

If you run an organization, start with Lattice, part 1. If you build systems, start with Concord, part 1.