Now open for sign-up · 14-day free trial

Model how your system behaves.
Before anyone writes the code.

Cratis Studio is the collaborative workspace for event modeling. Brainstorm the events, shape them into slices, prove them with runnable specifications and design the screens — with your team and your agents on the same board.

Start your free trial See the product

Sign up with your existing account14-day free trialAlready a user? Log in

app.cratis.studio
The Storefront event model in Cratis Studio: slices with commands, read models and events, a prototype for every screen, and the team's open questions as sticky notes.
An event model: slices with commands, read models and events, a prototype for every screen, and the team's open questions pinned as notes.

Writing code was never the hard part.

The hard part is agreeing on what the system should do — and keeping that agreement alive. Agents make code cheap. They make a vague idea expensive.

The whiteboard never makes it into the code.

The workshop ends, the photo of the sticky notes is filed, and the real design lives in someone's head.

With Studio: the workshop board is the model. Brainstormed events become slices on the same canvas, with the decisions and open questions still attached.

Documentation drifts the day it's written.

Diagrams go stale and tests are written after the fact, if at all. Nobody can say what the system is supposed to do.

With Studio: behavior is stated as Given / When / Then specifications that live next to the slice they describe — and can actually be run.

Agents are only as good as the intent you give them.

A loose prompt gets you loose software, written in whatever shape the model happened to learn.

With Studio: humans decide the design; agents work against an opinionated, event-sourced model instead of a blank page.

One workspace, from first sticky note to specified screens.

Everything below is a screenshot of the live product, taken from our own sample projects.

app.cratis.studio
An event brainstorming board: a chaos storm of orange event notes, then columns for Merchandising and Browsing with decisions and assumptions on yellow notes.
A big-picture board: a chaos storm of every event the team could think of, then columns per area — with decisions, assumptions and risks pinned beside them.
01 · BRAINSTORM

Chaos first. Structure second.

Get every event onto the board before anyone argues about shape. Then cluster them, name the areas, and write down what you decided — and what you're still unsure about.

  • An infinite canvas, built for a whole room at once
  • Decisions, assumptions and risks as notes, right where they matter
  • Columns that become the boundaries of your model
02 · MODEL

The system, laid out as it behaves.

Each slice is one thing the system does: what the person sees, the command they send, the events that record it, and the read model that answers back. Lanes for personas and the system keep it honest.

Command Event Read model Note
  • A screen prototype on every slice that has one
  • Personas, interactions and events in their own lanes
  • Everyone edits the same model, live
app.cratis.studio
The Basket module of the Storefront event model: AddToBasket, ChangeBasketQuantity and RemoveFromBasket commands, the BasketView read model, and the events between them.
A module of the model: three commands, the BasketView read model that listens to their events, and a prototype for each screen.
app.cratis.studio
Given/When/Then specifications on an event model, including a rejection that reads 'Pet name is required'.
Specifications on an event model: adding a pet records PetAdded; adding one without a name is rejected with “Pet name is required”.
03 · SPECIFY

Behavior you can read — and run.

Describe what should happen as Given, When, Then — using the same events and commands as the model. They are the regression suite and the shared definition of done.

  • Specifications sit beside the slice they describe
  • Business rules, like validation, are stated as outcomes
  • Run them against the model as it changes
04 · DESIGN

Real screens, not boxes and arrows.

Give each application a look and a shell with a UI profile, then build screen templates with slots your slices fill in. See your product take shape against sample data while the model is still fresh.

  • A UI profile for shell, look, menu and sample data
  • Screen templates with named slots, inspected live
  • Desktop and mobile previews
app.cratis.studio
A UI profile editor with a live preview of the storefront product grid.
A UI profile with a live preview of the application.
app.cratis.studio
The ProductGrid screen template editor with an inspector listing the template's slots.
A screen template and the slots it offers.

From a room full of sticky notes to a system you can trust

1

Brainstorm events

Dump every event on the canvas. Cluster them, name the areas, and write down decisions and risks as you go.

2

Model the slices

Turn events into slices with commands, read models and screens — one behavior at a time.

3

Specify & design

Write the Given / When / Then, shape the screens, and talk changes through with your agents.

4

Build & iterate

Generate code from the model, and keep changing the model first as requirements move.

Your team and your agents, on the same board.

Studio is multiplayer by design. People and agents share the model, and the human stays in the loop on what matters: how workflows fit together, what is valuable, how it feels.

💬

Talk to your agents

Every board has a prompt bar. Ask for a change or a question answered, in the context of the board you're looking at.

👥

Live collaboration

See who is on the board and where their cursor is. Developers, domain experts and product owners edit the same living model together.

🧩

Projects, applications, domains

Organize work into projects with several applications, each with their own domains, event models, screens and policies.

🔒

Protected work

Mark a project as a keeper and it can't be renamed or deleted by accident until protection is lifted deliberately.

⌨️

Code generation

Generate type-safe code from your model so what you designed and what you run don't drift apart. More on the way.

🗂️

Event sourced at the core

Studio is built on Cratis Chronicle. Everything that happens is kept as an event, so nothing valuable is thrown away.

Fewer choices. Better software.

Agents learned from code written by humans for humans, at every level of quality. Studio gives them a firmer foundation to stand on. Read the vision →

Event sourcing by default

Nothing is overwritten and nothing is lost — the history is there for new features and new questions.

Vertical slices

One behavior, end to end. Small enough to specify, review and change on its own.

Humans decide, agents assist

People own the design and the value. Agents do the legwork against a model they can't misread.

Specifications, not hope

Given / When / Then keeps quality and regression part of the design, not an afterthought.

Pay per seat. The bigger the team, the lower the price.

Start with a 14-day free trial. Prices exclude VAT.

Single user

1 seat

€12.00/mo

€12.00 per seat / mo

Save 15% €122.40 billed yearly

Small team

3 seats

€30.00/mo

€10.00 per seat / mo

Save 17% €298.80 billed yearly

Team of 10

10 seats

€80.00/mo

€8.00 per seat / mo

Save 20% €768.00 billed yearly

Team of 50

50 seats

€300.00/mo

€6.00 per seat / mo

Save 22% €2,808.00 billed yearly

Enterprise

Unlimited seats

Let's talk

Contact sales
Start your free trial

Common questions

What is Cratis Studio?

Cratis Studio is a collaborative platform for event modeling, event brainstorming, and domain-driven design. Teams use it to model commands, events, and read models before writing production code — learn more in the event modeling documentation.

Who is it for?

Studio is for developers, domain experts, and product owners who want a shared understanding of how their system behaves. They can edit the same living model in real time; see team collaboration and other features.

How does it relate to Cratis Chronicle?

Studio is built on Cratis Chronicle, an open-source event-sourcing platform for .NET. Studio provides collaborative modeling, while Chronicle captures state changes as immutable events — explore the Cratis documentation.

What does it generate?

Studio generates C# commands, events, and projections from a slice into your connected repository. An AI agent can then refine the generated code for you to review, as described in how it works.

Can I try it today, and what does it cost?

Yes — sign up and start a 14-day free trial. After that Studio is priced per seat; see the pricing and the terms and conditions.

Is my data an audit trail?

Yes — Studio captures every state change as an immutable event, giving you an append-only audit trail. You can replay history into new projections; see why Studio is built on event sourcing.

Your privacy matters. Read how Cratis Studio collects, uses and protects personal data in our privacy policy, and what you agree to when you use the service in the terms.

Privacy policy Terms and conditions
Open for sign-up

Model your first system
this week.

Create your organization and start a 14-day free trial. Bring the team — then bring the agents.

Start your free trial Log in Read the docs