Octant Council Builder

What Is This? (The Simple Version)

The Problem

Imagine you're deciding which projects should get funding. You could ask one person to review everything — but one person has blind spots. Maybe they love the tech but miss that the project has no real users. Or they're excited about the community but don't notice the money is running out.

The Solution: A Council

Instead of one reviewer, you assemble a council of specialists. One looks at the code. Another checks if people actually use it. Another follows the money. Another plays devil's advocate and tries to find problems. Another checks if the project is governed in a way that will last.

Here's the key: they work in separate rooms. The technical reviewer can't peek at what the financial reviewer wrote. The community reviewer doesn't know what the skeptic found. They each write their honest assessment alone.

Then a chair reads ALL the assessments, spots where they agree and disagree, and writes one final recommendation: fund it, fund it with conditions, or don't fund it.

What This Tool Does

This tool builds that council for you using AI agents. Each "specialist" is a Claude agent with specific instructions and data sources. You tell it what kind of projects you want to evaluate, and it creates the right team of agents.

It ships with agents pre-built for Octant/Ethereum public goods — projects that build open-source tools, infrastructure, and commons for the Ethereum ecosystem. But you can redesign it for any domain: DeFi protocols, climate DAOs, research grants, developer tools, etc.

Why "Council Builder" and Not Just "Council"?

Because you decide what the council evaluates. The agents that ship with this repo are a starting point. Run /council:setup and reshape the council for your own domain. Change which data sources agents look at. Change what dimensions they score. Change how the final report looks. The execution engine (three waves, parallel agents, independent scoring) stays the same — you customize what happens inside each wave.

The Three-Wave Pattern

Every council evaluation runs in three sequential waves. Within each wave, agents run in parallel.

Wave Gates

Each wave must fully complete before the next begins. The orchestrator polls task status until all agents in a wave report completion. This ensures:

• Wave 2 evaluators have complete data to work with
• Wave 3 synthesizers have all scores before writing the report
• No agent reads partial or in-progress output

Quickstart

Three steps to your first evaluation:

/council:settings

/council:evaluate Protocol Guild

/council:setup DeFi lending protocols
/council:setup climate impact DAOs
/council:setup developer tooling grants

Commands

Make It Yours

Everything is customizable. The plugin is a council factory, not a finished council.

Domain Ideas

Data Agents (Wave 1)

These agents gather raw information from external sources. They run in parallel and write structured JSON or markdown to council-out/{slug}/data/.

Eval Agents (Wave 2)

Independent evaluators that each score the project on 5 dimensions (1–10 scale). They read all Wave 1 data but never see each other's scores.

Synth Agents (Wave 3)

Synthesis agents read all Wave 2 outputs and can talk back to evaluators via team messaging to ask clarifying questions before writing the final report.

Synthesis Approaches

Output Structure

Every evaluation produces a structured directory in council-out/. The slug is derived from the project name (lowercase, hyphens, max 40 chars).

Example: Protocol Guild Evaluation

Here's a real evaluation output from the default scaffold council running on Protocol Guild.

Executive Summary

Key Risk Identified

Recommendation Criteria

Ostrom Governance Scoring

One of the most unique features of the council is its evaluation of projects against Elinor Ostrom's 8 Design Principles for managing commons — translated from physical commons (fisheries, forests) to digital public goods (code, protocols, data, treasuries).

The 8 Principles

Example: Protocol Guild Ostrom Scores

Governance Maturity Levels

EAS On-Chain Attestations

The council produces Ethereum Attestation Service (EAS) compatible JSON that can be submitted on-chain to Base (Chain ID: 8453). This creates a permanent, verifiable record of the evaluation.

What Gets Attested

Example Attestation JSON

{
  "schema": "0x000...000",
  "data": {
    "recipient": "0xF6CBDd6Ea6EC3C4359e33de0Ac823701Cc56C6c4",
    "revocable": true,
    "data": {
      "projectSlug": "protocol-guild",
      "ostromOverallScore": 75,
      "rule1_boundaries": 88,
      "rule2_congruence": 82,
      "rule3_collectiveChoice": 76,
      "rule4_monitoring": 90,
      "rule5_sanctions": 38,
      "rule6_conflictResolution": 55,
      "rule7_recognitionOfRights": 78,
      "rule8_nestedEnterprises": 72,
      "quantCompositeScore": 86,
      "governanceMaturity": "established",
      "evaluatedAt": "2026-03-22"
    }
  }
}

