rutis CLI
A plugin runtime in Rust for software that changes itself: agents write and hot-reload plugins in TypeScript, Python, Go and Swift
- 172 ★ on the repository
- Last commit
Broad access
Why this level
- An agent writes and swaps plugin code that then runs with process permissions and reloads without stopping the program
- Plugins can run on another machine and call services over the network
Install
- Works in
Manual install
npx @arcships/rutis-host new weather --lang nodeQuick start without Rust; then `cd weather && npm install`, `npx rutis-host dev` and `npx rutis-host check`.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- An agent writes and swaps plugin code that then runs with process permissions and reloads without stopping the program
- Plugins can run on another machine and call services over the network
This is third-party code. Review the repository files before installing.
What it does
rutis gives programs and agents a safe way to write, swap and reload their own plugins. The Rust core holds the guarantees: nothing starts before its dependencies, everything a plugin registered is released exactly once and a failed load rolls back. The lifecycle model comes from Cordis, and rutis implements it once and carries it to other languages, processes and machines. The workflow is this: `rutis-host new <name> --lang node|bun|python|go` creates a plugin project, `rutis-host check` shows each plugin's dependencies and services and fails if nothing provides a service, and `rutis-host dev` reloads a plugin when files change. Plugins call each other's services by name in one process, in another process or on another machine. The repository has skills for agents: `rutis-new-runtime` and `rutis-remote-plugin`.
Who it is for. Developers of agent systems and long-running programs who need to connect new APIs, models and devices through plugins written and replaced by the agent itself.
Good fit when
- An agent must write a plugin for a new API itself, check it and swap it without stopping the program
- Python and TypeScript plugins must call each other's services by name
- Plugin dependencies must be visible and a service nobody provides must be caught
- Some plugins run on another machine while the call uses the same name
Not a fit when
- A ready plugin for a specific service is needed: rutis offers a runtime and no set of plugins
- The application is simple and does not change after release: the runtime overhead is not justified
- Strict isolation of untrusted code is needed: the guarantees concern the lifecycle and not a sandbox
Example request
Create a weather plugin on Node, connect it to the llm service and check dependencies with the rutis-host check command.Limitations
The runtime is aimed at developers: to run without Rust `npx @arcships/rutis-host new weather --lang node` is enough, and for Rust the `rutis` crate and `tokio` are added. Language runtimes are Node, Bun, Python through uv, Go and Swift, each with its own guide in `docs/guide/`. The lifecycle guarantees do not isolate a plugin from the system: plugin code runs with process permissions. The project is young and plugin interfaces may change. The latest commit in the repository is from November 2026.
How to disable. Remove the created plugin projects and packages (`npm uninstall @arcships/rutis-host`, `cargo remove rutis`). Installed `rutis-new-runtime` and `rutis-remote-plugin` skills are removed from the agent skills directory.
FAQ
How do I start without Rust?
With `npx @arcships/rutis-host new weather --lang node`, then `cd weather && npm install` and `npx rutis-host dev`. Bun, Python and Go have their own command variants.
What guarantees does the runtime give?
Nothing starts before its dependencies, everything a plugin registered is released exactly once when it stops and a failed load rolls back.
What does rutis-host check show?
Each plugin's dependencies and services. The command fails if some service has no provider.
Where does the lifecycle model come from?
From the Cordis project. rutis implements it once in a small Rust core and carries it to other languages, processes and machines.
Is there help for agents?
Yes, `.agents/skills/` holds the `rutis-new-runtime` skill for a new runtime and `rutis-remote-plugin` for remote plugins.
Discussion
No questions or reviews yet.
Related
CLI toolsThree skills and a clippy config: an agent writes, reviews and ports idiomatic Rust, and CI enforces the checkable rules
A Rust coding agent in the terminal: extensions in any language over JSON-RPC, cloud and local models, audio, computer control
cargo agents matches a Rust project's dependencies to a plugin registry and installs the needed skills, hooks and MCP servers.
A Python-to-Rust transpiler with an MCP server: agents estimate migration effort, translate modules and verify the output.
A small terminal coding agent in Rust: bring your own API key or local model, per-turn cost, real undo and session branches
A modal Rust editor with built-in MCP: an agent reads buffers and terminals, and terminal input waits for your approval
README in short
The README states the goal (a plugin runtime for software that changes itself), shows the workflow and a quick start without Rust and in Rust. Language guides, the design philosophy and API docs follow.