Project Info

GOVWORLD — The Living City

This project did not submit a demo video on Devpost.

Inspiration

Every infrastructure decision a government makes starts somewhere as a row in a spreadsheet: a road gets widened, a budget gets approved, a contract gets signed. But the people who actually live and work on that street can become an afterthought. We kept asking one question: What if decision-makers could see how a policy affects real people before a single brick is laid? That became GOVWORLD: a human-first infrastructure simulator. Instead of treating roads, budgets, and contracts as the final output, we treat them as inputs and simulate their effects on people’s daily lives.

What it does

GOVWORLD is a SimCity-style policy simulator that lets users place an infrastructure proposal into a living city of AI citizens, observe its consequences over time, hear competing expert perspectives, and identify accountability risks before public money moves. Our demo models San Francisco’s Van Ness Avenue Complete Streets project, a roughly $45M and 18-month infrastructure effort. A living population The city contains around 50 AI citizens. Each has a name, job, family situation, income, concerns, aspirations, and a daily route through the neighborhood. Users can click on citizens such as: Jasmine, an SFMTA bus driver Tony, a restaurant owner Earl, a retired resident with diabetes and no car They can then speak with these citizens by voice to understand how construction affects their lives. An adversarial policy council A council of ten AI expert personas, including an economist, transit engineer, climate analyst, community advocate, lawyer, and corruption watchdog, debates the proposed policy. Each expert researches relevant live information, forms a distinct perspective, and argues through synthesized speech. The goal is not to create fake agreement. The goal is to surface tradeoffs decision-makers may otherwise miss. A 12-month city simulation A generative-agent director advances the city through a 12-month timeline. It introduces realistic disruptions such as: Utility conflicts Weather delays Contractor fraud Permit challenges Legal injunctions As events unfold, citizens’ wellbeing changes from green to amber to red, showing how one infrastructure decision can ripple through jobs, mobility, health access, local business revenue, and trust in government. An accountability ledger GOVWORLD tracks contractors, budget lines, project milestones, delays, and cost overruns. It flags potential risks before they become invisible problems buried in project documentation.

How we built it

GOVWORLD is a browser-first application built with: React 18, Vite, and TypeScript for the application Zustand for state management Leaflet and OpenStreetMap for the interactive city map react-three-fiber for the 3D debate arena A centralized llm.ts routing layer so models can be swapped by task We used different AI providers based on what each task required: Our simulation engine is inspired by Stanford’s Generative Agents research. Citizens retain memory streams, and the director retrieves relevant memories using a weighted combination of recency, importance, and relevance. This lets past events meaningfully shape future citizen reactions instead of making each simulation step feel disconnected. We also built the project with Claude Code as our pair-programmer. How we used Arize Phoenix We traced every council argument in Arize Phoenix and evaluated responses with a Claude-based judge on two criteria: Whether the expert cited named sources Whether the argument was coherent, specific, and evidence-based The evaluation exposed a real failure mode. Without an explicit instruction, our experts cited named sources 0% of the time and relied on vague claims. We added a requirement that each expert cite at least two named sources, then re-ran the evaluation. That loop of tracing, evaluating, fixing, and re-evaluating made the system measurably more accountable instead of relying on whether the outputs merely “felt good.”

Challenges we ran into

Connecting browser-side AI calls with Python evaluation tooling Arize Phoenix evaluations are Python-based, while our application runs in the browser. We handled this through browser-side OpenTelemetry instrumentation and a CORS-enabled tracing workflow, without exposing API keys to users. Provider reliability During development, Groq was blocked on our network and Gemini’s free tier rate-limited heavily. We made our model routing provider-agnostic and moved the evaluation judge to Claude so our evaluation loop could continue. Making each simulation rerun genuinely different Our first rerolls changed the edge-case panel but did not meaningfully affect the main story. We expanded the event pool from 10 to 28 scenarios, sampled 5 to 7 seeded events per run, and injected them directly into the simulation timeline. Now each run produces a different but coherent city story. Demo reliability Hackathon judges should not have to watch loading spinners. We precomputed and cached all AI outputs for the primary demo scenario, allowing the full experience to run with zero live API calls if the network fails.

What we learned

