Cratis Studio
Design together. Understand what runs.
Cratis Studio is the paid collaborative surface for the Cratis lifecycle. Domain experts, product people and engineers model the business together, explore supported behavior as a live preview, and keep design intent close to what the runtime can explain.
Preview maturity Free trial, no card Supported model export
Why this now
Machines write a growing share of your software. They build what they are told.
An assistant is only as good as the description it works from. Give it a vague plan and it produces vague software, faster than anyone can review it. The bottleneck has moved: it is no longer how quickly you can write software, it is how precisely you can say what you want.
The plan lives in a document
Someone writes it down, someone else interprets it, and the distance between the two only shows up months later in something that shipped wrong.
The plan becomes explorable
Your team makes intended behavior explicit in one model. At Preview maturity, Stage can perform supported parts in a sandbox; implementation, review, and testing remain necessary for production software.
Speed stops costing you control
People and assistants work from the same explicit description instead of guessing at it — so going faster stops meaning accumulating things nobody can explain later.
How it works
From a conversation to a model the team can explore.
You do not need to read the implementation to take part. Studio makes intent visible while Stage gives supported parts of the model a Preview sandbox to learn from. That sandbox does not replace implementation, review, or testing.
Get it out of people's heads
Everyone who knows part of how the business works puts it on one canvas — what people do, what happens as a result, what everyone needs to see. In business language, not technical notation.
Shape it together, at the same time
Product people, domain experts, designers and engineers work on the same model at once — the way you would expect from any modern collaborative tool. Some disagreements can surface on the canvas before implementation, when they are cheaper to resolve.
Explore it live
At Preview maturity, Stage performs supported parts of the model in a sandbox so the team can explore behavior rather than only debate a static diagram. It is a learning surface, not the production application or evidence of production performance.
Change it and go again
What you learn from using it goes straight back into the model. The loop is the work — not a phase that happens once at the start and never survives contact with reality.
What changes
What your organization gets out of it.
More of your people can take part
Today the final say on what the software does is the code, which most of the people who understand the business cannot read. Studio moves that to something everyone can read, question and change — so the knowledge that shapes your software is not locked inside one department.
Design stops being engineering-onlyLess gets lost on the way
Handoffs between an idea and working software introduce translation. A shared model can reduce some of that translation, while implementation, review, and testing still connect the design to production behavior.
Fewer surprises at the endYou find out sooner
Because Stage can perform supported model behavior in a sandbox, the people affected by a decision can explore it before the production implementation is complete. Feedback can arrive while changing direction is still cheaper.
Cheaper mistakes, earlierRuntime conversations start with evidence
The model, Chronicle's durable facts and the operating surfaces give the team a shared way to compare intended behavior with what the running system can show. Gaps become questions to resolve, not assumptions to preserve.
Intent and evidence in one conversationA durable record supports later questions
Chronicle can retain relevant business facts in order, subject to the system's retention and compliance rules. That history can make later questions easier to investigate; it does not remove the need to design audit and reporting behavior.
A stronger starting point for audit questionsThe honest part
Where Studio is today, and where it isn't.
We would rather you knew this before you spent an afternoon on it.
It is preview software, and that means something
Features arrive often and some of them move. Some lifecycle connections are still partial, and the live runtime is a sandbox for supported model behavior rather than a blanket production guarantee. We would rather state those boundaries than let you infer maturity from the ambition.
Pricing may still change
Studio is a paid Preview product. Current seat options and prices are shown by the hosted product before purchase and may change as the product develops. The terms shown at purchase apply to that order.
It will not cover everything
No tool covers a whole business, and the last stretch is usually the part that makes you different from everyone else. Studio is built to let your engineers drop into ordinary code exactly where that is needed, without leaving the model behind.
When it is the wrong fit
If your teams already design together well and nobody is asking questions the system cannot answer, you may not need this. It earns its keep where several people have to agree on how something works before it gets built — and where being wrong about that is expensive.
What it costs
Free to try. Then per person, published.
Start without talking to us
The hosted product currently offers a trial without requiring a card or a sales call. Current seat options, billing choices, and prices are shown before you confirm a purchase.
Current prices are on cratis.studio.
What you keep
Studio provides export for supported model content. Available formats, access after a subscription ends, and retention are described by the hosted product and the terms that apply when you use it.
Why this one is paid
Cratis Build — the software your business runs on — is open source. You can read it, operate it and continue running it whether you use Studio or Assurance. Studio is the hosted, collaborative product around design and runtime understanding. How we draw that line →