Covenant Prime

Live App: https://covenant-prime.vercel.app

Covenant Prime is an on-chain control layer for AI-managed tokenized securities.

Autonomous agents are getting wallets, but a normal wallet only offers full signing authority or no authority at all. That is not real financial delegation. An agent should be able to act quickly inside explicit limits and be unable to cross them.

A user creates an on-chain covenant defining the assigned agent, allowed assets, approved targets and recipients, spend limits, expiry, slippage, leverage rules, and lifecycle permissions. Every agent action passes through ActionRouter and is evaluated by MandateEngine before any funds can move.

Allowed actions execute and produce indexed execution receipts. Refused actions never reach the target and produce immutable refusal proofs with stable reason codes. Most systems only record what happened. Covenant Prime also records unsafe actions that never happened.

The protocol is modular Solidity: CovenantVault for policy and spend accounting, MandateEngine for deterministic validation across 14 checks, ActionRouter as the sole execution gateway, RefusalProofRegistry for blocked-action evidence, plus CorporateActionModule and AuditorDisclosureModule for votes, claims, and audit access. It supports 8 action types across the full tokenized asset lifecycle.

The product is live on Arbitrum Sepolia. Connect MetaMask, create a covenant, and run real demo scenarios: safe buys and votes pass, while exceed-cap buys, unauthorized transfers, and forbidden disclosure attempts are refused on-chain. Every result links to Arbiscan. No server-side keys. No simulated decisions. App state rebuilds directly from chain events.

We shipped 23 passing Foundry tests, CI on every push, verified contracts, full architecture docs, and a public Vercel deployment.

Agents can act. They cannot betray the mandate.

We entered the hackathon with one goal: ship a real on-chain control layer for AI agents, not a mock demo or slide deck.

We started with the protocol. CovenantVault stores policy, spend accounting, and agent assignments. MandateEngine evaluates every action with deterministic reason codes across 14 checks. ActionRouter is the only execution gateway. RefusalProofRegistry stores immutable proof for blocked actions. We also built lifecycle modules for corporate actions and auditor disclosure, plus testnet adapters for mock tokenized stocks.

Before touching the UI, we locked the contracts down with 23 Foundry tests covering allowed execution, every major refusal case, proof and receipt indexing, revoked and expired covenants, pause controls, reentrancy protection, invalid config rejection, and unsupported lifecycle actions. CI runs on every push with formatting, tests, contract-size checks, TypeScript validation, and a production Next.js build.

Then we deployed the full stack to Arbitrum Sepolia as v4.0.0 with verified contracts on Arbiscan. Every interaction in the app hits live chain state, not a local fork.

The frontend came next. We built a Next.js app on viem with MetaMask connect, on-chain covenant creation, Agent Console, five live demo scenarios, a refusal proof dashboard, Arbiscan links, and full state recovery from chain on refresh. The app is live on Vercel.

We also shipped complete README and ARCHITECTURE docs, branding across the landing page and app, and linked everything back to GitHub.

What we planned: on-chain policy enforcement, refusal proofs, Arbitrum deployment, and a working MetaMask demo.

What we shipped: the full protocol, 23 passing tests, verified contracts, live product, five attack/safe scenarios, public deployment, and full documentation.

Covenant Prime is live end to end. Anyone can connect MetaMask, create a covenant, run scenarios, and verify receipts and refusal proofs on Arbiscan.

Not Fundraising Yet