Building generative agents is not just about creating personalities. It is about modeling memory, reflection, cascading consequences, and compounding failures. LLM observability turns “this response feels weak” into an issue that can be measured, fixed, and re-tested. Multi-provider AI routing improves resilience, but every external dependency needs a fallback plan. The hardest part of simulating a city is not rendering the map. It is making every citizen feel like a person whose life deserves consideration.

What's next

Scale from approximately 50 citizens to 1,000 through our prototype social-opinion swarm pipeline. Allow governments, researchers, and communities to upload a real proposed policy for any neighborhood. Connect the Arize evaluation loop to CI so every prompt change is automatically tested for evidence quality, safety, and reasoning. Expand the accountability ledger into a more robust early-warning system for delays, overruns, and procurement risks. Our north star Human-first, not infrastructure-first. The road is the input. The human life is the output.

GovWorld — The Living City

An AI-populated city simulation that lets governments see the human consequences of infrastructure decisions — before a single brick is laid.

Think SimCity, but every citizen is an AI person with a name, a job, a family, and a voice. You paste a policy. The city comes alive. People react. Things go wrong. The truth comes out.

What It Does

Policy input — paste any infrastructure policy (road widening, BRT lane, utility upgrade).
Living map — 50 AI citizens appear as dots moving along their daily routes on an interactive map.
Council debate — 2–7 adversarial AI experts (economist, engineer, climate analyst, community advocate, corruption watchdog, and more) stream arguments about the policy in a cinematic 3D arena, each backed by live web research.
12-month simulation — fast-forward through monthly consequences; citizen statuses update, construction overlays advance, and flags fire automatically.
Voice chat — click any citizen dot, press Talk, and hold a live voice conversation with them in character.
Accountability ledger — every construction task is tracked with contractor history, delay flags, and budget burn.

Demo Scenario

Van Ness Avenue Complete Streets — Phase 1 San Francisco · Market St → Jackson St · $45M · 12 monthly ticks

Featured Citizens

ID	Name	Age	Role	Arc
C001	Jasmine Chen	34	SFMTA Bus Driver	Route disrupted for 8 months; normalises at Month 12
C002	Tony Ricci	57	Restaurant Owner	Storefront access blocked; revenue drops, then recovers
C003	Sofia Rodriguez	26	Civil Engineer	Assigned as on-site inspector from Month 2
C004	Earl Washington	72	Retired (diabetic, no car)	New road finally connects him to his clinic
C005	Amy Park	41	Elementary School Teacher	Dust and noise affect her classroom for 6 months
C006	Tyler Brooks	29	Startup Founder, cyclist	Cycling lane removed; considers relocating

The 90-Second Judge Demo

Policy is pre-loaded → press Run Policy Council → debate cards stream simultaneously.
Press Run 12 Months → citizen dots change colour and scaffolding appears on the map.
Click Jasmine Chen → press Talk → ask "How is this affecting you?" → she answers by voice, in character.
Scrub to Month 12 → road complete → Earl turns green and Contractor B is red-flagged in the ledger.

Tech Stack

Layer	Technology
Framework	React 18 · Vite · TypeScript
Styling	Tailwind CSS — warm "mission control" theme (`#160c06` / `#ffb690` / `#f97316`)
2D map	Leaflet + OpenStreetMap via `react-leaflet` (no API key required)
3D globe	Cesium (optional, requires an Ion token)
3D council arena	Three.js + `@react-three/fiber` + Drei
Ambient sound	Tone.js
State	Zustand
Citizens, council, simulation	Gemini 2.5 Flash (`@google/generative-ai`)
Real-time voice chat	Groq Llama 3.3 70B (`groq-sdk`)
Text-to-speech	Deepgram Aura-2, with Web Speech API fallback
Voice input	Web Speech API (`SpeechRecognition`)
Live council research	Browserbase (server-side Search + Fetch)
Observability & evals	Arize Phoenix + OpenTelemetry / OpenInference

Quick Start

Demo mode — zero API calls

npm install
npm run demo

Opens at http://localhost:5173 with all data pre-loaded from src/data/. No keys needed.

Live mode

cp .env.example .env.local
# fill in your keys (see API Keys below)
npm run dev        # app only
npm run dev:full   # app + research API server (Vite + Express together)

dev:full runs Vite alongside the local Express shim (server/dev.ts, port 3001) that serves the Browserbase research endpoint — the same code Vercel runs as a serverless function in production (api/research.ts). Vite proxies /api → localhost:3001.

API Keys

