Motus Continuum · Open source
Execution and evidence are produced together.
Motus records the causal path of an AI workflow while it executes — not by reconstructing logs afterwards.
Nothing about a driven wheel is asserted independently of what drove it.
Leonardo da Vinci, Codex Madrid I · Biblioteca Nacional de España, Madrid, c. 1493-97 · plate
Execution graph
Different inputs take different paths. Motus records the path that actually happened.
request → Motus runtime → node A → node B — decision recorded → node C → final result + execution trace
- which nodes executed
- which decisions selected a route
- which attempts failed
- which retries occurred
- which effects were committed
- which human approvals occurred
What makes it different
Causal evidence, not reconstructed observability.
Logs
Tell you what components reported.
Motus
Records what the execution actually did.
The UI does not invent the story.
The runtime already knows the story.
What a step records
Four kinds of record, per step of the execution.
Reads
What a node consulted before it acted — the values, and where each came from.Writes
Facts, decisions and rejections a node commits to the record — including what it declined to do.Decisions
The route selected at a branch, and the condition that selected it.Effects
Anything a node declared as touching the outside world — enforced by the runtime, not self-reported.
Open & agnostic
Use the AI stack you already have.
Nodes think. Motus orchestrates.
Motus is model-agnostic, provider-agnostic, agent-framework agnostic, domain-neutral and embeddable. A node can represent:
- an LLM
- an AI agent
- Python code
- retrieval
- an API
- a database operation
- a deterministic rule
- a human approval
Evidence by design
Execution produces structured evidence natively, not as an afterthought.Open verification
Checking the evidence never requires a Vitruvyan endpoint, key or company.Domain neutrality
Business meaning belongs to consumers and nodes, not to the runtime.Minimal embeddable core
No LLM SDK, database, or agent-framework dependency.
Open verification
Evidence you can verify without trusting us.
Execution
Canonical evidence
Cryptographic commitment
Optional witness
External anchor
Independent verification
A witness and an anchor play different roles. Motus does not depend on any one blockchain — OpenTimestamps, a private anchor or a qualified provider are all possible implementations, and none of them ships inside the core runtime. Governing which anchors and witnesses an organisation trusts, and preserving that proof over time, is what Motus Perpetuum is for.
Verification must never require trusting Vitruvyan.
Installation
Install it. Write a node. Run it.
A node is an ordinary function — no base class, no registration step, no agent framework to learn first.
$ pip install vitruvyan-motus
Successfully installed vitruvyan-motus-0.9.0
$ nano motus/nodes/retrieve.py
from core.agents.qdrant_agent import QdrantAgent
from vitruvyan_motus import Fact
_qdrant_agent: QdrantAgent | None = None
def _get_qdrant_agent() -> QdrantAgent:
"""Lazy singleton — avoids connecting at import time."""
global _qdrant_agent
if _qdrant_agent is None:
_qdrant_agent = QdrantAgent()
return _qdrant_agent
def retrieve(state, ctx):
query = state.fact("query")
hits = _get_qdrant_agent().search(query, top_k=5)
return state.with_fact(
Fact("citations", hits, source="qdrant", ts=ctx.now())
)
$ python run.py
node retrieve → 5 citations
node classify → intent=support
node respond → effect committed
✓ run complete — trace written to run.json
$ motus-validate trace run.json --spec graph.json
✓ trace valid — 5 records, root sha256:9c2f…Read examples/01_first_run.py through 06_effects_and_receipts.py in the repository— six standalone scripts, each printing what it did.
Read the runtime. Ask it a question. Verify what it recorded.
Motus does not ask for trust. It is open source and built to be embedded.