High-trust execution fabric for autonomous systems and frontier compute.
Get artifacts by default. Replay runs when you need to. Declare permissions up front.
Agents don’t fail like APIs.
You’re not debugging one request. You’re debugging a run that touched tools, state, and time.
State drifts
It drifts between steps, retries, and environments.
Side effects blur
They blur into “whatever happened” and “can’t reproduce.”
Reproduction breaks
Debugging turns into detective work.
If you can’t replay it, you can’t trust it.
Dotlanth is the execution substrate for autonomous systems.
It treats a run as a first-class object. Not an afterthought.
Definition
Dotlanth is an AI-native execution fabric for autonomous systems. It runs your system’s behavior, records what happened, and makes runs inspectable through artifacts.
dotDSL is a small declarative language for capabilities and execution. Dotlanth runs it on a register-based VM and records run history in DotDB.
Dotlanth Studio (separate)
Dotlanth Studio is Synerthink’s private console for operating Dotlanth. It consumes Dotlanth APIs to inspect artifacts and manage environments.
Studio doesn’t change execution semantics. Dotlanth stays the product.
Execution becomes something you can hold.
What ships today.
Focused on replayability, artifacts, and explicit control.
Dotlanth runtime
- Register-based VM
- dotDSL v0.1 (declarative language)
- Default record/replay mode
State and control
- Local DotDB (state + run history)
- Capability security foundation
- CLI tooling
Keep the system explainable.
Artifacts, by default.
Every run produces a structured artifact bundle.
Inspect
See what the run saw, decided, and produced.
Compare
Diff runs when behavior shifts.
Share
Hand your team one source of truth.
The artifact becomes the unit of truth.
Replayable execution.
Record the run. Replay it. Understand what changed.
Record/replay is the default mode in Dotlanth. When something breaks, you replay the run and inspect the artifact.
Dotlanth doesn’t pretend the world is perfectly deterministic. Side effects are treated as controlled events, recorded under declared capabilities.
Debugging becomes replay, not guesswork.
Capability-explicit security.
Permissions are part of the spec.
Declared capabilities
Runs declare capabilities instead of inheriting ambient credentials. Capabilities are declared in dotDSL and enforced by the runtime.
Reported usage
Capability usage is reported so you can review what happened. Connectors stay constrained and capability-gated, with interaction recorded into artifacts.
Permissions stay visible.
Determinism, when you need it.
Strict determinism is optional. Designed for proof.
Dotlanth doesn’t force strict determinism by default. Most real systems can’t.
Deterministic mode is an optional strict flag with replay validation. Phase 2 tightens opcode classes and capability checks at opcode boundaries.
Turn on determinism when you need proof.
Built for agent operability.
Operability is an API surface.
Run API
Submit dotDSL. Get status. Fetch artifacts.
Status streaming
Know what’s happening while it happens.
Isolated contexts
Keep concurrent runs from bleeding together.
Make operability part of the build.
Clear edges. Fewer surprises.
What it is. And what it isn’t.
What it is
- High-trust execution fabric for autonomous systems and frontier compute.
- Artifact-first runtime with record/replay.
- Security model based on declared capabilities.
- Local-first engine with DotDB run history.
What it isn’t
- A services puzzle you assemble.
- A drag-and-drop builder.
- A black box that hides side effects.
- Dotlanth Studio isn’t the engine.
Clarity is the feature.
Build trust in the right order.
We build visibility first, then validity, then operability.
Stabilize Core
Trace export, state diff, versioned artifact schema, and dot inspect/replay.
Deterministic Mode
Strict flag, opcode classes, opcode-boundary checks, replay validator.
Agent Operability
Run API, dotDSL submission, status streaming, isolated contexts.
Intent Layer
Intent block → validator/transformer → executable spec. Deterministic and testable.
Execution as Product
Hosted deterministic clusters, capability-scoped tenancy, versioned environments.
Each phase tightens the loop.
Start with one run.
Get the latest release and run locally. When you’re ready to go deeper, read the vision and roadmap.