One Object Per Decision

When an agent's trace is sealed, everything the decision needs to be understood later is compiled into a single machine-readable object: the decision packet. It is the machine half of the pair we introduced in the Decision Record walk-through — the PDF is for humans, the packet is for software, and the two travel together.

The design constraint that shapes everything: the packet must be bounded. An auditor's tooling, a GRC platform, or another agent should be able to fetch one object and hold the entire decision in hand — not paginate through an event stream. That constraint is also what makes packets retrievable as precedent, the idea behind decision tracing as institutional memory.

The Top-Level Sections, One by One

Here are the packet's top-level sections and the question each one answers. (Field names below are illustrative of the top-level structure — the point is the shape, not a schema reference.)

An Abridged Sample

Abridged to top-level structure, a packet for a credit decision looks like this:

{
  "packet_id": "pkt_...",
  "trace_id": "trace_...",
  "generated_at": "2026-08-05T14:32:00.000Z",

  "decision_summary": {
    "decision": "Approve credit application",
    "confidence": 0.87,
    "category": "financial_services",
    "risk_level": "high"
  },
  "context": { "request_type": "credit_increase", "amount_requested": 5000 },

  "deliberation_tree": {
    "pro_arguments":  [ { "argument": "Strong payment history over 24 months",
                          "weight": 0.85, "evidence": { "source": "payment_records" } } ],
    "con_arguments":  [ { "argument": "Recent employment change (3 months)",
                          "weight": 0.40, "evidence": { "source": "employment_records" } } ]
  },
  "alternatives_considered": [
    { "option": "Partial approval", "rejection_reason": "Net score supports full amount" }
  ],

  "rationale_summary": "Approval recommended: payment history and income ratio outweigh ...",
  "impact_assessment": { "immediate": "Credit limit increased", "long_term": "..." },
  "human_oversight": { "requires_approval": true, "status": "pending_review" },
  "audit_metadata": { "chain_valid": true }
}

Why the Packet Is Signed — and How to Verify One Offline

An unsigned record's integrity argument is "trust our database." For an artifact whose whole purpose is to be shown to people who should not have to trust you, that is not enough. So the packet is signed at sealing with Ed25519, and the public verification keys are published as a standard JWKS at /.well-known/jwks.json.

Verification is deliberately vendor-free: fetch the public keys once, then check any packet's signature offline — in your GRC pipeline, in an audit tool, in a script. A valid signature proves the packet was produced by us and has not been modified since sealing. Combined with the tamper-evident hash chain over the underlying trace, the full claim reads: this decision's history is intact, and this summary of it is authentic.

This is the same verification a reader performs on the Decision Record — the PDF simply carries the packet inside it, so the offline check works on the extracted attachment too.

"Isn't This Just Structured Logging With Extra Steps?"

It is a fair challenge, and the honest answer is: the difference is not the format, it is the unit. Logging — structured or not — is event-oriented: it accumulates facts about execution. The packet is decision-oriented: it is the closed argument for one outcome, with the counterarguments and the not-taken paths inside it.

The practical consequences diverge fast. You cannot sign a log stream meaningfully — it never ends. You cannot hand a regulator a query language. And you cannot retrieve "how did we decide cases like this before?" from spans, because the spans do not know what the decision was. We wrote the full comparison in AIAgentree vs LLM logging.

Diagnostic question: in your stack today, is there any single object you could sign that represents a complete decision — or does 'the decision' only exist as a query someone runs over logs after the fact?

Who Consumes Packets

Sources & Further Reading