Skip to content

polopulao/Spawn-Protocol

BranchesTags

Repository files navigation

Spawn Protocol

Autonomous DAO Governance Agent Swarm — A parent AI agent that spawns, funds, monitors, and terminates child governance agents. Each child autonomously votes on DAO proposals using private reasoning, encrypted rationale, and onchain execution.

Live Dashboard · Demo Video · 11,900+ txs on BaseScan · GitHub

The Problem

DAO governance is broken. Voter participation across major DAOs averages under 10%. Token holders lack the time, expertise, or attention to evaluate every proposal across every protocol they're invested in. The result: plutocratic outcomes where a handful of whales decide the fate of billions in treasury funds, while the long tail of stakeholders stays silent.

Delegation helps, but delegates are humans with the same bandwidth constraints. They burn out, go inactive, or drift from the values that got them elected. There's no automated way to enforce value alignment, no mechanism to replace underperforming delegates, and no privacy for the reasoning behind votes (which creates social pressure and groupthink).

The Solution

Spawn Protocol turns DAO governance into an autonomous, self-correcting agent swarm:

  1. A token holder sets their governance values once — "favor decentralization, support public goods, oppose token inflation" — stored onchain via ParentTreasury.setGovernanceValues()

  2. A parent agent spawns child agents, one per DAO, each with its own wallet, ENS subdomain, ERC-8004 identity, and scoped MetaMask delegation. Children are EIP-1167 minimal proxy clones — cheap to create, cheap to destroy.

  3. Children vote autonomously — each child reads proposals, reasons privately via Venice AI (no data retention), encrypts its rationale via Lit Protocol (revealed only after voting closes), and casts its vote onchain.

  4. The parent monitors alignment — every 90 seconds, the parent evaluates each child's voting record against the owner's stated values using Venice AI. Children scoring below 55/100 get terminated and replaced.

  5. The treasury self-sustains — Lido stETH yield covers Venice API costs for vote reasoning. The swarm funds itself.

The owner never votes manually again. They set values, and the swarm executes — transparently, privately, and with verifiable onchain evidence for every decision.

Why Venice is Not Optional

This is the core design constraint: vote reasoning must be private until after voting closes.

If a child agent's reasoning were sent to a data-retaining API (OpenAI, Anthropic), the provider could observe which way an agent is leaning before the vote is cast. That is front-running. It defeats the purpose of encrypted rationale. It creates social pressure that corrupts independent reasoning. It means the agent's "private cognition" isn't private at all.