Architecture

Project Structure

Key Design Patterns

Agent Lifecycle

Every agent follows the same pattern:

1. TaskUpdate — claim the task (status: "in_progress")
2. [Specific work] — fetch data / score dimensions / synthesize
3. Write output — structured JSON or markdown to $OUTPUT_DIR
4. TaskUpdate — complete the task (status: "completed")
5. SendMessage — summary to team lead

Extending the Council

Adding a Custom Agent

Two ways to add an agent:

Option A: Use the guided flow

/council:add-agent

This runs a conversation to design the agent, researches the domain, generates the markdown file, and creates documentation.

Option B: Create a file manually

Create a markdown file in agents/ with the right prefix:

# agents/eval-security.md
---
name: Security Evaluator
description: Evaluate smart contract security posture
tools: Read, Write, WebSearch, WebFetch, SendMessage, TaskUpdate
---

# Security Evaluator: Smart Contract Audit Assessment

You are an independent security evaluator...

## Dimensions (each 1-10)
1. Audit coverage
2. Bug bounty program
3. Formal verification
4. Incident response history
5. Dependency risk

## Output
Write your evaluation to `$OUTPUT_DIR/security.md`

Removing an Agent

/council:remove-agent
# Shows list of agents and impact preview before deletion

Or just delete the file from agents/. No config to update.

Sharing Your Council

A council is just a repo. Fork it, redesign the agents, push it, share the URL. Anyone can install it in Claude Code:

fetch https://raw.githubusercontent.com/YOU/YOUR_REPO/main/SKILL.md and follow the instructions

OptInPG: Public Goods Evaluation Extension

The OptInPG extension transforms the generic council builder into a production-grade Octant public goods evaluation platform. It adds Octant-native data sources, Elinor Ostrom's commons governance scoring, EAS on-chain attestations, and a full-stack deployment pipeline — all without changing a single line of the original plugin.

What Was Added

Design Decisions

Octant-Specific Agents

Nine new agents purpose-built for Octant public goods evaluation. They slot into the existing wave pattern — the orchestrator discovers them automatically by filename prefix.

Wave 1: Octant Data Collectors (4 agents)

These scrape Octant-specific data sources that the generic data agents don't cover.

Wave 2: Octant-Tuned Evaluators (3 agents)

These evaluators are calibrated specifically for public goods scoring.

Wave 3: Octant Synthesizers (2 agents)

The Ostrom Framework: Why It Matters

Most grant evaluation asks "Is this a good project?" The Ostrom framework asks "Is this project governed in a way that will sustain itself as a commons?"

Elinor Ostrom won the Nobel Prize in Economics (2009) for proving that communities can effectively govern shared resources without privatization or top-down control. Her 8 Design Principles (from Governing the Commons, 1990) were originally developed studying fisheries, forests, and irrigation systems. We translated them to digital public goods: open source code, protocols, data, and treasuries.

Physical Commons → Digital Translation

How Scoring Works

Each principle is scored 0-100 with a detailed rubric. For example, Principle 1 (Boundaries):

Principles 1, 3, and 4 are weighted at 1.25x (most critical for digital commons). Principle 5 is weighted at 0.75x (hardest to evidence for early-stage projects). The overall score is a weighted average.

Why This Changes Evaluation

A project can score 9/10 on technical quality and community strength, but if its governance is fragile — no conflict resolution, no graduated sanctions, one foundation can override everything — the Ostrom lens catches that. It's the difference between "this is a good project today" and "this project has the governance structures to remain a healthy commons for years."

EAS Attestation Pipeline

Every evaluation can be permanently recorded on-chain using the Ethereum Attestation Service on Base (Chain ID: 8453). This creates a verifiable, queryable record that anyone can check.

How the Pipeline Works

Schema (Registered on Base)

