Accountable software for long-lived .NET systems
Software that remembers.
Design it with the people who understand the business. Build it on an open .NET runtime. Operate it from the event record. Improve it without losing the reasons behind today's state.
Cratis Build is open source Studio is an honest preview Direct founder expertise
how the pieces fit → the stack · who's who → the cast · how we compare → compare .NET event-sourcing options
Why now
The way software gets made just changed. Most of it hasn't caught up.
Machines now write a growing share of the software your company runs. They work faster than any review process was designed for — and they only understand what your system has actually written down. We believe that in the age of AI, software has to be built differently — and more and more company leaders are reaching the same conclusion. Cratis is that different way: we build it, we sell it, and we support the companies adopting it.
Intent leaks out at every handoff
An idea passes through requirements, stories, designs, code and testing before anyone can use it — and every handoff is a translation. What ships is an interpretation of an interpretation, and nobody can say where the meaning went.
Systems that can't explain themselves
Ask most software why it made a decision and the honest answer is that nobody knows. It stored the outcome and forgot everything that led to it. That's an expensive answer to give a regulator, a customer, or a board.
Knowledge that walks out the door
The rules that govern your system live in a handful of people's heads. When they leave, the software keeps running and nobody can safely change it.
Where it matters most
When someone asks what happened, the answer should already exist.
Any business where a decision has consequences later — a payment, a claim, a contract, a shipment — is a business that eventually gets asked to account for itself. That's why we believe keeping the full history of what happened is worth it in almost every case: nearly every business runs on information, information flows and business processes, and those are exactly what a system that remembers serves best.
Payments and transfers
Movements of money kept as a durable, ordered history, with retention and compliance handled explicitly.
Claims and cases
Files that carry their own history, from first contact to resolution.
Orders and inventory
What was promised, what changed, and when — without a manual investigation.
Contracts and subscriptions
Every amendment, renewal and cancellation, in the order it occurred.
Identity and access
Who was granted what, by whom, and on what basis.
Supply and logistics
A traceable line from origin to delivery that holds up under scrutiny.
Give it a vague plan and it builds vague software, faster.
The problem Cratis was built to solve.
How it works
One accountable loop for the life of the system.
Cratis is organized around the work a long-lived business system must keep doing: agree on intent, ship typed behavior, understand production, and change safely from evidence.
Design
Map decisions, facts and the information people need on a shared canvas. Studio keeps domain experts, product people and engineers in the same conversation.
Cratis Studio · Screenplay · Stage
Build
Cratis Build carries a feature from C# commands and queries to generated TypeScript and React. Chronicle records the facts; Arc keeps the full-stack contract continuous. It stays familiar to the engineers building it, even if they have never built software this way before.
Arc · Chronicle · Components
Operate
Workbench, CLI, and Chronicle MCP expose documented Chronicle inspection and operational workflows. Available concepts and actions vary by tool and version; Studio and Assurance do not gate Build's available repair tooling.
Workbench · CLI · MCP
Improve
Use the durable record and executable specifications to explain current state, test the next change and feed what production teaches you back into the model.
Chronicle · Specifications · Synopsis
Start with the part you need. The products stand alone, but they were designed together — one ecosystem, one vocabulary — so the system becomes easier to understand over time, not harder. We work to keep the day-to-day simple and to take friction out of the approach, because we believe software built this way stays easier to change — and easier to explain — for the whole of its life.
Our product
Cratis Studio supports the design step.
The design step is the one everything else inherits from, so it is the one we built a paid product around. Studio is where your team maps how the business works, explores that model as a live preview and compares intent with runtime understanding. It is preview software: useful today, still moving, and described that way on purpose.
Everyone in the same room
Product people, domain experts, designers and engineers work on one picture at the same time — in business language, so the people who know the business are not spectators.
Explore supported behavior
Stage can perform supported parts of the model in a sandbox, so the team can test assumptions earlier. It is a preview for learning, not the production system or a replacement for engineering.
Ready for how software is made now
Machines write a growing share of your software and they build what they are told. Studio is where you say precisely what you want — the part that stays human.
What changes
What your organization gets out of it.
Most tools produce artifacts — requirements, tickets, code, documentation. Cratis closes a gap: from "we have an idea" to "the software does what we intended".
The whole organization can take part
In most companies, the final say on what the software does is the code — which most of the people who understand the business can't read. Cratis moves that authority to a model everyone can read, question and change. Product people, domain experts and engineers shape the same artifact instead of passing translations down a chain.
Software stops being engineering-onlyDesign and implementation stay closer
In many organizations the plan and the product separate quietly. Cratis gives teams a shared model, generated contracts, and checks that can expose some mismatches earlier. Engineering review still connects the model to production behavior.
Fewer silent handoff errorsYour system can answer for itself
For behaviors modeled with Chronicle, relevant business facts can be retained in order and queried later, subject to the system's retention and compliance rules. That gives reviews a better starting point than reconstructing everything from logs.
A queryable starting point for audit questionsAI helps instead of accumulating risk
Assistants are only as good as the structure they work inside. We provide AI skills and a system AI can genuinely work with: explicit models, guided ways of working, and checks a machine can run. That guidance is still being validated across AI tools, and it never replaces engineering review.
Explore AI-native development →Knowledge stays with the company
When how the business works is written into the system rather than carried only in senior people's heads, it can shorten onboarding and reduce key-person risk. New people — and new tools — can read the same model.
Less dependent on who's in the roomYou are not locked in
Cratis Build is developed in public, MIT licensed, and intended to run in your infrastructure. It does not require a Studio subscription. Compatibility and integration coverage vary by component and version, so check the current documentation for the systems you need. Leaving any platform still takes planning; public source and documented interfaces provide practical options. Studio export availability is described by the hosted product.
Open by design, not by promiseHow we help
Get the decisions right while they are still cheap to change.
Most of what we do is not writing code for you — it is working with your team on choices that are easy to make now and expensive to unmake later. Assurance is founder-led today; scope, availability, and points of contact are agreed for each engagement.
We design it with you
A working session with your people — the ones who know the business and the ones who will build it. Everyone leaves with the same picture, in language everyone in the room understands.
We tell you when you are wrong
Including when the answer is that you do not need us. A review that only confirms what you already believed is worth nothing, and we would rather be useful than agreeable.
We build the first piece alongside your team
Not instead of them. The first thing you build sets the pattern everything else copies, so we do it together — and then your team can do the rest without us.
Support is close to the product
Support plans publish response targets and provide access to people who work on the stack. The applicable plan and agreement define coverage, availability, and escalation.
Working with us
Build openly. Design together. Add Assurance when it matters.
Cratis Build is the open runtime: Chronicle, Arc, Components and the operating tools you deploy. Cratis Studio is the paid collaborative design product. Cratis Assurance is direct access to the experience behind the stack through support, reviews, workshops and bounded engagements.
Support
For organizations running Cratis in production
- Founder-led access to people who build the stack
- Published response targets by support plan
- Advisory hours for the decisions that are expensive to reverse
- A written continuity commitment
Advisory
For getting it right the first time
- A design session with your team and ours
- An architecture review, with the risks ranked
- The first piece built alongside your engineers
- Fixed scope, fixed price, agreed outcome
Workshops
For teaching the part that's actually hard
- Designing a system your whole team understands
- Working with a system that records relevant business facts
- Building where people and AI follow the same rules
- Built around your business, not a generic deck
Experience and access
More than fifteen years of event-sourcing lineage. Direct access today.
Cratis carries lessons from successive generations of event-sourced .NET systems. The products are one deliberate ecosystem, designed and supported together by a company that is intentionally small — so the people helping with your model or incident are the people building the stack.
We publish what we're building, including the parts that aren't ready — and we'll tell you plainly when Cratis is the wrong fit. We're here to stay: we keep building and supporting this, and support plans and services are available when you want us alongside you. More about how we work →
Get in touch
Start with a conversation.
You don't need a finished plan or an approved budget. Tell us what you're working on and we'll tell you honestly whether we can help. The first conversation is a fit review — ninety minutes, free, and if the honest answer is that you don't need us, that's what you'll hear.