The stack
One cast. One accountable lifecycle.
Cratis is not a catalog of repositories. It is one path through the life of a long-lived .NET business system: design together, build on an open runtime, operate from durable facts, and improve with evidence. One ecosystem, kept deliberately simple.
The lifecycle
Design → Build → Operate → Improve.
Each surface has a clear job. Together they preserve intent, behavior and history as the system changes over years.
Agree on the business
Model commands, facts and views together, then explore the model as a live preview.
Cratis Studio
Carry one typed contract
C# commands and queries become HTTP APIs, TypeScript proxies and React continuity.
Cratis Build
Work from the event record
Use the documented inspection and operational workflows available in each current tool; coverage varies by tool and version.
Workbench · CLI · MCP
Feed evidence back
Use runtime history and specifications to explain state and shape the next change.
Chronicle · Specifications
Nothing in that sequence is a second architecture. It is one model seen at the point where the team needs it.
Cratis Build
The open runtime and operating foundation.
Chronicle, Arc, Components and the operating tools are one open offer. Package boundaries stay useful to developers; customers do not have to decode the repository map.
Owns the event lifecycle: contract facts, append them in order, evolve schemas, derive read models, react to change, replay when understanding changes, and inspect or repair failed processing. The durable record remains the source from which current state can be explained.
And it runs on the databases companies already operate, so keeping the full history fits into your existing operation — not the other way around.
- gRPC / protobuf boundary
- MongoDB
- PostgreSQL
- SQL Server
- SQLite
- Orleans runtime
- Replay & recovery
- Namespaces for tenancy
Turns behavior into a typed application. A C# command becomes an HTTP endpoint and a generated TypeScript proxy — so many backend contract changes surface as TypeScript compile errors instead of silent mismatches. Identity, authorization and tenancy are part of the framework, not per-app boilerplate.
- Commands & queries
- Proxy generation
- Roslyn analyzers
- Tenancy
- Identity & authorization
- Works without event sourcing
Renders Arc's generated proxies as forms, dialogs and data tables. A screen becomes a few lines rather than a few files, and observable queries keep it current without reload code.
- Command dialogs
- Data tables
- Schema editors
- Observable queries
Authenticates at the edge, resolves the tenant, enriches identity, and forwards trusted context to configured HTTP services according to AuthProxy's current routing and integration documentation.
- Authentication
- Tenant resolution
- Identity enrichment
- Routing & invites
Workbench, the CLI, and Chronicle MCP provide public operating surfaces with different current coverage. Workbench offers browser inspection and interaction; the CLI documents event, observer, failed-partition, replay, retry, and job workflows; Chronicle MCP documents event-store, event, observer, recommendation, job, and identity tools. Treat replay and other operational actions as writes, and keep business changes on domain command and event paths.
- Workbench
- CLI
- Chronicle MCP
- Narrator
- Lens
- Synopsis
Separate offers
Design and expertise without changing the Build boundary.
Studio and Assurance work alongside Cratis Build. Neither is part of Build, and neither is required as permission to run or repair Build in your own environment.
Studio is the separate paid design product. Teams model commands, events, and read models together, and Stage can perform supported behavior in a sandbox. Screenplay provides the portable model. Prologue is an emerging brownfield aid; verify its current scope before planning an adoption around it.
Studio remains Preview. Current trial, pricing, export, and retention details are published by the hosted product and the terms that apply when you use it.
Studio →Assurance covers support, reviews, first slices, production readiness, and workshops with scope, availability, and commitments defined by the signed agreement. It does not gate access to Build or its operating tools.
Cratis Assurance →Adoption
Take one piece, or take all of it.
Each product has a focused role and can be adopted selectively. The dependency only runs one way — Arc can sit on top of Chronicle, but Chronicle never knows Arc exists.
| You want | Reach for | Event sourcing? |
|---|---|---|
| History as the source of truth through a documented client | Chronicle on its own | Yes |
| A typed full-stack app over a traditional database | Arc + Components over MongoDB or EF Core | Not required |
| Authentication, tenancy and routing at the edge | AuthProxy in front of your services | Optional |
| A typed full-stack app and a full event history | Arc + Chronicle + Components | Yes |
| A product-grade SaaS shape, end to end | AuthProxy + Arc + Components + Chronicle + CLI | Default |
The last row is where the stack is at its best, and it's the default for a new information system. Coming from an existing one? Adopting Cratis walks through taking one piece at a time.
Documented boundaries, with explicit coverage
Chronicle exposes a gRPC and protobuf boundary. Client libraries and storage providers have different maturity and coverage; .NET is the primary experience. Check each repository's license and the current compatibility documentation before choosing a boundary.
On purpose, and only where it pays
Conventions over configuration, vertical slices over layers, facts over current state. The opinions are what make codebases consistent — and consistency is what makes onboarding fast and AI assistance less speculative. They are also how we take friction out of the day-to-day work — the opinions exist to remove decisions, not to add ceremony.