RTA 💍

RTA, short for Rule Them All and written rta on the command line, is one binary over the tools you already juggle: databases, object storage, secrets, networking, certificates, host telemetry, HTTP APIs. Every capability is written once and rendered on three surfaces: a scriptable CLI, an interactive TUI, and an MCP server for AI agents.

It works with your agent, not instead of it

rta is not another AI CLI, and it does not want to be the thing you talk to. It is the layer underneath the one you already use — Claude Code, Codex, Cursor, Copilot, Gemini — the part that decides what those agents are actually allowed to touch.

That is the whole proposition. Handing an agent a shell is one decision that covers everything it will ever do. Pointing it at rta is a different shape: read-only by default, everything else granted per capability, narrowed to one record, expiring on its own, and written down. You keep your agent; it gets a smaller blast radius and you get a record.

Which is why the security pages below are not an appendix, and why every one of them is also usable by a person at a terminal. The same capability serves both — nothing here is an agent-only feature bolted on.

Install

# a release binary, with the gh CLI (macOS or Linux, amd64 or arm64)
gh release download --repo this-is-tobi/rta --pattern "rta_*_$(uname -s | tr A-Z a-z)_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" && tar -xzf rta_*.tar.gz rta && install -m 0755 rta /usr/local/bin/rta
# or from source, with Go 1.27 or newer
git clone https://github.com/this-is-tobi/rta.git && cd rta && make install
# or the container image
docker run --rm ghcr.io/this-is-tobi/rta:latest --version

Installation has the curl form, the Linux packages and how to verify a download. rta runs on macOS and Linux, on both amd64 and arm64, and Supported platforms lists where the two differ. It does not run natively on Windows; the Linux build under the Windows Subsystem for Linux, version 2, has not been tested.

Try it

rta sys overview          # your machine at a glance: cpu, memory, disk, load
rta                       # the interactive dashboard, with a search over every capability
rta doctor                # what rta can reach from here, the rows that need you first
rta init                  # find the AI clients on this machine and offer to connect each, one question each
rta mcp install claude    # or connect one by name: it reads what is local and asks you for anything else

Ask Claude Code to add a note and rta asks you first — rta agent pending shows the call and rta agent approve lets it through — which is the loop the rest of rta is built around. Quick start walks it in ten minutes, and Start here lays out four tracks: try it, give an agent access safely, run it for a team, and extend it.

Documentation

Website: https://this-is-tobi.com/rta/introduction

Table of Contents - md sources:

Getting started

• Installation - Download it, put it on $PATH, check it works, and where the two supported systems differ
• Quick start - Ten minutes: the CLI, the TUI, and an agent you connect and answer
• Connect an agent - Registering a client, naming it, and checking that it reached rta
• Other ways to install - From source, the container image, the Helm chart, and the plugins that arrive from an index

Using it

• The CLI - Output formats, exit codes, --dry-run, explain, scripting
• The TUI - The dashboard, answering agents, the catalogue, forms and confirmations
• Your config file - Where it lives, rta config set, edit and check, and a first file worth having
• Dashboard and theme - Stating the dashboard in the config file, and the colours
• Config examples - A cluster and its databases, remote services, roles and a dashboard, to copy and change
• Seeing the shape of things - Mapping a directory, a bucket, a Vault mount or an etcd keyspace in one call
• Profiles - Naming an environment once and pointing every plugin at it
• Profiles in depth - Several connections to one plugin, a profile from a script, types, and editor completion
• Reaching private services - A connection through kubectl port-forward or ssh, and the certificate rules that come with it
• Secrets (kv) - An encrypted local store for passwords, certificates and key files

The boundary

• What rta actually bounds - Read this first before giving an agent access: an agent with a shell is not bounded by rta, and this is how to be in the configuration where it is
• MCP and the safety gate - What a connected agent can reach before you grant anything, and what every call is checked against
• Grants - Time-boxed permission for one capability, optionally one record
• Roles, consent and the guard - A day of grants under one word, answering a parked call, and a passphrase in front of issuance
• The record - What agents asked for, what they got, and what is waiting on you
• Stop an agent now - Locks: the instant no, ahead of any expiry or revocation
• Harden in five minutes - A checklist: doctor, init, a lock, a ceiling, small grants and the record
• Team policy - A ceiling a repository can commit, which can only ever subtract
• Connecting your AI tool - Claude Code, VS Code, Cursor, Codex, Gemini, Copilot, and anything else that speaks MCP
• Hosting a server - --http, tokens, probes, and what a remote server leaves out
• The operator channel - Issuing grants and answering consent on a server you have no shell on
• Containers and images - The hardened server recipe, sharing an image, and why not one server for everyone
• OIDC - Naming the person behind a call with the identity provider you already have: what rta verifies, a Keycloak walkthrough, and where the failure messages go
• Kubernetes - Deploying the boundary as a chart, one instance per person: the decisions to make before setting a value, the posture worth choosing, and day two

Plugins

• Using plugins - Discovery, trust and what a plugin may touch
• Indexes and upgrades - Attaching an index, searching and installing from it, and upgrading what you installed
• The plugin inventory - What the TUI's plugin pane shows, and the plugins rta found and refused to run
• Writing a plugin - Fifteen minutes from plugin new to a plugin that runs: the loop, what an answer is, and worked examples
• Declaring inputs - What a capability takes, and how a connection is declared once for every capability of a plugin
• Answers, errors and hints - Hints in the reader's own words, connection failures, refusals and warnings
• Safety, credentials and what rta does to your process - The claims a capability makes about itself, and the checks on declared text
• Testing, conventions and publishing - The conformance suite, the habits worth keeping, and publishing it to an index

Recipes

• Recipes - Worked end-to-end examples: incident triage, a scoped agent, CI checks, backups
• For a security team - Deploying rta, committing a ceiling, handing out roles, reviewing grants and the record, stopping an agent
• For a developer - A day's work: environments, secrets, grants for your agent, the TUI
• An agent in a cluster - From a profile to an agent connected over MCP, with a minted, expiring ServiceAccount token the only thing between them and the cluster

Reference

• Glossary - The words these pages use in one particular way — grant, record, profile, role, plugin — and the acronyms they assume
• The path gate - Roots, symbolic links, hard links and git: exactly where the line falls
• Verify a download - Checksums, build attestations and signatures for the archive, the image and the chart
• External tools - The programs some capabilities shell out to, and what is lost without each
• Where rta keeps things - The config file, the data directory and every file in them

What is in it

21 built-in plugins, 131 capabilities in the default build, and rta plugin list is the inventory:

sys · net · http · cert · fs · kv · note · gen · codec · time · audit · grant · agent · operator · lock · pkg · debug · keys · git · eol · gitignore

Plus anything you install. Twelve first-party plugins live in rta-plugins as proof the contract works — pg, mysql, mariadb, etcd, qdrant, redis, s3, vault, kube, cnpg, docker and keycloak — each a separate binary from a separate module, so the ones you skip cost you nothing, and rta plugin index add official is how they arrive.