A new way
to build
with Rust.
Build software you can reason about.
A precise foundation for your coding agents.
A clear model for the people guiding them.
Build the application. Or what it runs on.
- Applications
- Libraries
- Databases
- Frameworks
Let agents build.
Keep the model
in your hands.
Durable actors with typed contracts, explicit effects and precisely scoped capabilities. A common model for what each part owns, how it communicates and what it may do.
See the shape of the system.
Checkout declares operations for reserving inventory and requesting payment. Typed contracts describe those interactions. They do not grant permission to perform them.
Two declared interactions. The contract makes the intended connections inspectable before execution.
What this view tells you
A typed contract describes message and operation shapes. It helps people and agents inspect the system’s intended structure. Whether a particular request is permitted is a separate question, answered by scoped authority and runtime admission.
See where authority begins and ends.
Runtime admission checks the caller, target, operation and scope. Change the example payment grant to see how a declared interaction can be denied.
Admitted in this example. Checkout has a matching grant to request payment for this order.
What this view tells you
- Caller
- Checkout
- Target
- Payment
- Operation
- Charge an order
- Scope
- Order 1042
This example assumes the caller is authenticated and all other admission checks pass. A matching grant applies to this operation and scope; it does not provide unrestricted payment authority. Declaring the operation does not create the grant.
See the evidence of what happened.
Retained execution evidence can show a recorded reservation and where a workflow resumes. Its coverage is explicit: it does not account for every possible data flow.
Reservation result recorded. The payment request has not been attempted.
What this view tells you
The example assumes the reservation result was durably recorded before interruption and the payment request had not begun. Resume continues from the recorded boundary. External effects still need an explicit retry, idempotency or reconciliation strategy.
A retained history has a coverage window and belongs to a particular code and policy context. Missing events do not prove an interaction never occurred; this diagram does not establish complete information-flow coverage or universal exactly-once execution.
All states are illustrative. This model does not execute Septa code.
Set the intent.
Define responsibilities, boundaries and acceptance criteria. Give the agent a system to work within.
Let the agent implement.
Agents write a defined Rust profile, with structured feedback from checking, tests and the runtime.
Inspect what changed.
Review the contracts, authority and execution evidence that apply to the result.
Less uncertainty.
More room
to build.
Rust’s foundations. A deterministic core. Durable execution. A development loop that keeps them connected.
Understand the model01Explicit boundaries
Actors own state and communicate through typed contracts. Follow responsibilities and interactions without turning every boundary into a separate service.
Explore the idea ↗02Predictable behaviour
A deterministic core keeps the rules of your system repeatable. Effects make interactions with the outside world explicit.
Explore the idea ↗03Durable progress
Preserve state and progress across supported restarts. Make retries and recovery part of the design, instead of an afterthought.
Explore the idea ↗04Fast development
Use the installed runtime to check and execute supported Rust without a native build on every edit. Exact package identities keep dependencies precise.
Explore the idea ↗05A composable foundation
Create reusable libraries, databases and frameworks on the same foundations. Extend beyond the core through explicit native Rust interfaces.
Explore the idea ↗06Safety and security
Combine Rust’s safety foundations with defined core semantics, explicit effects and scoped authority. Tie the evidence to the code you are reviewing.
Explore the idea ↗Start from what
you know.
Rust developers
Keep Rust. Discover a different development and execution model.
Elixir & Erlang developers
Start with actors. Explore durable progress and precise authority.
Functional programmers
Bring pure decisions and explicit interactions into one system.
Solo builders
Give your coding agent a small, coherent system to build.
Teams
Share contracts, review changes and understand their reach.
Enterprise
Inspect code identity, authority and the evidence behind a change.
Know what runs.
Control what it can do.
Exact code identities, explicit effects, and scoped authority provide a foundation for reviewing dependencies and limiting their reach.
Explore safety and securityA clearer way forward.
Explore the ideas. Follow a working example. Make it your own.