Copy .env.example to .env.local and fill in the keys you need. Never commit .env.local.

# === Required for live LLM features ===
VITE_GEMINI_API_KEY=        # aistudio.google.com — free tier
VITE_GROQ_API_KEY=          # console.groq.com — free tier
VITE_DEEPGRAM_API_KEY=      # console.deepgram.com — free tier (TTS)

# === Live council research (server-side only — never bundled into the browser) ===
BROWSERBASE_API_KEY=        # browserbase.com — powers expert web research
BROWSERBASE_PROJECT_ID=

# === Optional ===
VITE_CESIUM_TOKEN=          # cesium.com/ion — only for the 3D globe view
VITE_GOOGLE_MAPS_API_KEY=   # console.cloud.google.com — not used by the Leaflet map

# === Demo flags (no keys needed) ===
VITE_DEMO_MODE=false        # true = run entirely from pre-computed JSON
VITE_SKIP_API=false         # true = force demo data even if keys are present
VITE_DEMO_NEIGHBOURHOOD=andheri  # which neighbourhood to load in demo
VITE_AUTO_DEMO=false        # true = auto-run the demo on load (unattended kiosks)
ANTHROPIC_API_KEY=

Demo mode is active whenever VITE_DEMO_MODE=true or VITE_SKIP_API=true. Every LLM call then loads from pre-computed JSON in src/data/ instead of hitting an API.

The BROWSERBASE_* keys are not prefixed VITE_, so they stay server-side and are never exposed in the client bundle.

Available Scripts

Command	What it does
`npm run demo`	Start in demo mode — no API calls, fully interactive
`npm run dev`	Start the app in live mode with hot reload
`npm run dev:api`	Run only the Express research server (`server/dev.ts`)
`npm run dev:full`	Run Vite + the research server together (via `concurrently`)
`npm run live`	Live mode with Phoenix tracing enabled (`VITE_PHOENIX_TRACING=true`)
`npm run build`	Production build (`tsc` + Vite)
`npm run preview`	Preview the production build
`npm run precompute`	Re-generate all `src/data/` JSON via LLM (requires API keys)
`npm run typecheck`	TypeScript check, no emit
`npm run lint`	ESLint across `src/`

Live Council Research

Council experts back their arguments with real web sources via Browserbase:

api/research.ts — Vercel serverless function: POST /api/research with { queries[], scrapeUrls?, maxFacts? } → { facts[] }.
api/_browserbase.ts — the Search + Fetch implementation; holds the API key server-side.
server/dev.ts — local Express shim so npm run dev:full works end-to-end without the Vercel CLI.

When research is unavailable, the council falls back to its pre-computed demo facts.

Observability & Evals (Arize Phoenix)

The eval/ directory wires Arize Phoenix into the adversarial council debate to run a full trace → eval → close-the-loop cycle. Every expert argument is traced, scored by an LLM-as-judge, and the failure explanations drive a measurable prompt fix.

Tracing — src/lib/tracing.ts wraps generateCouncilArgument (Gemini) and generateTurnArgument (Groq) in OpenInference LLM spans, exported via OTLP/HTTP. The Vite dev server proxies /v1/traces → Phoenix at localhost:6006, keeping the browser same-origin (no CORS, no key in the client). Enabled only when VITE_PHOENIX_TRACING=true (npm run live); a no-op in demo mode.
Judge — eval/judge.py runs Claude as an LLM-as-judge over council spans, scoring evidence_citation and argument_quality, logging annotations, and printing the before/after delta.
Seed — eval/seed_traces.py emits reproducible before/after spans so the loop runs without the UI.

Headline result: Phoenix surfaced that, without an explicit "cite ≥2 named sources" instruction, experts cited zero sources. Adding that mandate to EXPERT_SYSTEM_PROMPTS in src/lib/llm.ts moved evidence_citation from 0% → 100% and argument_quality from 50% → 100%. See eval/README.md for the full run instructions.

Project Structure

