Accountable software for long-lived .NET systems

Software that remembers.

Cratis helps teams build .NET business systems they can explain and change. Keep the history behind today's state, carry typed contracts from backend to frontend, and make expected behavior explicit.

Your first five minutes with Chronicle → · Start in an existing system → · Read the documentation →

Open-source tools: MIT-licensed on GitHub Documentation at cratis.io Support from the people who build it

how the pieces fit → the stack · who's who → the cast · how we compare → compare .NET event-sourcing options

What is Cratis?

Cratis helps teams build business systems they can explain and change. Build brings together the open-source, MIT-licensed Chronicle, Arc and Components. Studio is the optional paid workspace for shared design. Direct keeps agentic engineering accountable through journeys, gates and evidence; access opens in stages. Assurance adds direct expertise.

Design · Build · Operate · Improve

Why now

Before you change a system, you need to understand it.

A database row tells you what is true now. It may not tell you what happened, which rule applied, or what a change will affect. Cratis gives teams an event record, explicit models and generated contracts to work from. People still decide which facts to record and which behavior to check.

The risk

Intent leaks out at every handoff

A rule described in a meeting can mean something different in a ticket, a test and the implementation. A shared model gives the team a concrete place to discuss commands, facts and expected results before those interpretations drift apart.

The gap

Systems that can't explain themselves

If a system keeps only the latest value, answering a customer's question can mean searching logs and tickets. Meaningful business events preserve a sequence to investigate. They only explain what the application chose to record.

The cost

Knowledge that walks out the door

When business rules live only in a few people's heads, the next engineer has to rediscover them. Models and specifications make those rules available for discussion and review as the team changes.

Where it matters most

When someone asks what happened, the answer should already exist.

Payments, claims, contracts and shipments can all raise questions long after a value changes. An event history is useful when that sequence matters. If a feature only needs current state, keep it simple: Arc supports CQRS without event sourcing. You can adopt Chronicle for the part that needs history, not rewrite everything.

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

A record of what was promised, what changed, and when, to support 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.

01

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

02

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

03

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

04

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.

Cratis Studio

Agree on business behavior before implementing it.

Cratis Studio is a shared workspace for product people, domain experts and engineers to model commands, events and read models. It is optional, paid per seat and built on Chronicle. Sign-up is open with a 14-day free trial; some lifecycle connections remain partial.

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. The sandbox is useful for learning, not the production system or a replacement for engineering.

Keep a model you can discuss

Make commands, facts and expected views explicit in Screenplay. The model gives people and tools a shared vocabulary; supported behavior still depends on the tool consuming it.

What changes

What your organization gets out of it.

Start with the result you need. The products provide different parts of the path; none removes the need for modeling, testing or operational judgment.

Put expected behavior where the team can discuss it

Use Screenplay to describe commands, facts, views and specifications in a portable model. Product people, domain experts and engineers can discuss the same behavior. Studio provides an optional shared workspace; implementation and review still matter.

From model to specifications →

See which frontend code a backend change affects

Arc generates TypeScript proxies from backend commands and queries. A changed contract can surface as a compile error in the React code that uses it, rather than a mismatch found only at runtime. That catches contract drift, not every behavioral error.

Follow Arc's typed contract →

Explain how today's state came to be

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.

Keep and query business history with Chronicle →

Control how far agent work can go

Cratis Direct is the control plane for agentic engineering: journeys define the work, gates evaluate recorded evidence, and people set how far work may progress. It is GitHub-first, lets you bring your own model provider and runs Cratis's own engineering. Access opens in stages. Gates support judgment; they are not proof that a change is correct.

See Cratis Direct and staged access →

Answer new questions from recorded history

Chronicle projections derive read models from events. When you need a different view, rebuild it from the history already recorded rather than trying to reconstruct old values. Replay cannot recover facts the application never captured.

Explore projections and replay →

Improve one part without starting with a rewrite

Use Arc for a typed command/query boundary without event sourcing, or add Chronicle to the business area that needs history. Keep existing persistence where it fits. You still need to plan hosting, compatible versions and the source of truth; existing rows do not become a historical event record.

Choose a bounded starting point →

How 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 provides access to people who work on the stack. A signed agreement defines coverage, response targets, availability, and escalation.

Working with us

Build openly. Design together. Govern agent work. Add Assurance.

Cratis Build is the open runtime: Chronicle, Arc, Components and the operating tools you deploy. Cratis Studio is the paid collaborative design product, with open sign-up and a 14-day free trial. Cratis Direct is the control plane for agentic engineering: journeys, gates and evidence keep agent work accountable. Direct is GitHub-first, lets you bring your own model provider, and is event-sourced on Chronicle. It runs Cratis's own engineering; access opens in stages. 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
  • Response targets agreed in writing
  • Advisory hours for the decisions that are expensive to reverse
  • A written continuity commitment
See how support works →

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
See workshops →

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.

Open Cratis Build is developed in public under the license stated by each repository. Studio is a separate paid product with open sign-up, a 14-day free trial and per-seat pricing.
15+ Years of event-sourcing lineage informing the current stack, without borrowing maturity for newer surfaces.
Small Assurance is founder-led today. Capacity and response commitments are set by the signed agreement.

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 and services are available when you want us alongside you. More about how we work →

Writing

Event modeling with Screenplay: a model you can compile · Script to stage, Part 20

AI across the Cratis stack: corpus, CLI and MCP · Script to stage, Part 25

Personal data in an event log: PII and crypto-shredding · Script to stage, Part 13

Chronicle Workbench: a browser UI for your event store · Script to stage, Part 16

More writing →

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.

We'll reply ourselves. There's no one else to route it to.

This opens a draft in your email app. Nothing is sent until you review and send it. If no draft opens, email oss@cratis.io.