// Solidity-compatible schema for EAS SchemaRegistry.register()
string projectSlug,
address projectWallet,
uint8 epochNumber,
uint8 ostromOverallScore,
uint8 rule1_boundaries,
uint8 rule2_congruence,
uint8 rule3_collectiveChoice,
uint8 rule4_monitoring,
uint8 rule5_sanctions,
uint8 rule6_conflictResolution,
uint8 rule7_recognitionOfRights,
uint8 rule8_nestedEnterprises,
uint8 quantCompositeScore,
uint8 activityScore,
uint8 ecosystemImpactScore,
uint8 transparencyScore,
string governanceMaturity,
string ipfsReportHash,
string evaluatedAt

Full Walkthrough: End-to-End Evaluation

Here's exactly what happens when you run /council:evaluate Protocol Guild with the OptInPG extension installed.

Step 1: Orchestrator Setup

The evaluate skill parses "Protocol Guild" → slug protocol-guild. It discovers all agents by filesystem prefix, creates a team, and pre-creates tasks for all 19 agents across 3 waves.

Step 2: Wave 1 — Data Gathering (parallel)

All 8 data agents spawn in a single message (true parallelism). Each writes to council-out/protocol-guild/data/:

Plus: data-github, data-web, data-onchain, data-funding run in parallel alongside the Octant-specific agents.

Step 3: Wave 2 — Independent Evaluation (parallel)

All 8 eval agents spawn in a single message. Each reads ALL Wave 1 data files but never sees other evaluators' scores.

Plus: eval-impact (9/10), eval-technical (7/10), eval-community (9/10), eval-financial (8/10).

Step 4: Wave 3 — Synthesis

Three synthesis agents read ALL Wave 2 outputs. The chair can send messages back to evaluators asking for clarification.

Step 5: Report Presented

Final output in council-out/protocol-guild/:

Hosting & Deployment

The OptInPG extension includes a full production deployment stack. Here's the current status:

Documentation Site

This page you're reading is hosted on GitHub Pages at rashmi-278.github.io/octant-council-builder. Automatically deploys from the docs/ folder on the main branch.

Backend API (3 FastAPI Microservices)

Three Python services mirror the three-wave pattern:

All services include health checks, slug validation (regex ^[a-z0-9][a-z0-9-]{0,39}$ to prevent path traversal), and configurable CORS origins.

Deploy to Railway

# Option 1: Use the skill (handles everything)
/council:deploy-to-production protocol-guild

# Option 2: Manual deploy with Railway CLI
cd production/backend/evaluator
railway up --detach

Frontend Dashboard (Next.js 15)

Next.js 15 + React 19 + Tailwind CSS dashboard with:

• Interactive Ostrom radar chart (custom SVG renderer, 8 axes)
• Projects list with evaluation status
• Per-project detail view: data → evals → synthesis → report
• "Attest on Base" button (ethers.js + EAS SDK integration)
• Markdown rendering for full reports
• Octant-branded color scheme

Deploy to Netlify

# Static export (no server needed)
cd production/frontend
npm install && npm run build
netlify deploy --prod --dir=out

# Or use the deploy skill which handles both backend + frontend
/council:deploy-to-production protocol-guild

Local Preview

# Run backend locally
cd production/backend/evaluator
pip install -r requirements.txt
uvicorn main:app --port 8000

# Run frontend locally (in another terminal)
cd production/frontend
npm install && npm run dev
# Dashboard at http://localhost:3000

Test on 5 Octant Projects

/council:test-octant
# Runs full evaluation pipeline on:
# Protocol Guild, L2BEAT, growthepie, Revoke.cash, Tor Project

Production Architecture

The deployment mirrors the three-wave agent pattern:

Extended by Rashmi-278

What Was Added (Comprehensive)

Total: 49 new files, 4,705+ lines added, 0 lines modified in original plugin.

Octant Synthesis Hackathon Tracks

The OptInPG extension was built to cover three hackathon tracks simultaneously:

Why These Three Tracks Fit Together

The tracks aren't independent — they form a pipeline:

A project gets evaluated (Track 1), that evaluation includes governance depth via Ostrom (Track 2), and the results are permanently recorded on-chain (Track 3). Each track makes the others more valuable: attestations are only worth recording if the evaluation is rigorous, and the evaluation is only rigorous because it includes governance analysis most frameworks skip.