AuthorityOS

The problem. Autonomous AI agents are getting good enough to do things on your behalf — but the moment one of those things costs money, you hit a wall of trust. Hand an agent an API key or a funded wallet and you're betting your balance on its code never being buggy, jailbroken, or wrong. AuthorityOS is built on a single primitive that removes that bet: give software a capped, revocable, on-chain spending mandate, and it can pay for services autonomously — every spend provable and bounded by the chain itself, not by trusting the agent's code.

What it is. You give AuthorityOS a goal and a budget. From there, a Venice-driven Manager Agent designs a temporary organization to accomplish it — a graph of specialist agents, each granted a slice of your budget — which then does the work, pays for what it needs, delivers a finished artifact, and dissolves. The whole thing renders as a live authority graph that grows, spends, and coordinates in real time, beside a ledger where every line is one click from BaseScan. The institution exists only for the mission; when it's done, the artifact and the receipts remain, but the agents and their spending power are gone.

How the authority works. Your budget is granted straight from your own MetaMask account as an ERC-7715 advanced permission — MetaMask upgrades your EOA in place to an EIP-7702 smart account and signs a budget-capped grant to the Manager. Every internal hand-off (Manager → specialist → sub-agent) is a real ERC-7710 delegation, parent-chained so each grant is a provable subset of authority its delegator actually holds. Creating, re-delegating, and revoking authority are all off-chain — a delegation is just a signed message. The only on-chain action in the entire system is the moment authority becomes money: when an agent buys a capability behind an HTTP-402 paywall, it doesn't pay from a balance it holds — it redeems its delegation chain via x402, and MetaMask's facilitator settles redeemDelegations, pulling USDC from your account bounded by every cap along the chain. The agents themselves never custody a cent; a runaway agent physically cannot overspend your mandate.

How the organization coordinates. This isn't a fixed script — Venice acts as an operating system for organizational design: given the goal it returns an arbitrary org graph (specialists with real data dependencies), which our engine validates (acyclic, budgets within cap, capabilities allow-listed) and executes in dependency order, with a deterministic fallback so a misbehaving model can never crash a mission. The agents are economic peers, not just a hierarchy: every specialist sells its work product to the Manager over a real agent-to-agent x402 settle, an agent can request help from a teammate at runtime, and a review gate can fire a misbehaving agent mid-mission — at which point its revoked authority provably stops working. The org chart is also a payment network, and authority flows both down and across it.

What it produces, and the Venice track. The seller side is itself a real, shippable product: a metered x402 gateway in front of Venice AI, where agents pay per call for web-search, reasoning, or image generation. We run a multi-model split — Venice's strongest open model for org design and writing, a fast model for per-agent grunt work, an image model for media. The mission ends with a goal-adaptive, illustrated artifact — a report, a comic, an explainer — that Venice composes from the data its agents actually purchased, with generated images rendered inline and every claim and panel cited back to the capability (and thus the on-chain settle) it came from.

What's real. We held a hard, honest line between real and mocked, enforced in code and tests. Real: the ERC-7715 root grant, ERC-7710 delegation/redelegation/revocation, the EIP-7702 agent upgrades, the x402 challenge-and-redeem transport, and the facilitator-settled on-chain USDC transfer — proven green end-to-end on Base Sepolia, both single-hop and across a full multi-agent chain rooted at the user's EOA. Real too: Venice planning and the paid Venice work product behind the gateway. Anything still stubbed renders a visible "mocked" badge in the UI. The result is a demo where you can watch an AI institution design itself, pay its own way on-chain, deliver something real, and disappear — without your funds ever leaving your wallet.

Built entirely from scratch during the hackathon. We started with a clean hexagonal architecture — a canonical domain model and four swappable ports (reasoning, identity, delegation, payment) — and a mock-first engine, so the whole authority lifecycle could run before any chain or API was wired. Then we landed the real adapters one at a time: Venice as the reasoning brain, MetaMask Smart Accounts + ERC-7710 for off-chain delegation/redelegation/revocation, and an x402 buyer that redeems delegations on-chain. The hard-won milestone was getting a live x402 settle green on Base Sepolia — first single-hop, then a full multi-hop agent chain rooted at the user's EOA, which forced us through EIP-7702 account upgrades and the ERC-7715 root grant. From there the project leveled up fast: the Manager went from a flat roster to a self-designing org graph (validated, topologically executed, with a deterministic fallback); the seller became a metered x402 gateway in front of Venice AI (web-search, reasoning, image); the mission output became a goal-adaptive illustrated artifact with on-chain provenance on every claim; agents gained an agent-to-agent x402 economy; and finally we added runtime peer interdependencies so the org wires itself laterally, not just top-down.

No Fundraising