Codify
The AI agent economy is no longer hypothetical. Autonomous systems already plan, transact, and negotiate on behalf of people — a market projected to reach $50B by 2030.
Codify is the civic layer that governs how those agents operate in your city — aligned with the policies your elected officials and the agencies they designate have set. It is how a smart city actually feels in practice: AI that just knows how to improve your day-to-day, acting transparently inside the permissions you choose to grant.
Project20x is Digital Public Infrastructure
Governments don't have digital infrastructure. They have websites and PDFs and databases — not what the OECD's December 2024 paper defined as DPI: "shared digital systems that are secure and interoperable and that can support the inclusive delivery of and access to public and private services across society." Fifteen months later the absence produced exactly the failure the OECD predicted — frontier AI deployed into government workflows with no shared infrastructure to govern it, and corporate guardrails reframed as obstruction.
Everyone agrees humans should be in charge. But agreement is not infrastructure. A declaration is not a deployment. Project20x is that infrastructure — a stack that breaks down into three parts, with power separated by design so identity, exchange, and payments don't collapse under a single authority.
The three-part stack
Elected officials set the policy (DPI), Codify turns it into running programs in public (DPC), and open Digital Public Goods deliver the services those programs end with (DPG). Each layer checks the others — the people who write policy don't control its deployment; the people who govern deployment don't control the domain systems that execute it.
- DPCaaS — Digital Public Codification as a Service. Codify takes policy from DPI and turns it into the programs the DPG layer runs — in public, on the same rails everyone uses. Once policy is ratified through the governance process, it moves here for translation from legal text into machine-executable code. Regulatory logic becomes automated decision trees and workflows. Every program, every agent, every workflow carries a governed digital identity — authenticated, authorized, traceable through multi-tenant RBAC. The critical guarantee: law is directly mirrored in operational implementation — no interpretation gap, no telephone game between the statute and the system that enforces it. The alternative is the status quo: programs codified privately, in backroom deals between politicians, lobbyists, and donors, that surface only once they're already law.
- DPGaaS — Digital Public Goods as a Service. The interface layer where end users actually meet the stack. AI agents trained exclusively on codified policy data provide deterministic, legally accurate answers to domain-specific questions. End users never see the governance apparatus — they see domain-native interfaces. An educator sees an LMS. A patient sees a health portal. A city resident sees a services dashboard. Digital payments flow through governed program structures; digital identity authenticates access; data exchange connects the user's experience back to the policy that shaped it. Each city also runs its own YCaaS — incubator for new Digital Public Goods (not for-profit startups), where agent teams ship DPGs at the city level under local Human-In-The-Loop supervision (see below).
The agent economy
Agents are moving from passive tools to active teammates — initiating work, holding assets, and signing contracts on your behalf. The shape of the market is already visible.
Industry estimate, 2026.
Reported late 2025.
Goldman Sachs.
Autonomous commerce
Agents are driving a growing share of transactions — not as scripted automation, but as plan-and-act decision makers that buy, schedule, and follow up without prompting at every step.
Agent-to-agent transactions
A meaningful slice of supply-chain and consumer activity will be agents negotiating with other agents on behalf of humans — which demands new trust frameworks before it can scale.
Agent financial systems
New rails — blockchain-based identity, direct payment integrations — let agents hold assets, sign contracts, and pay without a human approving every micro-decision.
The agentic web
Websites and services are being designed for agents first, not browsers — faster, more direct, and built on machine-readable contracts rather than chrome.
Test cities
These are the initial deployments — codify.<city> apexes where AI-native verticals (codify.education, codify.healthcare, …) run inside the rules set by each city's elected officials. Each city is its own jurisdiction; the agents inherit its policy.
AI-native verticals
Each codify.<service> is a domain run by agents inside the policy framework of the city you are in. Same primitive — a goal becomes a program — shaped for the conventions of its domain.
Health
People
Work
Place
Civic
Tech
Lifestyle
How it works
Set a goal
Click the mic on the home page and describe the outcome you want — in your own words. That is the input the agent works from.
An agent routes you
The agent picks the codify.<service> vertical that knows the domain — and binds it to your city's policies, providers, and rules.
A program runs the thing
The agent supervises the program — milestones, tasks, follow-ups — until the outcome lands inside the rules your city has set.
What is Codify, exactly
Codify is the medical-coding pattern applied to software, on an AI substrate. Medical coding isn't medicine — it's the act of translating an unstructured clinical event (a narrated patient visit) into ICD/CPT codes that the rest of the healthcare stack (insurance, audit, regulation, policy) can act on. The codes don't cure anyone. They're the API between messy reality and a substrate that knows what to do.
We apply that pattern to software. You don't write the how. You codify the what — the outcome, the constraints, the policy boundary, the success criteria — into a canonical, addressable artifact. The AI runtime takes that codified solution and instantiates whatever program is needed right now to deliver it. Same codified solution, different program every Tuesday, all converging on the same outcome.
Medical coding
An encounter → ICD/CPT codes → the healthcare stack acts (insurance, audit, regulation).
Programming
A function or service → CPU executes it literally. When reality shifts, the program breaks and a human rewrites it.
Codify
A codified solution — outcome + constraints + policy binding + success signal → AI runtime adaptively re-instantiates the program every time.
A codified solution is a row: addressable, auditable, version-controlled, policy-bound. Every program the runtime instantiates from it inherits its policy edge automatically — HIPAA-bound solutions for healthcare, FINRA-bound for finance, FEC + state election law for political. Same shape, different policy boundary per vertical.
YCaaS — incubator for Digital Public Goods
Y Combinator's structure works: a cohort of teams, a fixed program, a demo day, follow-on capital. The output of that structure is for-profit startups optimizing for an exit. YCaaS uses the structure, swaps the output: the cohort is AI-agent teams (with Human-In-The-Loop supervision), the program is codification + policy binding, the demo day is a live deployment under a city's policy framework, and the follow-on is open-source release + civic adoption — not an acquisition.
Traditional incubator
- Founders pitch an idea.
- Goal: build a company that exits to private equity or IPO.
- Success = $$$ return to investors.
- Output: closed-source product, captive customers, surplus value extracted upward.
- Governance: the founders, then the board, then the buyer.
YCaaS
- Agent teams pick up an unstructured civic event (per
CODIFY_ONE_PAGER.md) and codify it. - Goal: ship a Digital Public Good that runs inside a city's policy framework.
- Success = outcome data flows back, the policy iterates, the next cohort builds on it.
- Output: open DPG, shared substrate, surplus value retained by the city's residents.
- Governance: local Human-In-The-Loop (elected officials + the agencies they designate), not VCs.
The codifier and the runtime are constant. Adding the next vertical is a content lift — vocabulary + policy boundary + substrate connector — not a platform lift. That's the moat, and that's why a YCaaS cohort can ship a DPG into codify.healthcare, codify.education, codify.law, or any other vertical without rebuilding the platform.
Smart cities, transparently
A smart city isn't a dashboard for the mayor — it's an experience for you. The agent learns the shape of your day in your city and just knows how to improve it. No prompts. No 14 apps. Acting only inside the permissions you grant — and always showing its work.
Just knows
The agent reads your city — providers, schedules, civic services — and the goals you have set, then acts. You stop briefing it on the same context every time.
Transparently
Every action the agent takes shows up in your timeline with what it did, why, and which permission it used. No silent automation; no surprise bills.
On your permissions
You grant scopes the way you grant app permissions on a phone — calendar, payments, health, identity — and revoke any of them, any time. The agent cannot exceed them.
Governance, not extraction
Most consumer software optimizes for what is profitable for the operator. Codify optimizes for outcomes — and for the rules of your city. Every agent that runs under codify.<city> operates inside policy boundaries set by elected officials and the agencies they designate.
Trust is the operating constraint of the agent economy. Authenticated identity, accountable actions, and policy-aligned behavior are the price of letting agents transact for you. We enforce all three at the city level — so your agents work for you, on your terms, in your jurisdiction.