Agents do the work. People decide how far it goes.
Software teams are about to supervise far more work than they write. Direct is our answer to how that should be done: with rules you can read, evidence you can check and people on the decisions that are theirs.
Writing code stopped being the bottleneck
An agent can already investigate an issue, write the change and open the pull request. That moves the hard part. It is now deciding what agents work on, proving what they did, and noticing when the world changed underneath them.
Faster code with the same oversight just produces more unreviewed change. The answer is not to slow the agents down, and it is not to trust them blindly. It is a system that sits around them.
Autonomy is earned, one rung at a time
We don't believe in a switch marked "autonomous". We believe in a ladder: deliver, observe, monitor, heal, fix. Each rung lets agents take on more, and each rung is something a team chooses to climb because it has watched the one below work.
A team that trusts agents with pull requests but not with production should be able to say exactly that, and have it hold. The ceiling is yours to set, and it is always visible.
Nothing starts until a person says so
A label flipping to "agent can do this" is not a decision. In Direct, work begins when a person admits it into a journey with a work ceiling. Classification describes an issue. It never starts one. Spend, scope and intent stay with people, where they belong.
Evidence over confidence
"The tests passed" and "the model said it was fine" are not reasons to ship. Every stage ends at a gate, and the gate decides from recorded evidence against versioned rules. The verdict, the evidence and the rule version are all kept, so months later anyone can see why something was allowed, and under whose rules.
Unknown is never a pass. A gate with no applicable rule holds. We would rather an agent wait for a person than guess.
The human, on the decisions that matter
The point of supervising agents is not to read every diff. It is to spend human attention where only a human can resolve something: an agent's question, a gate waiting for review, an alert it couldn't fix, a request from outside the team. Everything else should be moving without you.
That is why Direct opens on what needs a person, and says plainly that the rest is in hand. The signal is the product.
From production back to the backlog
Engineering does not end at the merge. A system that only delivers code never learns what happened next. We want the whole loop closed: an alert is investigated by an agent at once, remediated within the action policies you set, and turned into a governed issue when it needs a real fix. That fix is released and then verified by the same probe that raised the alert.
Direction belongs next to the work
A backlog of two thousand issues has no strategy. Agents follow direction, so somebody has to set it, and it has to live where triage and planning can use it. Direct keeps the vision, the roadmap and the order of work beside the issues, and checks changes against them.
The same governance reaches beyond code. What shipped is only half the story, so release notes, posts and the weekly digest travel through journeys with gates of their own.
Tools are not authority
A trusted application owns state, sequencing, credentials and capacity. The agent is a replaceable, bounded worker holding only what one unit of work needs. GitHub, your models and your editor are integrations, never the source of truth. Bring your own provider, run workers where you need them, and change either without losing the record.
Built to learn, honest about limits
Teams will override gates and fix the same failures again and again. Direct should notice, and propose rule changes for a person to review. It never changes its own rules unasked.
We would rather tell you where it stops than oversell it. Agents are only as good as the rules you activate, and judgement is not proof. Direct is coming soon, it runs our own engineering today, and it will open to others in stages.
Part of the same Cratis story
Direct governs how software gets built and run. Cratis Studio is where teams design it together as an event model, and Chronicle is the event-sourced foundation underneath. Different jobs, one belief: the people building information systems should keep every fact and stay in control of what matters.
This is the vision we're building toward, one release at a time. We'd love for you to be part of it.
Einar Ingebrigtsen
Co-founder, CTO
Sindre Wilting
Co-founder, Chief Architect
Give agents a brief, a ceiling and a gate.
See how the ladder, journeys and gates fit together.