The stack
Keep business history, contracts and behavior connected.
Cratis brings together tools for systems you need to explain and change: Chronicle for event history, Arc for typed commands and queries, and Screenplay for explicit business models. Choose the part you need. Studio adds an optional paid design workspace; Direct governs agentic engineering, with access opening in stages.
Capability map
Know which piece does the job.
One ecosystem, with focused products you can adopt separately. Published packages or images do not promise feature parity across languages; the support matrix has the details.
| Product | What it helps you achieve | Availability and limits | Go deeper |
|---|---|---|---|
| Chronicle | Explain today's state and build new views from recorded events through projections and reactions. | Packages and images published; client coverage varies | Chronicle docs |
| Arc | See which frontend code a backend contract change affects through generated TypeScript proxies and React hooks. Event sourcing is optional. | Packages published; TypeScript backend available from source | Backend · Frontend |
| Components | Builds React forms, command dialogs and query-backed tables on Arc's generated proxies. | Packages published | Components docs |
| Fundamentals | Provides reusable concepts, serialization and other shared building blocks beneath the stack. | Packages published | Fundamentals docs |
| CLI | Inspects and diagnoses Chronicle events, observers and failed processing from the terminal. | Published tool; action coverage varies by version | CLI docs |
| Studio | Agree on commands, events and expected views together in a shared Screenplay modeling workspace, built on Chronicle. | Paid; sign-up open, 14-day free trial, per-seat pricing | Studio docs · The offer |
| Direct | Control how far agent work progresses and review the evidence behind it. The control plane for agentic engineering uses journeys and gates. | Runs Cratis's own engineering; access opens in stages | Cratis Direct |
| Screenplay | Records desired business behavior in a portable declarative .play model. |
Supported behavior varies by consumer | Screenplay docs |
| Prologue | Observes selected signals from an existing system and proposes an event model for your review. | Verify current inputs, data handling and output coverage before use | Prologue docs |
| Cratis Choreography | Keep business processes running across restarts with durable jobs, workflows, state machines and workers on Orleans. | Choose the building block and storage for your process | Cratis Choreography docs |
| Stage | Compile Screenplay models, verify supported specifications and explore supported behavior in a disposable sandbox. | Supported model subset; sandbox, not production hosting | Stage docs |
Chronicle clients: .NET · TypeScript · Kotlin / Java · Elixir · Go (no observers or projections) · Python (not published). Client coverage differs; start with Chronicle in your language. The open tools are MIT-licensed; Studio is a separate paid product.
Start small: Your first five minutes with Chronicle → Follow one fact through an event, a projection and a reaction.
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 supported behavior in a sandbox.
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
These tools share concepts, not a promise of automatic delivery from design to production. Check the documented capabilities of each tool. Choose a starting point in an existing system →
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. Generated contracts remove the hand-written API client; observable queries keep the screen 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, agent governance and expertise alongside Build.
Studio, Direct and Assurance work alongside Cratis Build. They are separate offers, not 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, not a production deployment. Screenplay provides the portable model. Prologue is a brownfield aid; verify its current scope before planning an adoption around it.
Studio is optional and built on Chronicle. Sign-up is open with a 14-day free trial and per-seat pricing at cratis.studio. The Studio page describes export and retention.
Studio →Keep agent work accountable through journeys, gates and recorded evidence. 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 Direct →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. The CLI and other operating tools are optional, not prerequisites for using Chronicle or Arc. 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 support matrix before choosing a boundary, and the capability map for each product's scope and maturity.
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.
Evaluate the stack
Start here.
- Install. Check the prerequisites and scaffold a local application with the template getting-started guide.
- Model and build one slice. Follow Build a full app from a command through its event and projection to the screen.
- Run it. Use the local startup instructions to start Chronicle, the backend and the frontend, then register a name and inspect its event in Workbench.