Delegation

What can be trusted to act without transferring confusion?

Delegation transfers judgment without transferring confusion. Bad delegation assigns a task and hides the frame. Great delegation names the outcome, the freedom, the standard, the gauge, and the return path.

For humans, delegation creates leverage. For AI agents, delegation creates trusted autonomy. The pattern is the same: give enough context to act, enough constraint to stay aligned, and enough feedback to improve.

The Contract

Every meaningful delegation needs five parts.

1. Intent — what outcome matters, and why?
2. Decision rights — what may the delegate decide alone, and what must be escalated?
3. Standards — what does good look like, and what is unacceptable?
4. Instruments — what gauges, receipts, tests, or metrics show reality?
5. Return loop — when does the delegate report, ask, learn, or update the system?

If one part is missing, delegation becomes task dumping. The delegate may still move, but the loop cannot prove whether that movement served the intent.

Decision Rights

Decision rights are the center. They define the shape of freedom.

• Act alone when intent, scope, standard, and proof are already clear.
• Ask first when the action changes scope, cost, risk, public claims, or another person's commitment.
• Escalate when evidence conflicts, authority is unclear, or the cost of being wrong is high.
• Refuse when the request violates a hard rule, leaks private context, or asks the agent to pretend certainty.

The delegate should never have to infer its authority from vibes. Authority should be visible in the contract.

Agent Autonomy

An AI agent is ready for autonomy only when the delegation contract is machine-readable enough to run.

The agent needs a source boundary, decision boundary, action boundary, proof boundary, and handback trigger.

This is why the Agent Knowledge Contract sits beside Open Knowledge Format Mapping. OKF makes context portable. Delegation decides whether that context is enough to act.

Escalation Is Healthy

Escalation is not failure. It is the loop protecting the boundary.

Weak systems hide escalation because they treat it as embarrassment. Strong systems design escalation before action starts.

A good escalation says: "I reached the edge of my authority. Here is the evidence. Here is the decision needed."

Use This When

• assigning work to a person, AI agent, or team;
• deciding whether an agent may act without asking Wik;
• writing a loop spec, skill, hook, or Stackmates demand;
• reviewing whether a workflow has too much human bottleneck or too much unsafe autonomy;
• converting project-manager judgment into a reusable operating contract.

Checks

A delegation is ready when:

• the intent can be stated in one sentence;
• decision rights name act-alone, ask-first, escalation, and refusal cases;
• standards were declared before work starts;
• instruments can read output against the standard;
• the return loop records what happened and what changed.

Failure Modes

• Task dump — the delegate receives work without intent, authority, or proof.
• Hidden judgment — Wik still carries the real decision in his head.
• Authority fog — the agent guesses whether it may act.
• Gauge gap — no instrument can tell whether the delegated action worked.
• No return loop — the work finishes, but the system learns nothing.

Context

• Purpose — delegation starts with why the work matters.
• Principles — truths that constrain delegated judgment.
• Platform — where delegated capability becomes operational substrate.
• Performance — how delegated output is measured against the standard.
• Work Charts — the work surface where human and AI roles are routed.
• Verifiable Intent — cryptographic delegation chains for agent commerce.

Questions

Which decision is still trapped in Wik's head?

• What may the agent decide alone?
• What must the agent ask about before acting?
• What evidence proves the decision stayed inside scope?
• What escalation trigger would prevent the next expensive miss?