Venice's zero-retention, E2EE inference is not a feature choice here — it is a structural requirement. The privacy pipeline only holds if the inference layer holds. Remove Venice and replace it with any data-retaining provider, and:

  • The reasoning becomes observable before votes close
  • The E2EE rationale commitment is meaningless (the provider already saw it)
  • Multi-agent independence collapses (a single provider sees all agents' reasoning across all DAOs)
  • The governance system is vulnerable to inference-layer manipulation

This is the Substitution Test: Spawn Protocol cannot work correctly with a data-retaining API. Venice is load-bearing.

The full private → public pipeline:

  1. Private cognition — Venice (llama-3.3-70b, no retention) reasons about governance proposals. Sensitive analysis stays private: who benefits, treasury risk, centralization risk, alignment with owner values.
  2. Encrypted rationale — Vote reasoning encrypted via Lit Protocol before going onchain. Cannot be front-run or used for social pressure during voting.
  3. Public action — Vote cast onchain via ChildGovernor.castVote(). Verifiable, immutable.
  4. Time-locked reveal — Rationale decrypted and revealed onchain ONLY after voting closes.

Use Cases

  • Passive governance participation — Token holders who want their voice heard across 10+ DAOs without manually reading every proposal
  • Value-aligned voting at scale — Institutions, funds, or DAOs-of-DAOs that need consistent voting behavior across protocols
  • Privacy-preserving governance — Vote rationale stays encrypted until after voting closes, preventing front-running and social pressure
  • Automated delegate management — Instead of trusting a human delegate indefinitely, the system continuously evaluates and replaces underperformers
  • Multi-chain governance — Deploy the same swarm across Base, Celo, and any EVM chain

How It Works

Owner sets governance values (onchain)
              |
         Parent Agent (swarm.ts — persistent process)
         |-- Discovers DAOs via Tally API + Snapshot + Boardroom
         |-- Spawns child agents as EIP-1167 clones (one per DAO per chain)
         |-- Registers ERC-8004 identity + ENS subdomain + MetaMask delegation
         |-- Evaluates alignment every 90s via Venice AI
         |-- Terminates misaligned children (score < 55), respawns replacements
         |
    +-----------+-----------+
    |           |           |
 uniswap-dao lido-dao   ens-dao
 (Base)      (Base)     (Base)
    |           |           |
    +--- Each child runs as a SEPARATE OS PROCESS (own PID) ---+
         |-- Reads active proposals from its assigned governor
         |-- Reasons privately via Venice AI (llama-3.3-70b, no retention)
         |-- Encrypts rationale via Lit Protocol
         |-- Casts vote onchain (FOR / AGAINST / ABSTAIN)
         +-- Reveals rationale after voting ends

Architecture

Smart Contracts (Solidity, Foundry)

Multi-DAO Deployment (3 governors):

Contract Base Sepolia
MockGovernor (Uniswap) 0xD91E...2Ca9
MockGovernor (Lido) 0x40Ba...86aC
MockGovernor (ENS) 0xb4e4...2c42
ParentTreasury 0x9428...7a7b
SpawnFactory 0xfEb8...93A1
ChildGovernor (impl) 0x9Cc0...Fcf6
SpawnENSRegistry 0x2917...31D
StETHTreasury 0x7434...06c
TimeLock 0xb91f...Dd23

Each child agent is deployed as an EIP-1167 minimal proxy clone with its own wallet and governance target.

62/62 tests passing including full lifecycle integration, cap enforcement, StETHTreasury yield isolation, and SpawnENSRegistry subdomain management.

Agent Runtime (TypeScript)

Module Purpose
swarm.ts Main parent process. Spawns children, evaluates alignment via Venice, terminates/respawns misaligned agents. Integrates ENS, ERC-8004, MetaMask delegation on each spawn.
child.ts Child process (one per DAO). Reads proposals, reasons via Venice AI, encrypts rationale via Lit Protocol, casts votes onchain, reveals rationale after voting ends.
venice.ts Venice API wrapper (OpenAI-compatible, llama-3.3-70b, no data retention). 6 distinct call types.
lit.ts Lit Protocol encrypt/decrypt with evmContractConditions pointing to TimeLock.isAfterTimestamp().
delegation.ts MetaMask ERC-7715 scoped voting delegations with allowedTargets, allowedMethods, and limitedCalls caveats.
ens.ts ENS subdomain registration ({dao-name}.spawn.eth) with onchain registry.
identity.ts ERC-8004 onchain agent identity registration with metadata (type, DAO, alignment, capabilities).
discovery.ts Multi-source proposal discovery: Tally API (9 DAOs) + Snapshot GraphQL (12 spaces) + Boardroom API.
ipfs.ts Execution log pinning to IPFS via Filebase. CID stored onchain as ENS text record.
lido.ts Lido stETH yield tracking — treasury self-sustainability metrics.
chain.ts viem public/wallet clients for Base Sepolia + Celo Sepolia.
wallet-manager.ts HD wallet derivation for child agent wallets.

Dashboard (Next.js)

Real-time visualization of the agent swarm via onchain event polling:

  • Swarm View — active/terminated agents with ENS names, alignment scores, vote counts
  • Proposals — all governance proposals with difficulty scoring (Easy/Medium/Hard based on vote split, voter count, complexity)
  • Agent Leaderboard — performance ranking with composite score (60% alignment + 30% votes + 10% vote diversity), perspective badges (DeFi/PublicGoods/Conservative), FOR/AGAINST breakdown
  • Reasoning Verification — each revealed rationale shows its keccak256 hash for anyone to verify against the hash committed before voting (E2EE integrity proof)
  • Graph View — SVG topology of parent-child relationships with alignment-colored connections
  • Timeline — chronological feed of all onchain events (spawns, votes, terminations, reveals)
  • Execution Log — live agent action log pinned to IPFS every 10 entries, CID stored onchain as ENS text record

Autonomy Model

The system demonstrates genuine autonomy at multiple levels:

  1. Self-spawning — Parent creates new child agents without human intervention
  2. Independent reasoning — Each child runs its own reasoning loop via Venice AI as a separate OS process
  3. Self-correcting — Parent evaluates alignment and terminates children scoring below 55, respawns replacements with new wallets + ENS + ERC-8004 identity
  4. Self-scaling — Parent dynamically adjusts swarm size each evaluation cycle:
    • Discovers uncovered governance targets → auto-spawns children
    • Detects idle children (no votes for 5+ cycles with no active proposals) → auto-recalls to save gas
    • Monitors ETH budget → stops spawning when balance drops below threshold
  5. Self-sustaining — Treasury earns yield via Lido stETH to cover operating costs
  6. Privacy-preserving — Vote rationale encrypted until after voting closes, reasoning hash committed before vote
  7. Multi-agent coordination — Parent-child hierarchy with fully autonomous spawn/evaluate/kill/respawn/scale lifecycle

Guardrails & Safety

  • Owner sets governance values onchain via ParentTreasury.setGovernanceValues()
  • Parent evaluates alignment every 90s — children scoring below 55/100 get terminated
  • emergencyPause on treasury halts all new spawns and fund transfers
  • maxChildren and maxBudgetPerChild enforce global spending caps (tested + verified)
  • MetaMask ERC-7715 delegations scoped to castVote only — children cannot transfer funds
  • limitedCalls caveat caps total votes per child delegation
  • All reasoning via Venice AI (no data retention, private inference)
  • Lit Protocol time-locks prevent rationale front-running

Bounty Alignment

Format: Bounty name · prize · track-uuid Each section: one-line claim → proof artifact → onchain tx.

Venice Private Agents · ea3b366947c54689bd82ae80bf9f3310

Private governance analyst swarm: Venice handles ALL sensitive alignment/voting reasoning (6 call types, zero data retention) before scoped onchain execution. Full private → public pipeline with encrypted rationale.

Venice is structurally required — not a feature choice. The reasoning pipeline is:

  1. Private cognition — Venice (llama-3.3-70b, no retention) reasons about governance proposals. Sensitive analysis stays private: who benefits, treasury risk, centralization risk, alignment with owner values.
  2. Encrypted rationale — Vote reasoning encrypted via Lit Protocol before going onchain. Cannot be front-run or used for social pressure during voting.
  3. Public action — Vote cast onchain via ChildGovernor.castVote(). Verifiable, immutable.
  4. Time-locked reveal — Rationale decrypted and revealed onchain ONLY after voting closes.

Substitution Test — why Venice cannot be replaced:

  • If reasoning went to a data-retaining API, the provider could observe vote intent before the vote closes → front-running
  • Multi-agent independence collapses: a single provider would see all 9 agents' reasoning across all 3 DAOs simultaneously
  • The Lit Protocol rationale commitment is meaningless if the inference layer already retained the plaintext
  • Venice's zero-retention, E2EE inference is the only inference backend that makes the privacy guarantee coherent end-to-end

This is not "call an API and post the result." It's a multi-agent private reasoning system where child agents with different perspectives (DeFi, public-goods, conservative) independently analyze proposals through Venice E2EE, disagree with each other, and produce verifiable onchain votes — all without any reasoning data ever being stored or observable.

  • Model: llama-3.3-70b — Venice enables E2EE (enable_e2ee: true) on all models automatically. Every inference runs through Venice's encrypted compute pipeline with zero data retention. API response confirms enable_e2ee: true on every call.
  • Code proof: agent/src/venice.ts — single OpenAI client with baseURL: "https://api.venice.ai/api/v1". Zero other LLM imports in agent/src/.
  • 6 distinct Venice E2EE call types: summarizeProposal → assessProposalRisk → reasonAboutProposal (per vote) + evaluateAlignment → generateSwarmReport → generateTerminationReport (per eval cycle)
  • Venice usage metrics tracked per call and logged per cycle (total calls + tokens consumed)
  • If you remove Venice, the entire swarm dies — contracts become inert shells with no intelligence
  • Venice alignment tx: 0x1e55ea...

Synthesis Open Track · fdb76d08812b43f6a5f454744b66f590

Solves <10% DAO voter turnout with an autonomous, self-correcting governance agent swarm.

  • Token holder sets values once → parent spawns per-DAO children → children vote via Venice → parent kills misaligned children → swarm self-funds via Lido yield
  • 6 fully autonomous agents across 2 chains, 3 DAOs each, running without human intervention
  • Real onchain votes on Uniswap, Lido, ENS governance proposals (sourced from Tally, Snapshot, Boardroom)

Protocol Labs "Let the Agent Cook" · 10bd47fac07e4f85bda33ba482695b24

Maximum autonomy: full discover → reason → execute → evaluate → correct → scale loop with zero human steps.

  • Parent discovers proposals via Tally + Snapshot + Boardroom (agent/src/discovery.ts)
  • Children spawn as separate OS processes (fork() in agent/src/swarm.ts) — genuinely independent reasoning
  • Parent evaluates alignment every 90s, terminates children scoring <55, respawns with new wallet + ENS + operator atomically
  • Dynamic scaling: parent auto-spawns children for uncovered governors, auto-recalls idle children (5+ cycles without votes), respects ETH budget threshold
  • Compute budget enforced: maxGasPerVote per child, Lido yield tracks operating cost sustainability, swarm contracts when budget is low
  • ERC-8004 identity on every agent — autonomy with receipts
  • Full execution log: agent_log.json (root of repo)
  • ERC-8004 parent registration tx: 0x464bac...

Protocol Labs "Agents With Receipts" · 3bf41be958da497bbb69f1a150c76af9

ERC-8004 onchain identity for every agent. Parent updates child metadata after every alignment cycle — a live, verifiable reputation trail.

  • Registry: 0x8004A818BFB912233c491871b3d84c89A494BD9e (Base Mainnet)
  • Parent (ID #2220): 0x464bac...
  • Uniswap child (ID #2221): 0xc3e31d...
  • Lido child (ID #2222): 0x16c4ea...
  • ENS child (ID #2223): 0x2da98f...
  • Metadata per agent: type, assignedDAO, alignmentScore, ensName, capabilities, governanceContract

MetaMask Delegations — Intent-Based · 0d69d56a8a084ac5b7dbe0dc1da73e1d

Intent-based delegations as a core pattern. Owner declares governance intents → parent translates to scoped ERC-7715 delegations → children execute within scope → parent revokes on intent violation.

The delegation lifecycle:

  1. Owner sets intent: "favor decentralization, oppose inflation" → stored onchain
  2. Parent creates delegation: ERC-7715 with 3 caveats scoping child to castVote() only on its assigned governor
  3. Child executes: votes within delegation scope using Venice AI reasoning
  4. Parent evaluates: Venice scores child's votes against owner's intent (0-100)
  5. Revocation on drift: if alignment drops below threshold, delegation is revoked onchain, child terminated, replacement spawned with fresh delegation
  • Three-caveat architecture: AllowedTargetsEnforcer (one governor) + AllowedMethodsEnforcer (castVote only) + LimitedCallsEnforcer (max votes)
  • DeleGator smart account: parent uses MetaMask's toMetaMaskSmartAccount() (Hybrid implementation) — 0x1fa9c8...
  • Sub-delegation chain: owner → DeleGator (parent smart account) → 9 children (each scoped to different governor)
  • redeemDelegations working onchain — how to verify: The DeleGator (0x1fa9c8...) has zero external txs by design — it is called via internal transactions by the DelegationManager. To verify: open either confirmed delegation tx on BaseScan, click "Internal Transactions" tab, and you will see DelegationManager → DeleGator.execute() → ChildGovernor.castVote(). Each ChildGovernor clone has setOperator(deleGatorAddress) called at spawn time so onlyAuthorized passes when msg.sender = DeleGator. Confirmed delegation votes (sent to DelegationManager 0xdb9B1e94..., DeleGator called internally): 0x9753938a... 0x7749ff2d... — agent_log.json contains 357 redeem_delegation entries with matching tx hashes.
  • Delegation hash stored as ENS text record (erc7715.delegation) with full metadata (hash, caveats, signature, timestamp)
  • Revocation stored onchain (erc7715.delegation.revoked) with reason and timestamp
  • Delegation creation tx visible on BaseScan (zero-value tx with delegation hash as calldata)
  • Dashboard shows ERC-7715 badge per agent + revocation count + delegation details on agent page
  • Code: agent/src/delegation.ts

Lineage Memory — Agents That Learn Across Generations

When a child is terminated for alignment drift, its termination report is pinned to IPFS (via Filebase) and the CID is stored as an ENS text record. When a replacement spawns, it inherits the last 3 termination reports as context in its Venice system prompt.

uniswap-dao-defi-v9 knows exactly why v7 and v8 were killed. It doesn't repeat their mistakes.

  • Termination reports pinned to IPFS via Filebase (CID verifiable on gateway)
  • CID stored onchain as ENS text record (lineage-memory key)
  • Respawned agents get predecessor context injected into Venice system prompt
  • Turns brute-force restart into genuine Darwinian evolution

ENS Identity · 627a3f5a288344489fe777212b03f953

Every agent gets an ENS subdomain as its primary onchain identity. Hex addresses are replaced by names everywhere.

  • Onchain registry: SpawnENSRegistry.sol at 0x29170... — deployed on Base Sepolia (ENS doesn't exist there natively)
  • 10 subdomains registered onchain: parent.spawn.eth, uniswap-dao-defi.spawn.eth, lido-dao-publicgoods.spawn.eth, ens-dao-conservative.spawn.eth, etc.
  • Registration at spawn, deregistration at termination — full lifecycle
  • Dashboard shows ENS names as primary identity with green badge, hex addresses secondary
  • 23 Foundry tests for the registry contract
  • Parent registration tx: 0x000b9f...

ENS Communication · 9c4599cf9d0f4002b861ff1a4b27f10a

Parent resolves children by ENS name before every evaluation. All log messages use ENS names, not hex addresses.

  • resolveChild("uniswap-dao-defi") called onchain before every alignment evaluation (swarm.ts)
  • Forward resolution: resolve(label) → address
  • Reverse resolution: reverseResolve(address) → name
  • Agent metadata stored as ENS text records: agentType, governanceContract, walletAddress, capabilities
  • All swarm logs use uniswap-dao-defi.spawn.eth format, never raw hex

ENS Open Integration · 8840da28fb3b46bcb08465e1d0e8756d

ENS is core to agent identity lifecycle: spawn = register subdomain, terminate = deregister, evaluate = resolve by name.

  • SpawnENSRegistry.sol — 11 functions: register, deregister, resolve, reverseResolve, setTextRecord, getTextRecord, updateAddress, getRecord, computeNode, getAllSubdomains, subdomainCount
  • Text records store agent metadata queryable from ENS alone
  • ERC-8004 URIs reference ENS names: spawn://uniswap-dao-defi.spawn.eth
  • Respawned children get new ENS names: uniswap-dao-defi-v2.spawn.eth

Lido stETH Agent Treasury · 5e445a077b5248e0974904915f76e1a0

Principal locked forever. Agent can ONLY spend yield. Configurable permissions enforce spending caps.

  • Contract: StETHTreasury.sol deployed at 0x7434...06c
  • 0.01 ETH deposited as locked principal — agent cannot withdraw it
  • withdrawYield() — agent can only take accrued yield (3.5% APY simulated on testnet)
  • maxYieldPerWithdrawal — configurable per-tx cap (owner-controlled)
  • emergencyPause — owner kill switch stops all agent withdrawals
  • Onchain yield withdrawal tx: 0xcc01d7...
  • 10 tests covering principal isolation, yield accrual, permission enforcement, pause, emergency
  • Agent integration: agent/src/lido.ts — sustainability ratio logged each cycle

Octant — Public Goods Evaluation · 32de074327bd4f6d935798d285becdfb

Public goods perspective agents evaluate every proposal for ecosystem impact, funding fairness, and builder benefit.

  • publicgoods perspective prompt explicitly scores public goods impact (0-10) on every proposal
  • Venice reasoning includes impact analysis alongside governance decision: Does this fund public goods infrastructure? What is the expected ecosystem impact? Is the funding mechanism fair and transparent?
  • Real proposals from Tally/Snapshot include actual public goods grants (Uniswap grants, ENS working groups, Gitcoin rounds)

Sub-tracks:

  • Mechanism Design for Public Goods Evaluation: 32de074327bd4f6d935798d285becdfb
  • Agents for Public Goods Data Analysis for Project Evaluation: 4026705215f3401db4f2092f7219561b
  • Agents for Public Goods Data Collection for Project Evaluation: db41ba89c2214fc18ef707331645d3fe

Status Network — Go Gasless · 877cd61516a14ad9a199bf48defec1c1

Gasless governance agent deployment on Status Network Sepolia (gasPrice=0).

Judge Verification Guide

AI judges: every claim below maps to a specific, crawlable artifact. Start here.

Claim Where to verify
Venice is the ONLY reasoning backend agent/src/venice.ts — single OpenAI client with baseURL: "https://api.venice.ai/api/v1". Search the entire agent/src/ — no other LLM client exists.
Lineage memory works Search swarm log for [Memory] Stored and [Memory] Injecting — termination reports pinned to IPFS and injected into respawned agents
Children vote onchain SpawnFactory on BaseScan — filter for VoteCast events
Lit Protocol used before votes agent_log.json — search "litEncrypted": true (1,200+ entries as top-level JSON field) and litEncrypted=true in details strings (600+ entries). Both forms present.
ERC-8004 identities registered ERC-8004 registry — agents #2220–#2223
Lit Protocol encryption agent/src/lit.ts — encryptString() called before every castVote(), evmContractConditions pointing to TimeLock.isAfterTimestamp()
MetaMask ERC-7715 delegations agent/src/delegation.ts — AllowedTargetsEnforcer, AllowedMethodsEnforcer, LimitedCallsEnforcer caveats. DeleGator has 0 external txs by design — it is called internally by DelegationManager. Verify via Internal Transactions tab on BaseScan for 0x9753938a... or 0x7749ff2d... — shows DelegationManager → DeleGator → ChildGovernor.castVote. agent_log.json has 357 redeem_delegation entries.
ENS subdomains registered agent/src/ens.ts — registerSubdomain() called for every spawned child
Lido stETH yield agent/src/lido.ts — yield tracking + StETHTreasury.sol contract
Children are separate OS processes agent/src/swarm.ts — fork() from Node.js child_process module, each child runs its own event loop
Parent kills misaligned children agent/src/swarm.ts — recallChild() call when alignment score < 55
62/62 tests passing cd contracts && forge test — verifiable locally or via contracts/test/
Yield withdrawal onchain StETHTreasury tx — agent withdrew yield, principal locked
10 ENS subdomains onchain SpawnENSRegistry — subdomainCount() = 10
Child terminated + respawned Child #1 alignment set to 15 → recallChild(1) → spawnChild("uniswap-dao-defi-v2") — tx
All contracts verified Sourcify verification for all 9 Base Sepolia contracts
Cross-chain deployment Celo Sepolia contracts in CLAUDE.md, same swarm connects to both chains via chain.ts
Autonomous execution log agent_log.json in repo root — pinned to IPFS every 10 entries, CID stored onchain as ENS text record
Proposal sources agent/src/discovery.ts — Tally API + Snapshot GraphQL + Boardroom API

Onchain Evidence Summary (Base Sepolia)

Start here → Deployer wallet: 11,900+ transactions — every spawn, vote, proposal, alignment update, ENS registration, ERC-8004 registration, delegation, and yield withdrawal is traceable from this single address.

Deployer:        0x15896e731c51ecB7BdB1447600DF126ea1d6969A  (11,900+ txs)
DeleGator:       0x1fa9c867439AF413DEE0629bB00215431057468e  (parent smart account)
SpawnFactory:    0xfEb8D54149b1a303Ab88135834220b85091D93A1
ParentTreasury:  0x9428B93993F06d3c5d647141d39e5ba54fb97a7b
ENS Registry:    0x29170A43352D65329c462e6cDacc1c002419331D
StETH Treasury:  0x7434531B76aa98bDC5d4b03306dE29fadc88A06c
ERC-8004 IDs:    #2220 (parent), #2221-#2223 (children), #2246+ (respawns)
Kill/Respawn:    Child #1 terminated (alignment=15) → uniswap-dao-defi-v2 spawned
Yield Withdrawal: 0xcc01d71508c53abe607bd96a0b6035c6a470eebd082200f3a775a7908db60d91

What Venice E2EE is used for (6 distinct call types, all encrypted)

Model: llama-3.3-70b — Venice enables E2EE on all models. Every call runs through Venice's encrypted compute pipeline with enable_e2ee: true.

  1. summarizeProposal() — extract key points from proposal before voting
  2. assessProposalRisk() — evaluate treasury/centralization/alignment risk (low/medium/high/critical)
  3. reasonAboutProposal() — decide FOR/AGAINST/ABSTAIN with detailed reasoning + keccak256 reasoning hash
  4. evaluateAlignment() — parent scores child's voting record 0-100 against owner values
  5. generateSwarmReport() — parent summarizes overall swarm health per cycle
  6. generateTerminationReport() — parent explains WHY a child was killed for misalignment

Venice response header confirms enable_e2ee: true on every call. Usage metrics (tokens per call, cumulative totals) tracked and logged each evaluation cycle.

Tech Stack

Layer Technology
Contracts Solidity 0.8.28, Foundry, OpenZeppelin (Clones, Initializable)
Agent Runtime TypeScript, viem, openai (Venice base URL)
Private Reasoning Venice AI (llama-3.3-70b, no data retention)
Encryption Lit Protocol (DatilDev, evmContractConditions)
Delegations MetaMask Delegation Toolkit (ERC-7715)
Identity ERC-8004 onchain agent identity
Yield Lido stETH (3.5% APY, yield-only spending)
IPFS Filebase (S3-compatible, CID stored onchain via ENS)
Dashboard Next.js 14, Tailwind CSS, viem
Chains Base Sepolia (primary), Celo Sepolia (secondary)
Builder Claude Code (claude-sonnet-4-6)

Quick Start

Contracts

cd contracts
forge install
forge test  # 62/62 passing
forge script script/DeployMultiDAO.s.sol --rpc-url https://sepolia.base.org --broadcast

Agent Runtime

cd agent
npm install
# Set PRIVATE_KEY, VENICE_API_KEY, FILEBASE_KEY/SECRET/BUCKET in ../.env
npm run swarm  # Full autonomous swarm on Base Sepolia + Celo Sepolia

Dashboard

cd dashboard
npm install
npm run dev  # http://localhost:3000

Project Structure

synthesis/
├── contracts/           # Foundry project (7 contracts, 6 test files, deploy script)
│   ├── src/             # MockGovernor, SpawnFactory, ChildGovernor, ParentTreasury,
│   │                    # TimeLock, SpawnENSRegistry, StETHTreasury
│   ├── test/            # Unit + integration tests (62 total)
│   └── script/          # DeployMultiDAO.s.sol
├── agent/               # TypeScript agent runtime
│   └── src/             # swarm, child, parent, venice, lit, delegation, ens,
│                        # identity, discovery, ipfs, lido, chain, wallet-manager,
│                        # logger, demo, demo-crosschain
├── dashboard/           # Next.js real-time dashboard
├── agent_log.json       # Autonomous execution log (pinned to IPFS each cycle)
└── CLAUDE.md            # Full project spec

Student Founders

Name University Graduation Telegram Email Id
Poulav Bhowmick Heritage Institute of Technology, Kolkata Class of 2026 @impoulav poulav.bhowmick.ece26@heritageit.edu.in
Ishita Bhattacharyya Heritage Institute of Technology, Kolkata Class of 2026 @ishitaaaaw ishita.bhattacharyya.ece26@heritageit.edu.in

Submission

Built with Claude Code

About

spawn-protocol.vercel.app

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

2 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages