SkillAgentSearch skills...

revl

A language for safe, universal spatiotemporal composability (Cordis paradigm) and orchestration.

Install / Use

claude mcp add inso1337 -- npx -y github:inso1337/revl

If the server publishes to npm under a different name, use that package instead โ€” check the repo README.

About this skill
๐Ÿ”Œ

MCP Server

Model Context Protocol server

Quality Score

73/100

Category

Security

Supported Platforms

Claude Code
Claude Desktop

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.

Substance
30/30
Structure
18/20
Description
12/15
Adoption
4/20
Freshness
15/15

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.

SkillScoreStarsUpdatedFormat
revl (this skill)by inso13377310todayMCP Server
Agent-Reachby Panniantong100112.8k10d agoCLAUDE.md
rufloby ruvnet10082.0ktodayCLAUDE.md
headroomby headroomlabs-ai10079.9ktodayCLAUDE.md
CowAgentby zhayujie10048.0ktodayCLAUDE.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.
<div align="center"> <img src="assets/banner.svg" alt="revl: revertible effects as a type system" width="820"> <p> <a href="https://github.com/inso1337/revl/actions/workflows/ci.yml"><img src="https://github.com/inso1337/revl/actions/workflows/ci.yml/badge.svg" alt="CI"></a> <img src="https://img.shields.io/badge/runtimes-6-2dd4bf" alt="6 runtimes"> <img src="https://img.shields.io/badge/emitted%20code-validated%20by%20real%20compilers-2dd4bf" alt="validated by real compilers"> <img src="https://img.shields.io/badge/self--hosting-native-2dd4bf" alt="self-hosting"> <img src="https://img.shields.io/badge/agent--native-MCP-a78bfa" alt="MCP native"> <img src="https://img.shields.io/badge/license-AGPL--3.0%20%2B%20MIT-blue" alt="AGPL-3.0-only compiler, MIT runtime and examples"> <img src="https://zenodo.org/badge/DOI/10.5281/zenodo.23355060.svg" alt="DOI"> </p> <p> <b><a href="#quickstart">Quickstart</a></b> ยท <a href="#what-makes-it-different">What makes it different</a> ยท <a href="docs/README.md">Documentation</a> ยท <a href="DESIGN.md">Design</a> ยท <a href="docs/vision.md">Vision</a> ยท <a href="docs/guide-ai-agents.md">For agents</a> </p> </div>

revl 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

View on GitHub
GitHub Stars10
CategorySecurity
Updated5h ago
Forks2

Languages

Python

Trust signals

92/100

From repository metadata: license, adoption, age and documentation. Not a code audit โ€” see the Safety scan above for what the skill file itself contains.

1 low1 info
revl โ€” MCP Server: Install & Safety Check | SkillAgent