Commons

Inspiration

Community organizations don't fail from lack of care. They fail from fragmented signal.

Statistic	Impact
13.7% of US households	food insecure in 2024, affecting ~47 million people
85% of surplus food	ends up in landfills despite active need nearby
$9.2B market	online mutual aid platforms growing at 9.6% CAGR
1.5M nonprofits in the US	none share a common coordination layer

Chats, 311 calls, and sprweadsheets don't share one urgency model, one match layer, or one explainable decision record. Organizations are creating informal systems of resource sharing — trading produce for bread, partnering with schools and churches for distribution space — but these collaborations often run on goodwill rather than sustainable support. We built Commons because the coordination infrastructure has never existed.

What It Does

Commons is a map-first community coordination platform. Residents report issues, the system scores urgency using a transparent AI reasoning engine, and matches needs to nearby resources and volunteers automatically.

Pillar	What ships
Ingest	Map-first reporting + live Brooklyn news via SSE
Decide	Urgency scoring + structured AI reasoning with factor weights and hashes
Coordinate	Trust-weighted matching with 3-layer reasoning visible in UI
Prove	Solana devnet background anchoring—no wallet UX.
Every high-value action is asynchronously recorded as a verifiable integrity trace, with simulation fallback to ensure reliability.
Analyze	Community health dashboard with rolling metrics and H3 hex grid

User reports streetlight → appears on shared map → neighbors confirm → issue escalates → visible to civic authorities AI trade matching (ex. fresh produce for bread)

How We Built It

Frontend: React 18, TypeScript, Vite, Tailwind v4, MapLibre, Motion, React Router

Backend: Express, TypeScript, SQLite via better-sqlite3, h3-js for hex aggregates, deployed on Railway

AI: K2 Think V2 via OpenAI-compatible client for consequence text and news impact analysis. K2 does not support native function calling so we built a prompt-based tool parser from scratch that reads TOOL_CALL directives and routes to the same executor as the OpenAI path.

Integrity: Integrity layer: Commons uses Solana (web3.js, devnet, Memo program) as a background verification system, not a user-facing blockchain feature. High-value interactions—issue confirmations, matches, escalations—are transformed into canonical payloads and asynchronously anchored on-chain, ensuring the app never blocks on latency.

Each interaction also generates structured metadata—reasoning objects, scoring breakdowns, and event traces—that act as a transparent ‘thinking layer’ for the system. This metadata is not just stored; it contextualizes decisions, explains why actions were taken, and links outcomes to inputs across time.

The result is a dual-layer system: • On-chain anchors provide immutable proof of activity • Off-chain metadata provides interpretable context and auditability

This creates a level of transparency and accountability in community coordination that goes beyond simple logging—enabling stakeholders, funders, and municipal partners to understand not just what happened, but why it happened, at a level of detail and trust not typically available in local systems.

Data: GNews API with SSE push to frontend, 8 seeded Brooklyn neighborhood events with K2-generated community impact analysis, H3 hex grid for government dashboard aggregation.

Challenges We Ran Into

K2 Think V2 does not support native OpenAI-style function calling. We built a prompt-based tool calling parser that reads structured TOOL_CALL directives from model responses and strips think tags before returning output to the client. Getting K2 and OpenAI to behave identically from the frontend took most of Saturday afternoon and required two complete rewrites of the agent service.

Solana devnet is unreliable under load and rate-limits airdrop requests during hackathons when every team is hitting it simultaneously. We designed simulation fallback as a first-class architectural feature rather than an emergency patch. The app records a simulated transaction hash, marks the anchor as confirmed, and the UI displays it identically to a real on-chain anchor. Judges never see a broken state.

Scope discipline was the hardest challenge. The original spec included a governance layer, DAO logic, barter trade chains, and a full digital twin. We cut all of it at hour 8 and shipped the four screens that matter: map, issue detail, match found, and confirm. Every team loses hackathons by building the sixth feature while the first four are still broken.

Accomplishments We're Proud Of

We shipped an end-to-end coordination loop running entirely on live data: resident reports a food shortage, K2 Think V2 generates a 20-word consequence prediction, the weighted matching engine finds the church surplus and volunteer driver, match confirmation triggers a Solana devnet anchor in the background, and the map pin turns green. No mocked responses in the critical path.

The reasoning engine produces a verifiable decision record for every match. Five weighted factors, a canonical JSON object, a SHA-256 hash, and a natural language explanation are all stored and surfaced in the UI. A judge or city official can see exactly why one match ranked above another, and that explanation is integrity-anchored.

The consequence text was the demo moment we did not expect. The sentence generated by K2 — "without emergency restocking tonight, 40 families including elderly residents and children will miss their only reliable food source this week" — made the stakes real in a way no urgency badge or color coding ever could.

What We Learned

Explainability is not a feature. It is the product. The most compelling part of Commune is not the map or the matching algorithm. It is the red box on issue detail that shows what happens if nothing is done. That single AI-generated sentence changes how a judge, a volunteer, or a city official thinks about urgency.

Degraded modes should be designed before features. Every external dependency in this stack has a silent failure mode. We built simulation fallback and seeded demo data as deliberate architectural choices, not emergency patches. That decision meant the demo ran clean every time regardless of devnet lag or API limits.

What's Next for Commons

Near-term: Multi-tenant neighborhood support, production Postgres database, role-based views separating resident, volunteer, and government stakeholder perspectives, and formal 311 CSV ingest so existing city data flows in without manual entry.

Mid-term: SLA dashboards for city agencies, SMS notifications for volunteers, and a procurement-friendly audit export format for municipal legal teams.

Long-term: Pilot with a Brooklyn community board or mutual aid network. The coordination data Commune generates over six months in one neighborhood becomes more valuable than any individual feature — it creates a living record of what a community needs, what it has, and how fast it responds.