revl
A language for safe, universal spatiotemporal composability (Cordis paradigm) and orchestration.
Install / Use
claude mcp add inso1337 -- npx -y github:inso1337/revlIf the server publishes to npm under a different name, use that package instead โ check the repo README.
MCP Server
Model Context Protocol server
Quality Score
Category
SecuritySupported Platforms
Our assessment of revl
revl scores 73/100 on our quality scale, 1024th of 1,094 Security skills we index.
Its MCP Server is 19 KB long, well organised into 15 sections with 3 code examples: a thorough specification that gives an agent plenty to work with.
It has 10 GitHub stars, so there is little community track record yet; judge it on its content.
Maintenance, license and trust
- The repository was last updated today, so revl is actively maintained.
- It is released under AGPL-3.0, a copyleft license: you can use it, but modified versions you distribute must carry the same license.
- Its trust signals score 92/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit โ read the skill file before letting an agent act on it.
revl compared with similar skills
All 4 of these similar skills score higher than revl; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| revl (this skill)by inso1337 | 73 | 10 | today | MCP Server |
| Agent-Reachby Panniantong | 100 | 112.8k | 10d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 82.0k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.9k | today | CLAUDE.md |
| CowAgentby zhayujie | 100 | 48.0k | today | CLAUDE.md |
Frequently asked questions
- How do I install revl?
- Run
claude mcp add inso1337 -- npx -y github:inso1337/revl. The install tabs above show the steps for each supported agent. - Which AI agents does revl work with?
- It is written for Claude Code and Claude Desktop, as a MCP Server file. Other agents that read the same format can often use it too.
- Is revl safe to use?
- It is AGPL-3.0-licensed and scores 92/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is revl still maintained?
- The repository was last updated today, so revl is actively maintained.
Skill content
View source on GitHubrevl is a language for software that changes while it runs. Components
load, unload, and hot-swap inside a live system, and the properties that make
that survivable are checked at compile time: unloading leaves no residue,
dependencies stay coherent, nothing reaches state it never declared. The core
move is small and strict. Every mutation is written beside its inverse, and a
mutation with no inverse, one that crosses the system boundary, must carry an
emit marker at the call site. Irreversibility is legal; invisible
irreversibility is not.
The paradigm comes from Cordis and the paper it implements, A Programming Paradigm for Spatiotemporal Composability. The paper proves strong theorems about revertible effects, but each one rests on hypotheses a library can only ask programmers to respect. revl moves those hypotheses into the checker. C++ had RAII as a discipline and Rust made it a type system; Cordis has revertible effects as a discipline and revl makes them a language. The borrow checker governs lexical resource scope. revl's checker governs dynamic component scope: what may enter a running system, what it may touch while there, and what must be true when it leaves. What this project claims, and what it deliberately does not, is docs/vision.md.
service Database {
emission fn execute(sql: Str) -> Int // crosses the system boundary
}
service Cache {
fn get(key: Str) -> Opt[Str]
emission fn put(key: Str, value: Str) // its body emits, so the interface says so
}
component UserCache requires db: Database provides cache: Cache {
let store = effect Map.new() undo store.drop() // every effect declares its inverse
provide cache {
fn get(key) = store.get(key)
fn put(key, value) {
effect store.insert(key, value)
undo store.remove(key)
emit db.execute(`INSERT INTO cache_log VALUES (${key})`)
}
}
}
Read that as a contract the compiler enforces. Drop the undo and it will not
compile. Call db.execute without the emit marker and it will not compile.
Reach for a service the component never required and it will not compile.
Declare put as a plain fn while its body emits and it will not compile: a
service declaration is an upper bound on what its providers may do. Teardown is
derived, LIFO over exactly the effects that ran, and an undo body has no way
to register new effects because the grammar gives it nowhere to put one. Link
time rejects dependency cycles and two providers of one key. Nine guarantees,
G1 through G9, are the table in DESIGN.md. G1 through G8 each
discharge a hypothesis the paper could only ask programmers to respect. G9 has
no paper anchor: it is revl's own, and it is where this project stops packaging
the paradigm and starts extending it.
Quickstart
revl needs Python 3.11 or newer and is installed from source. The name revl
on PyPI belongs to an unrelated project, so do not pip install revl.
git clone https://github.com/inso1337/revl && cd revl
python3 -m venv .venv && source .venv/bin/activate
pip install -e .
With uv the last two lines are
uv venv && source .venv/bin/activate && uv pip install -e .. To install a
tagged release without a checkout, use
pip install "git+https://github.com/inso1337/revl@<tag>", with a tag from the
releases page. To run the test
suite, install the extra (pip install -e ".[test]") and run pytest tests/.
With the virtual environment active, revl is on your PATH:
revl compile examples/user_cache.rvl # source -> checked IR, printed as JSON
revl emit examples/user_cache.rvl # source -> emitted TypeScript (--backend picks another tier)
revl audit examples/user_cache.rvl # everything that can cross the boundary
revl mcp serve # the compiler as an agent admission gate
make demo # a live hot-swap, migration and rollback
make demo-flagship # one agent, ten steps, six refusals
make demo needs more than the install above: it runs
backends/python/setup.sh on first use (git, uv and network access) to build
the runtime it hot-swaps on. revl mcp serve prints the same pointer if that
runtime is missing and starts with the live verbs unavailable.
The revl console script is the documented happy path. The
absolute-interpreter fallback is python -P -m revl (PYTHONSAFEPATH, 3.11+).
The -P matters: without it, the current directory can shadow the installed
package (issue #336; issue #317 is the underlying mechanism).
The language reference is docs/syntax-2.0.md; if the component author is a model, start with the agent guide instead.
What makes it different
The undo is checked, not hoped for
Undo logic is the classic write-only code path: written once, wrong quietly,
exercised at the worst possible moment. revl refuses the quiet part. Code
outside effect forms is pure, so the accumulator provably holds every
mutation, and the emission marker keeps the two kinds of change, revertible and
not, distinct in the types. When a component deactivates, the runtime replays
inverses in reverse order and the environment is exactly what it was before
activation. That property is what the whole language is shaped around.
The gate defends against the component's author
The reversibility theorems come from the paper. The admission gate does not.
revl treats its input as hostile, because increasingly that input is written by
an agent optimising for "make the tool say yes," and such an author will phrase
a side effect however it must to slip past a name-based check. So the checks are
not name walks. When a generated MCP tool advertises readOnlyHint: true, revl
has proved the operation reaches no irreversible host effect, through an emission
fixed point that follows an effect even when it is handed around as a value and
fired one indirection later. An effect that escapes its declaration does not
compile.
On top of the eight paradigm guarantees, revl adds a security discipline the
paper never described, enforced by the same checker. G9 refuses authority
manufactured from untrusted data unless a declassification is declared and
audited, a static defense against prompt injection. Capability-bound Secret
values cannot reach a log, a serializer, an LLM prompt, or an undeclared
receiver. A further family of rules governs async boundaries, acquisition order,
and provider signatures. The properties an attacker would have to break, and the
executable suite that tries to break them, are in
docs/threat-model.md.
One front end, six live runtimes
<div align="center"> <img src="assets/architecture.svg" alt="one checked front-end, one IR, six runtimes, an MCP admission gate" width="880"> </div>One front end parses, checks, and links .rvl into a single IR. Six emitters
lower that IR to six hardened Cordis runtimes: cordis-py (reference), cordis
(TypeScript), cordis-rs (Rust), cordis4j (Java), cordis-go (Go), and the
first-party cordis-wasm sandbox. This is not six ports of a demo. Components
built for different runtimes compose in one running system across process
boundaries, a Python component consuming a service a Rust component provides
(docs/interop-bridge.md). And the claim that all six
tiers agree is measured, not asserted: every construct is emitted through every
backend and the output is handed to that tier's real compiler, tsc, cargo check, javac, wasmtime. The construct-by-tier matrix and its generated
per-tier support table are in
docs/conformance.md; make matrix regenerates them and
CI gates their output. Where a tier genuinely cannot agree, the conformance
suite pins the divergence and names it rather than hiding it, so a difference
between runtimes is a documented fact instead of a surprise in production.
The compiler is the agent's interface
If components are increasingly written by AI agents, the question that matters
is whether a generated component is safe to deploy into a system that is
already running. revl's answer is to make the compiler the admission gate.
revl mcp serve (to connect it to an MCP client working on your own project,
see the client recipe)
gives an agent revl_check and revl_admit instead of
filesystem access: drafts are held server-side, edited by delta, and nothing
lands until the same checker that guards human commits says yes. A rejected
candidate cannot deploy, and every rejection carries the guarantee it violated
plus the rewrite that fixes it. Tool safety annotations are derived from the
method body rather than asserted by an author, so a tool cannot call itself
read-only when it emits. One tracked run of the Python gate measured the
in-process compile_source(..., manifest=running) round-trip at a median of
0.165 ms for a small candidate against a two-component running composition
on an Apple M1 Max / Python 3.14.3. This is not MCP transport latency.
tests/test_admission_latency.py holds a 20 ms ceiling, which is only a
regression guard, not a performance claim. See the
measurement and a
worked MCP admission example.
docs/mcp-bridge.md has the shapes;
docs/guide-ai-agents.md has the workflow.
Tooling that operates a running system
Because the compiler knows every effect and its inverse, it can answer
questions no ordinary toolchain can. The swap verb of revl run --placement
(a REPL verb, not a revl subcommand) migrates a live component to another
runtime tier, re-pointing every consumer across the cutover and ending with a
proof the old provider left nothing behind
(docs/swap.md). revl plan shows the exact delta a hot-swap
would produce and revl apply executes it with a derived rollback, so a
mid-plan failure unwinds by inverses instead of by hand
(docs/plan.md, docs/apply.md). revl why
prints the derivation behind a rejection or a runtime transition
(docs/why-traces.md).
Placement is an isolation boundary, not just a tier choice
A component can declare an isolation boundary and a capability envelope, no disk, no network, or an explicit allowlist, and run inside a wasm cell, a container, or a microVM while still composed with the rest of the system over th
Truncated for display โ read the full file on GitHub.
Related Skills
Agent-Reach
112.8kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu โ one CLI, zero API fees.
ruflo
82.0k๐ The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.9kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
CowAgent
48.0kOpen-source personal AI assistant & Agent Harness. Plans tasks, runs tools and skills, self-evolves with memory and knowledge. Multi-agent, multi-model, multi-channel. Lightweight, extensible, one-line install.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit โ see the Safety scan above for what the skill file itself contains.