govworld/
├── src/
│   ├── App.tsx                  # Root: loads demo data, renders Shell
│   ├── components/
│   │   ├── map/                 # Leaflet map, citizen dots, construction overlay, Cesium globe
│   │   ├── citizens/            # CitizenCard, CitizenList, CitizenStatus
│   │   ├── council/ debate/     # Debate panels, AgentCard, cinematic 3D arena
│   │   ├── simulation/          # Tick engine, TimelineBar, EventFeed, SimControls
│   │   ├── voice/               # CitizenChat, VoiceIndicator, TranscriptPanel
│   │   ├── ledger/              # AccountabilityLedger, TaskRow, ContractorFlag
│   │   ├── swarm/               # Social-opinion swarm engine + views
│   │   ├── notifications/       # Dissatisfaction alerts
│   │   ├── common/              # Shared UI primitives
│   │   └── layout/              # Shell, Sidebar, TopBar, PanelManager
│   ├── store/                   # Zustand: world, citizen, council, simulation, ledger, swarm, ui
│   ├── lib/                     # llm.ts, speech.ts, deepgram.ts, tracing.ts, constants.ts, …
│   ├── data/                    # Pre-computed demo JSON (citizens, policy, debate, ticks, ledger)
│   ├── hooks/                   # useCitizen, useSimulation, useCouncil, useSpeech, useWeather
│   └── types/                   # citizen, policy, council, simulation, ledger, swarm
├── api/                         # Vercel serverless: research.ts + _browserbase.ts
├── server/dev.ts                # Local Express shim for the research API
├── eval/                        # Arize Phoenix evals: judge.py, seed_traces.py, README.md
├── scripts/precompute_demo.ts   # Regenerates src/data/ via Gemini + Groq
├── .claude/agents/              # Claude Code subagent definitions (6 agents)
├── AGENT_*.md                   # Per-agent task specs (map, citizens, council, sim, voice, ledger)
├── DESIGN.md · nvidia/DESIGN.md # Design-system references
├── CLAUDE.md                    # Master specification + as-built status
└── TASKS.md                     # Multi-agent task board

Agent Architecture

GovWorld was built with six isolated Claude Code subagents, each owning a module slice:

Agent	Owns	Key responsibility
Map	`components/map/`, `store/worldStore`	Leaflet map, citizen dots, construction overlays
Citizen	`components/citizens/`, `store/citizenStore`	50 AI citizen profiles, status tracking
Council	`components/council/`, `store/councilStore`	10-expert pool, cinematic 3D debate arena
Simulation	`components/simulation/`, `store/simulationStore`	12-tick engine, generative-agents memory loop, edge cases
Voice	`components/voice/`, `lib/speech.ts`	Deepgram TTS, Groq voice chat, Web Speech fallback
Ledger	`components/ledger/`, `store/ledgerStore`	Task tracking, contractor flags, worker assignment

All LLM calls route through src/lib/llm.ts — never called directly from components.

Council Expert Pool

Users pick 2–7 experts from a pool of 10 San Francisco domain specialists:

Economist · Community Advocate · Civil Engineer · Corruption Watchdog · Climate Analyst · Transportation Lawyer · Urban Planner · Public Health Officer · Transit Expert · Heritage Preservation Officer

The 3D Council Arena (src/components/council/arena/) runs a round-robin sentence queue with pause, skip, and abort controls. Expert voices are synthesised via Deepgram Aura-2 with a distinct voice per expert.

Simulation Engine

Director (src/lib/simulationDirector.ts) — generative-agents-inspired memory streams, reflection, and planning (Park et al., 2023).
Edge cases fire automatically: contractor delays, weather impacts, utility bursts, budget overruns.
Swarm pipeline (src/lib/swarmSimulation.ts) — a social-opinion simulation: Seed → Ontology → Knowledge Graph → Personas → multi-agent social posts → prediction report, with views under components/swarm/.

Accountability Ledger

Eight pre-built construction tasks for the Van Ness demo, with:

Automatic delay flags when actual progress falls more than 10% behind projection.
Budget flags when spend exceeds 115% of contract.
Pre-loaded contractor history (Ram Construction, Bharat Infra, CityUtil Services, SignPro Ltd).
Weather-impact days drawn from the Open-Meteo API, with fallback demo data.

License

Private / hackathon project.

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
ExpressIn code
Google GeminiIn code
HTMLIn code
JavaScriptIn code
OpenAIIn code
PythonIn code
ReactIn code
Tailwind CSSIn code
TypeScriptIn code
Node.jsClaimed

11 of 12 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

Claude CodeConfig · Commits
CursorCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

876 KB

Source files

110

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

Feature verification

18 Verified3 Code-supported1 Claimed only

