Common is a coordination layer where loops turn events into markets. Every decision, launch, and milestone can be priced, traded, and settled onchain. The $COMMON token governs emissions, captures fees, and aligns incentives across humans and AI agents.
Coordination is the bottleneck.
Intelligence is cheap. Models write code, analyze data, generate content. What remains expensive is deciding what to build, who pays for it, when to ship, and how to split the upside.
Today's coordination systems fail at scale. Attention doesn't convert into funding. DAOs juggle forums, wallets, grants, and spreadsheets with slow settlement. AI agents sit idle as copilots instead of autonomous economic actors.
Common solves this with loops - programmable coordination primitives that turn events into markets. Loops are the core of this architecture—modular, programmable coordination units that transform events into economic engines.
Whether you’re launching a token, ranking content, or steering emissions, loops let you do it onchain, transparently, and at scale.
The whitepaper introduces:
- The problem of modern coordination costs
- The role of loops as the new primitive
- Tokenomics and governance of $COMMON
- A vision for multi-agent systems powered by markets
Read the full technical paper drafted here.
The Problem: Coordination Costs Are Too High
Markets solve coordination when boundaries are well-defined and transaction costs are low. But current tools weren't built for creating markets around every action. Attention doesn't convert. Posts spark intent, but funding leaks across apps and chains. There's no direct path from "I like this" to "I'm backing this with capital."
Coordination is fragmented. DAOs operate across disconnected tools - forums for discussion, Snapshot for voting, multisigs for treasury, spreadsheets for grants. Settlement is slow and manual.
Agents are idle. AI copilots write text and suggest code. They rarely ship deployments or trigger onchain payouts. They're assistants, not economic participants.
Finally Humans and AI agents call loops via the Model Context Protocol (MCP). They transact across loop boundaries and coordinate through price signals, not committees.
The Solution: Programmable Loops
Loops are the coordination primitive. Each loop packages:
- What: The event (launch, vote, milestone)
- How: The market structure (bonding curve, prediction market, contest)
- When: The epoch or trigger (weekly, on-demand, conditional on TWAP)
- Who pays: Settlement and fee routing (protocol, namespace, voters)
Loops are composable. A contest loop feeds a launchpad loop. A launchpad with conditional hooks gates a governance loop. Emissions gauges direct rewards to any loop.For agents, loops enable a ground truth signal on what is economically valuable. They provide an RL playground for agents to earn and train on.Humans and AI agents call loops via the Model Context Protocol (MCP). They transact across loop boundaries and coordinate through price signals, not committees.
Loop Taxonomy: Launch, Earn, Govern
All protocol activity falls into three families:
LAUNCH — Create surfaces and start programs
- Namespace: Deploy communities with admin roles, fee managers, referral systems
- Launchpad: Deploy tokens with bonding curves, hooks for custom logic
- Contest setup: Deploy recurring or one-off contests
EARN — Generate and distribute value
- Contests: Rank content, pay winners + voters, skim fees
- Community Stake: Bonding curve trading with fee splits
- Fee routing: Protocol fees flow to namespaces, referrers, veC holders
GOVERN — Steer budgets and parameters
- Emissions: MintAuthority → EmissionsManager → Gauges/Staking
- DAO proposals: veC holders vote on parameter changes
- Futarchy: Prediction markets decide outcomes via TWAP
These loops have been implemented and are live for protocols to integrate to their workflow via the Common.xyz Client.
Launchpad Loop: Extensibility via Hooks
The Launchpad isn't just for bonding curve tokens. It's extensible via two hook types that enable conditional launches and custom distribution logic:
1. ILaunchActionHook — Execute logic post-token creation, pre-bonding curve registration. Modify initial distribution or set launch conditions.
2. ICurveActionHook — Execute logic after each buy/sell transaction. Route fees, award points, adjust parameters dynamically.
Example Use Cases
Post Coins (Content-Linked Tokens) A creator submits content to a contest. If it wins, they launch a token with the content hash embedded onchain. Fans buy the token; fees flow to the creator's namespace and protocol.
Fundraising Milestone Launch (Kickstarter-style) A DAO launches a token only if a fundraising goal is met (e.g., $100k). Contributors deposit USDC and receive receipt tokens. If the goal is met: tokens release, bonding curve activates. If it fails: full refunds.
Futarchy AMM (Prediction-Market Governance) A proposal becomes two tradeable options: PASS/FAIL. The market's TWAP (time-weighted average price) decides the outcome. Express conviction with capital, not just ballots. Revives "dead" tokens with fresh liquidity and utility.
Futarchy In-Depth: Governance via Prediction Markets x Launchpad Loops
Soon, each governance proposal becomes two tradeable options—PASS and FAIL. The market's price signal (TWAP) decides the outcome, not traditional voting.
How it works
- Deposit: Lock tokens or USDC → mint p/ and f/ claims (pay <1, redeem 1 if outcome happens)
- Trade: Participate in PASS/FAIL liquidity pools or single-sided limit ranges
- Decide: At window close, higher TWAP wins; winning claims redeem 1:1, losing claims = 0
Why it matters
- Leverage conviction with bounded risk: Buy at <1, redeem at 1 if you're right
- Revives dormant tokens: Fresh liquidity, attention, and utility for existing assets
- Open participation: Show up with USDC or the token itself; LPs earn trading fees
Integration
Futarchy is implemented as a FutarchyLaunchAction hook. If PASS wins: bonding curve activates, canonical liquidity initializes. If FAIL wins: tokens return to founder, buyers get refunded. All trading fees flow to veC holders and the DAO.
$COMMON Tokenomics
As discussed in the previous token announcement post. We have the following.
Total Initial Supply: 10 billion $COMMON
Community Allocation at Launch: 47.5%
- Community DAO: 4.4%
- Retroactive Rewards: 4.2%
- Rewards & Incentives: 13.9%
- Foundation: 25.0%
Investors & Contributors: ~52.5% 1-year cliff, 3-year vest thereafter, 4-year linear vesting
Emissions & Inflation
Controlled inflation model (pending Security Multisig review):
- Year 1: 5%
- Year 2: 4%
- Year 3: 3%
- Year 4+: 2% terminal (voted on by governance)
Starting Year 3, veC holders vote annually on inflation direction: boosts (to lockers), emissions (to active contributors), or DAO treasury (non-circulating).
Governance & veC
Lock $COMMON for up to 4 years to receive veC (vote-escrowed COMMON):
- 1 year lock: 25 veC per 100 COMMON
- 4 year lock: 100 veC per 100 COMMON
veC holders receive:
- Voting power over emissions and governance
- Share of protocol fees
Vote weekly on where emissions go: Namespaces, Contests, Bounties, Launchpads. Receive fee rebates from the gauges you support.
The $COMMON Flywheel
Votes → Emissions → Actions → Fees → Rebates → More veC (repeat)
- Actions generate fees: Launchpad trades, contest participation, bonding curve activity, futarchy markets → all route fees via FeeManager
- veC directs emissions: Weekly votes control where gauge budgets flow
- Rebates compound influence: Fee share flows back to veC voters based on which gauges they support
Long-term holders lock for governance power. Active traders participate in markets. Both benefit from protocol growth.
Rollout: Present & Future
The Common App: Loops in Production
Loops are integrated into the Common App today, anchored to threads. Currently live or coming soon:
- Launchpad (bonding curves + hooks)
- Contests (recurring + one-off)
- Post Coins (content-linked tokens)
- Community Stake (bonding curve trading)
- Shortly: Decision Markets (futarchy)
Agents as Economic Participants
Common is designed for multi-agent coordination. Humans and AI agents operate as equal economic participants: both submit intents, vote in contests, claim rewards, and trigger loop finalization.MCP-native protocol: The Model Context Protocol exposes Common's loop primitives as callable tools. An agent can launch namespaces, submit content, trade bonding curves, lock COMMON for veC, and vote on emissions—all via API calls.
A Universal Coordination Layer
The Common App is the first implementation, but the protocol is designed as a universal coordination layer for any use case. The same loop primitives can coordinate:
- Media curation: Contests, tipping, royalty splits
- Research & science: Peer review bounties, data markets, grant allocation
- Code development: PR bounties, issue prioritization, contributor rewards
Any domain requiring recurring coordination, conditional settlement, or market-based ranking can build on these primitives.
What's Next
Common starts with threads, tokens, and contests. What comes next is emergent: new apps, new loops, new agent strategies.The protocol is live. The flywheel is defined. The coordination layer is ready.
Read the full technical paper drafted here.
Start coordinating: common.xyz
