DAC structure (for dummies)
Victor Yermak6 min read·Just now--
The simplest possible guide to how a Decentralized Autonomous Corporation is built — from a single cell to a full on-chain company.
The one-sentence version
A DAC is a company written as code. It has a treasury, a set of strict rules, a team of agents (some human, some AI), and a way to fund projects and pay people — all on-chain, no Discord polls required.
If a DAO is a town hall with a bank account, a DAC is a company with an org chart. DAOs discuss. DACs execute.
That’s the whole pitch. Now let’s break it into pieces.
The three building blocks
A DAC is built from exactly three primitives. Memorise these and you understand the whole system:
3. The Cell — your company’s “kernel”
Think of the Cell as a tiny autonomous business unit living on a blockchain.
It owns three things:
- A treasury — the money it controls.
- A set of rules — written in code, not in a Confluence page. These rules say things like “you can only spend X% of treasury per quarter,” “every project needs a KPI,” “if a deal fails its KPI, no payout.”
- A list of approved deals — the projects it has decided to fund.
The Cell never “does” work. It approves and funds. It’s the strategic layer.
4. The Deal — your on-chain Scrum team
Here’s where it gets interesting.
A Deal is the on-chain analog of a Scrum team. It is a project container with:
- A scope (what we’re building / running)
- A capped budget (the maximum capital it can ever touch)
- A team of agents (the people and bots assigned to it)
- A KPI (the measurable result it has to deliver)
- A payout function (the smart contract that pays everyone the moment the KPI is hit)
This is the unit of execution. It’s where the actual work happens — and where humans and AI agents sit side by side as equals.
The diagram below shows the relationship: a Cell holds the treasury and rules; a Deal lives inside it; agents (some human, some AI) sit inside the Deal.
The visual hierarchy isn’t decorative — it encodes authority:
- The Cell (purple) holds the rules. Nothing can violate them.
- The Deal (teal) inherits those rules but adds its own scope and budget. It cannot exceed what the Cell allows.
- The Agents (gray and coral) operate inside the Deal. They cannot exceed the Deal’s budget. The treasury cannot be drained no matter what they try.
This is the “risk capped by design” property. Giving an agent — human or AI — a Deal is like giving them a corporate credit card with a pre-set limit. They can spend, but they can’t blow up the company.
The Agents — humans and AI on equal footing
Inside a Deal, every contributor is just an agent: a wallet with an assigned role and a KPI.
Notice what this doesn’t care about:
- Whether the agent has a pulse
- What time zone they’re in
- Whether they show up to standup
- Whether they’re a single person, a team, or a script running on a server somewhere
If the agent hits the KPI, the smart contract pays them. If they don’t, it doesn’t.
This is why AI agents become first-class teammates in a DAC. They get the same wallet, the same role slot, the same budget cap, and the same payout function as any human contributor. The Scrum team upgrade isn’t philosophical — it’s structural.
6. The Fractal — how a DAC scales into a corporation
A single Cell with a few Deals is a startup. A real company is a tree of those things.
This is the Fractal — and it’s how DACs scale the way real corporations scale: not by drawing a bigger org chart, but by spinning up more cells and wiring them together with Deals.
The trick is that a Deal can fund another DAC. So the “agents” inside a Deal aren’t always individual contributors — sometimes a whole sub-DAC is the agent. That sub-DAC then has its own Deals, with its own agents, and so on.
What you’re looking at
- Tier 1 — the parent DAC. The corporate treasury and the strategic rules. The “holding company.”
- Tier 2 — the divisions. Product, Treasury, Growth. Each is its own DAC, with its own wallet, but the capital it received is governed by a Deal back to the parent. The arrow isn’t a reporting line — it’s a funded contract.
- Tier 3 — the Scrum teams. Engineering, Design, Yield Vault, Risk Agent, Marketing, Referrals. These are the actual two-pizza teams from the previous diagram. This is where humans and AI agents sit shoulder-to-shoulder and execute.
The big insight
Every node has the same shape. A leaf team is a Deal. A division is a DAC of Deals. The corporation is a DAC of DACs. That’s what makes it a fractal: the same primitive at every level.
Amazon scales this way with two-pizza teams. Google scales this way with autonomous product squads. The Fortune 500 has spent fifteen years collapsing hierarchy into trees of small accountable teams. A DAC is just that pattern, written as code.
How a DAC actually grows
Because everything is a primitive, growing the company is a deployment, not a reorg:
- New team? Open a Deal. Assign agents. Set a KPI. Fund it.
- New product line? Spin up a sub-DAC. Wire a Deal to it.
- New subsidiary? Same thing, larger budget, more sub-Deals underneath.
- Hiring? Add a wallet to a Deal. The wallet might belong to a person, or to an AI agent — the Deal doesn’t care.
- Performance review? There isn’t one. The KPI either fired or it didn’t. Payout is automatic.
Compare this to a traditional company, where each of those moves needs HR, finance, legal, and a quarter of meetings.
Who actually needs this
You’ve outgrown a DAO and need a DAC if you are:
- Managing a token treasury that deploys capital regularly
- Running a fund that needs programmatic execution
- Operating a protocol with multiple contributors
- Coordinating a team where accountability matters more than consensus
- Building anything where AI agents will need to operate alongside humans with real responsibilities and real budgets
If your current “governance” is a Discord channel and a multi-week vote, you don’t have a company. You have a stalling mechanism.
Cheat sheet
Print this out. Tape it to your monitor.
And the one rule that makes the whole thing work:
DAOs discuss. DACs execute.
That’s it. You now understand DAC structure.
Built on ideas from DAC.cloud and Victor Yermak’s “DAOs Discuss. DACs Execute.”