12-month simulation with generative-agents-style directorVerified
A generative-agent director advances the city through 12 months using memory streams, reflection, and planning (Park et al. 2023)
Claimed on readmehigh confidence
- src/lib/simulationDirector.ts:3 — Comment states implementation of memory streams, reflection, planning, cascading edge cases
- src/lib/simulationDirector.ts:55 — reflections field distilled every 3 months, consistent with generative-agents pattern
50 AI citizens with full profiles (name, job, family, income, fears, hopes, daily route)Verified
City contains ~50 AI citizens each with name, job, family situation, income, concerns, aspirations, daily route
Claimed on Devposthigh confidence
- src/data/demo_citizens.json — 50 citizen entries found; contains fields matching Citizen interface (fears, hopes, dailyRoute etc per CLAUDE.md spec)
- src/types/citizen.ts — Citizen type defines fears/hopes/familyStructure/dailyRoute fields
Accountability ledger with contractor history, delay/budget flagsVerified
Every construction task tracked with contractor history, delay flags, and budget burn; budget flag over 115% of contract
Claimed on readmehigh confidence
- src/components/ledger/TaskRow.tsx:34 — isOverBudget computed as spentToDate > budget * 1.15, matching the claimed budget-flag threshold
- src/data/demo_ledger.json:32 — Contains flagged task status and contractor history text
Arize Phoenix tracing of council argumentsVerified
Every council argument is traced in Arize Phoenix via OpenTelemetry/OpenInference spans
Claimed on Devposthigh confidence
- src/lib/tracing.ts:1 — Implements OpenTelemetry + OpenInference spans exported via OTLP/HTTP for Phoenix
- src/lib/tracing.ts:33 — OTLPTraceExporter configured to export traces
Browserbase-powered server-side research API (never exposes key to browser)Verified
BROWSERBASE_* keys stay server-side via api/research.ts and server/dev.ts, never bundled into the client
Claimed on readmehigh confidence
- api/_browserbase.ts:9 — Comment and code confirm BROWSERBASE_API_KEY read via process.env (server-side), not VITE_-prefixed
- server/dev.ts — Local Express shim serving the research endpoint for dev
Cinematic 3D council debate arenaVerified
Experts stream arguments in a cinematic 3D arena with synthesized speech
Claimed on readmehigh confidence
- src/components/council/arena/CouncilArena.tsx — 3D arena component exists
- src/components/council/arena/ExpertAvatar3D.tsx — 3D expert avatars implemented
- src/components/council/arena/DebateControls.tsx — Pause/skip/abort debate controls exist alongside CouncilChamber3D
Claude-based LLM judge evaluating evidence citation and argument qualityVerified
Claude judge scores whether experts cited named sources and whether arguments were coherent/evidence-based
Claimed on Devposthigh confidence
- eval/judge.py:47 — Defaults to Claude (claude-sonnet-4-6) as judge model, falls back to Gemini
- eval/judge.py:5 — Comment states judge scores on two criteria and writes labels/explanations back to Phoenix
Council debate with 2-7 adversarial expertsVerified
Users pick 2-7 experts from a pool of 10 SF domain specialists to debate the policy
Claimed on readmehigh confidence
- src/store/councilStore.ts:282 — Enforces min 2 / max 7 selectable experts
- src/lib/llm.ts — EXPERT_SYSTEM_PROMPTS defines per-expert persona prompts for the pool
Deepgram Aura-2 text-to-speech per expertVerified
Expert arguments are spoken via Deepgram Aura-2 with distinct voices per expert
Claimed on readmehigh confidence
- src/lib/deepgram.ts:8 — DEEPGRAM_VOICE_MAP assigns a distinct aura-2 voice id per expert
- src/lib/deepgram.ts:214 — Calls Deepgram /v1/speak endpoint
Demo mode with zero live API calls (pre-computed JSON)Verified
All AI outputs are precomputed and cached; full demo runs with zero live API calls if network fails
Claimed on readmehigh confidence
- src/data/demo_citizens.json — Pre-computed data file present
- src/data/demo_council_debate.json — Pre-computed council debate data present
- src/data/demo_voice_responses.json — Pre-computed voice responses for offline demo
Expanded edge-case event pool (10 to 28 scenarios, 5-7 sampled)Verified
Event pool expanded from 10 to 28 scenarios, 5-7 sampled per run for varied reruns
Claimed on Devpostmedium confidence
- src/lib/simulationDirector.ts:236 — EDGE_CASE_TEMPLATES array contains ~28-29 category entries, matching the claimed pool size
- src/lib/simulationDirector.ts:557 — seededPick(EDGE_CASE_TEMPLATES, ecCount, seed) samples a subset per run
Leaflet + OpenStreetMap map (not Cesium)Verified
2D map uses Leaflet + OpenStreetMap via react-leaflet, no API key required
Claimed on readmehigh confidence
- src/components/map/CesiumWorld.tsx:1 — File comment states it uses Leaflet + OpenStreetMap despite the Cesium-sounding filename; imports MapContainer/TileLayer from react-leaflet
Live expert web research backing argumentsVerified
Each expert researches relevant live information (via Browserbase) before arguing and cites sources
Claimed on readmehigh confidence
- api/_browserbase.ts:14 — Implements Browserbase Search/Fetch calls server-side using BROWSERBASE_API_KEY
- api/research.ts — Serverless endpoint wraps browserbase research
- src/lib/llm.ts:300 — Expert prompt requires citing at least 2 named sources from the live research block
Living map with AI citizen dotsVerified
50 AI citizens appear as dots moving along daily routes on an interactive map
Claimed on readmehigh confidence
- src/data/demo_citizens.json — Contains 50 citizen records
- src/components/map/CesiumWorld.tsx:1 — Renders Leaflet map (react-leaflet); citizen dots component referenced in map directory
Multi-provider LLM routing (Gemini/Groq/Claude fallback)Verified
Model routing made provider-agnostic; evaluation judge moved to Claude when Groq/Gemini were unreliable
Claimed on Devposthigh confidence
- src/lib/llm.ts:94 — Groq client used for real-time calls
- eval/judge.py:52 — Falls back between Anthropic and Google providers depending on key availability
Policy input and pasteVerified
Users can paste any infrastructure policy which is used to run the council debate
Claimed on readmehigh confidence
- src/components/council/PolicyInput.tsx:38 — PolicyInput component holds pre-loaded/pasteable policy text and wires policyText into startDebate
Voice chat with citizensVerified
Users click a citizen dot, press Talk, and hold a live voice conversation using Web Speech API input + Groq responses
Claimed on readmehigh confidence
- src/lib/speech.ts:27 — Uses browser SpeechRecognition API for voice input
- src/lib/llm.ts:384 — generateVoiceResponse uses Groq Llama 3.3 70B for real-time citizen responses
Web Speech API TTS fallback when Deepgram unavailableVerified
Text-to-speech uses Deepgram Aura-2 with Web Speech API fallback
Claimed on readmehigh confidence
- src/lib/deepgram.ts:105 — window.speechSynthesis.getVoices() used, indicating a browser TTS fallback path alongside Deepgram
Prompt fix moved evidence citation from 0% to 100%Code-supported
Adding a 'cite >=2 named sources' mandate moved evidence_citation from 0% to 100% and argument_quality from 50% to 100%
Claimed on readmelow confidence
- src/lib/llm.ts:300 — Expert prompts do require citing at least 2 named sources, consistent with the described fix, but the specific before/after percentage results cannot be verified from static code
Swarm social-opinion pipeline scaling to 1,000 citizensCode-supported
Prototype social-opinion swarm pipeline as a path to scale from ~50 to 1,000 citizens
Claimed on Devpostmedium confidence
- src/lib/swarmSimulation.ts — Swarm simulation pipeline code exists (seed/ontology/graph/persona/social-post stages)
- src/components/layout/Shell.tsx — No reference to swarm components found in Shell.tsx, meaning the pipeline is not mounted/wired into the running app despite existing as code
Worker assignment (citizen assigned as inspector)Code-supported
Sofia Rodriguez (C003) is assigned as an on-site inspector from Month 2
Claimed on readmemedium confidence
- src/store/citizenStore.ts:64 — getWorkers filters citizens by isWorker flag, supporting worker-assignment concept
- src/lib/llm.ts:616 — generateWorkerAssignment function exists for assigning workers to tasks
Automatic delay flag at >10% behind projectionClaimed only
Automatic delay flags fire when actual progress falls more than 10% behind projection
Claimed on readmemedium confidence

An AI agent derived these features from the project’s Devpost page and readme, then searched the code for each one. Verified features are backed by cited code; claimed-only features had no supporting code, which is not by itself proof a feature is missing.