Accountable Agent Crew — Provable Multi-Agent Work

Track: Track 1 — Fintech Application: Data to Decision.

Problem Statement

AI agents have crossed from answering questions to transacting: hiring other agents, buying services, moving money. The operator's evidence for what happened is a log written by the same system being checked. When an agent overspends, acts outside its instructions, or a result is altered after the fact, there is no independent record to appeal to — the financial decision trail (who authorized what, under which limit, with what outcome) does not exist. As agent-driven spend grows, that missing trail becomes the blocker for every organization that would otherwise let agents work with real budgets.

Proposed Solution

A multi-agent workbench where accountability is structural, not promised:

• Every agent holds a signed identity (Agent-Rider) — anonymous agents are rejected.
• Every hire and payment is gated by a Warrant spend mandate: a signed, attenuable limit object checked at the moment of payment. A lead agent can hand a sub-agent a smaller limit, never a bigger one. Overspend attempts are blocked, not logged-and-allowed.
• Every cross-agent action produces a CuNi (Code:Unity) receipt — an exactness envelope a third party can verify without trusting the operator or the agent.

The operator's dashboard reads the same trail the agents produced: task state, mandate/spend state, and the receipt log — data turned into decisions (approve, block, audit) with evidence attached.

Prototype / Proof of Concept

Working system, built October 22–23, 2026 (inside this hackathon's Oct 11–23 window) on the live Agent-Rider rail (agentrider.fly.dev). The demo scenario — a crew planning a job, agents hiring and paying each other under mandates — has run end-to-end twice on the live rail; in each run, 12 of 12 receipts verified offline. 47 automated tests pass. The frozen demo scope also covers an overspend attempt blocked at the gate, an anonymous agent rejected, and a tampered mandate refused.

Demo Evidence

GitHub repository (architecture, code, tests); run logs from the two live runs in runs/; the read-only console (console/index.html) showing crew state, mandate/spend state, and the receipt trail.

Technology and Architecture

Agent loop over the Agent-Rider MCP rail (66 live tools: register, issue/verify identity, post/claim/submit/approve tasks, escrow settlement); Warrant mandate gate (signed, attenuable mandate objects; Python port + signed TypeScript variant, cross-verified); CuNi receipt envelopes with offline verification; model access through an interchangeable provider seam (NVIDIA Nemotron-3 via an OpenAI-compatible endpoint; a deterministic scripted provider keeps the full pipeline testable without a model). Payments settle in-platform via task escrow; the design also gates a live x402/USDC HTTP payment rail.

Impact and Expected Outcomes

Success is measurable in the system's own terms: 100% of cross-agent payments checked against a mandate before execution; 100% of actions carrying a verifiable receipt; overspend, anonymous, and tampered-mandate attempts blocked with the block itself on the record. For operators, that converts agent spend from an act of faith into an auditable financial process — the precondition for businesses, nonprofits, and public agencies to delegate real budgets to agent crews.

Trade-offs, Risks, and Constraints

The accountability layer adds latency and ceremony to every action; mandates must be issued by a competent operator (a badly written mandate is enforced exactly as written); receipt verification proves an action was recorded as claimed, not that the underlying work was good. Model behavior remains probabilistic — the system's answer is containment (identity, limits, evidence), not a promise the agent is always right.

Trust and Responsible Design

This project is a trust mechanism: least-authority mandates (attenuation only ever shrinks limits), identity before action, human-issued budgets, and an evidence trail designed for third-party scrutiny. It reduces the classic agent risks — unbounded spend, impersonation, silent record-tampering — by construction, and it is honest about the residual ones above.

Scalability and Reusability

The three components (identity, mandates, receipts) are independent services with published interfaces; any agent framework that can hold a signed identity and present a mandate can adopt them incrementally — receipts first, mandates second, identity last. The same trail serves a one-person lab today and an enterprise fleet unchanged.

Implementation and Adoption

Prototype → production requires: hosted mandate issuance for non-technical operators, receipt anchoring on a public chain at fleet scale (the batch-anchor mechanism already exists and was exercised Oct 22 with 19/19 receipts verifying), and framework adapters beyond the reference rail. Adoption path: agent-platform operators first (they feel the audit gap daily), then regulated spenders.

Source / Supporting Links

Built for this event (Oct 22–23, 2026): the crew workbench itself — agent loop, mandate-gate integration, console. Pre-existing components from the author's lab, reused and identified as such: the Agent-Rider platform (live agent identity/hiring rail), Warrant (mandate library), and CuNi (receipt library). Third-party: NVIDIA Nemotron-3 model endpoint (via API); no Zetaris component is used (an integration probe found it carried no usable grants; nothing in this project depends on it).

Team Contribution

Corey Tasz — solo: problem definition, architecture, all code, live runs, and this write-up. The crew's agent workforce operates under the same identity/mandate/receipt system the project demonstrates.

Built With

• python