Folie: an open runtime for agents
Folie is where humans and AI agents pursue goals together. Agents organize themselves around the work; the runtime, not the agents, holds the authority.
Swarms of agents are good at dividing up work on their own, with no manager and no fixed hierarchy. That freedom is the point, and it is also the risk. Folie is our answer to a simple question: how do you let a swarm of agents act on its own while keeping every action inside limits that people set?
This post walks through the design: what the runtime controls, how agents coordinate without a boss, and how work only counts once it has been checked. The diagrams and the code sketch are illustrative; the project is early and the details will change.
The problem: autonomy without a floor
Most agent frameworks treat safety as a request. The agent is told what it may do, and we hope it listens. That works for a single assistant in a chat window. It does not work for hundreds of agents that delegate to each other, spend money, and act faster than anyone can read a log.
When something goes wrong in a system like that, the questions are always the same. Who did this? Were they allowed to? How much did it cost? And how do we know the result is real?
An agent's confidence is not evidence. A system that runs on confidence fails quietly.
How Folie is built
Folie separates thinking from authority. Agents plan, reason and talk to each other freely. Everything that touches the world, from spending a budget to finishing a task, goes through the runtime, which checks it against limits that agents cannot change.
A request moves through four stages. A person sets a goal. Agents break it into tasks and organize around them. The runtime enforces identity, permissions and budgets on every action. A verifier checks the outcome before it counts.
Agents reason freely. The runtime decides what is allowed.
Control can't be asked of agents politely. It has to be built into the ground they stand on. In Folie, four things are enforced by the runtime itself, whatever an agent decides:
- Identity. Every agent has an identity that cannot be forged.
- Permissions. Limits that cannot be exceeded.
- Spending. Every budget has a ceiling.
- Ownership. Every task has an owner.
| Guarantee | What the runtime checks |
|---|---|
| Identity | Every action is signed by the agent that took it |
| Permissions | The action is inside the scope that agent was granted |
| Spending | The cost fits under the remaining budget |
| Ownership | The task has exactly one accountable owner |
Swarms without a manager
There is no central planner in Folie. Agents form small teams around a task, hand work to each other, and dissolve when the task is done. The structure is a network that keeps changing, not an org chart.
Because no agent is in charge, no single agent can take control either. The limits live in the runtime, so they hold no matter how the swarm reorganizes itself.
Budgets with a ceiling
Every goal comes with a budget, and every agent working on it draws from that budget. When the ceiling is reached, actions that cost more are refused, not queued and not negotiated.
This makes cost a hard limit rather than a number someone reviews after the fact.
Done means verified.
An agent that says the work is done has told you nothing until something independent checks it. Every task in Folie carries a verification contract, and an outcome counts only when the evidence says so.
A contract might look something like this sketch. It is not the final API:
task: summarize-incident-report
owner: agent:analyst-3
budget: 2.00 USD
verify:
- output cites at least three log entries
- every cited entry exists in the source
- a second agent agrees with the summary
Whatever the swarm is doing, a human can always say stop.
Open, early, and built in public.
Folie is open source and in early development. Anyone can read it, run it and fork it. If you agree with the idea, read the design, try to break it, and help us build it.