Let AI agents operate your production machines - safely. Reads run; every write is blocked and queued for a human to approve before it touches anything. No SSH, no VPN, no open ports.
The one idea: on a production agent, an AI (or any automation) can inspect everything the agent can reach, but it cannot change anything until a person approves the exact action.
# your agent asks to do something destructive on prod...
$ reach exec --agent prod -- kubectl delete pods --all -n payments
Status: REJECTED - approval required; a request was sent to your operator.
# ...an operator approves the pending rule once - structured, not a string:
# { verb: delete, resource: pods, namespace: payments, name: * }
$ reach approvals approve appr_9f2c
Approved.
# ...and now it runs - this time and next, without re-asking.
$ reach exec --agent prod -- kubectl delete pods --all -n payments
Status: SUCCEEDEDYou approve a rule, not a command string - so an approved action can't be extended (… | tee /etc/x, … && rm -rf) to smuggle something past it. That's the difference between "AI on prod" being a liability and a system you can operate with confidence.
Zero to your AI agent running commands on a real machine, in three steps:
1. Start Reach. One command runs the backend, creates your tenant and first agent, installs the CLI, and logs you in:
curl -fsSL https://releases.reach.nabeem.com/local-setup.sh | bash2. Install the agent on the machine you want to control. The script prints a ready-to-paste command - a curl … | sudo bash for a host, or helm install … for Kubernetes.
3. Connect your AI tool. reach agent-init writes the context file for Claude Code / Cursor and prints the MCP server config to drop in - now your agent can drive that machine through Reach:
reach agent-initNow ask your AI agent to run something - or check it yourself:
reach exec -- hostnameThat's it: your AI agent has controlled, audited access to the machine - no SSH, no VPN, no open ports. Setup asks you to pick the mode and defaults to readonly (safe: the agent can look but not touch) - a new agent never runs writes by default. For real operations, choose approved (Agents → [agent] → Policy) so reads run and writes stop for sign-off - that's the posture up top; wild (unrestricted) is opt-in for personal/dev boxes. On AWS instead? Swap step 1 for lambda-setup.sh. Docker, Kubernetes, and production hardening are in SELF_HOSTING.md.
Reach gives AI agents controlled, audited command execution on machines you own. It is not a sandbox for arbitrary untrusted commands.
- On production, run
approvedmode - the posture above: reads run, every write needs a human-approved structured rule, everything else is blocked and queued. This is the intended way to point an AI at real infrastructure.wildmode is the opt-in exception - it runs anything (reboots, deletes, package installs). Use it only on personal/dev boxes where you're the sole user.- Reach is not a security boundary against the machine's own owner/root - whoever controls the host can read the agent's token.
See SECURITY.md for the full threat model, and POLICIES.md for how the modes work.
- Give an AI agent standing access to production - safely - lock agents to
approvedmode: reads run, every write waits for a human to approve the exact rule, everything is audited. The headline use case. - Run agent-driven operations you can trust - restarts, scaling, rollouts, targeted deletes - each gated by a structured rule an operator approved once, not a command string that can be extended past the check.
- Check Kubernetes pods from an in-cluster agent - install the agent inside the cluster, run
kubectlthrough it from your laptop; non-kubectltools (helm, flux) are approvable the same way. - Let Claude Code inspect a remote dev box - check what's running, tail logs, or diff configs without leaving your editor (reads never need approval).
- Debug Docker containers without SSH -
reach exec -- docker ps,docker logs,docker inspectfrom anywhere. - Manage an autoscaling group as one fleet - bake a fleet join token into your autoscaler's launch/instance template (AWS ASG, GCP MIG, Azure VMSS, …); instances auto-enroll on scale-out and clean themselves up on scale-in, inheriting the fleet's approved rules.
The agent never accepts inbound connections - it makes outbound HTTPS requests to your backend, polls for jobs, runs them, and posts results back.
- Deploy the backend (Local, Lambda, Docker, or Kubernetes).
- Register agents in the console (or let the setup script do it) - you get ready-to-paste install commands.
- Install the CLI locally and the agent on each machine.
- Queue commands via the CLI, MCP, or the console; the agent picks them up and runs them; results come back.
The local and Lambda setup scripts do 1-3 for you. See ARCHITECTURE.md for the full design.
Reach is self-hosted. The Quick Start above uses the Local script; four backends are available:
| Backend | Setup |
|---|---|
| Local (no cloud account) | curl -fsSL https://releases.reach.nabeem.com/local-setup.sh | bash |
| AWS Lambda + DynamoDB | curl -fsSL https://releases.reach.nabeem.com/lambda-setup.sh | bash |
| Docker + PostgreSQL (any cloud) | docker run … nabeemdev/reach:0.1.0, then finish in the console at /ui |
| Kubernetes (Helm) | helm install reach reach/reach … - self-contained (bundles Postgres + Redis), or wire to managed Postgres / DynamoDB |
The Local and Lambda scripts are interactive and re-runnable (--update, --down, …) and enroll your first agent for you. The Kubernetes backend runs the same image via the reach Helm chart - self-contained by default, or point it at a managed Postgres (or DynamoDB on EKS). Full setup - environment variables, installing the CLI, enrolling host / Kubernetes / fleet agents, grants, and lifecycle - is in SELF_HOSTING.md.
The backend serves a web console at /ui (platform-admin and per-tenant logins) to manage agents, fleets, users, approvals, API tokens, and audit logs - and to run commands (single-agent or fleet/tag fan-out, write-gated to what you can access, with a dry-run preview + confirm). The CLI and MCP server authenticate with API tokens:
reach exec -- <command> # run on your default machine
reach exec --tag env:prod -- <command> # fan out across a tag
reach fleets exec <fleet> -- <command> # fan out across a fleetreach agent-init wires Claude Code / Cursor in over MCP. Full command reference, profiles, aliases, and MCP setup: cli/README.md; every HTTP endpoint: API.md.
Each agent runs in one of three modes (set in the tenant console or via the API):
approved← the production mode - reads run; every write runs only if it matches a rule a human pre-approved for that agent, otherwise it's blocked and queued for review. This is the whole point of Reach.readonly- only reads run; any write/delete/restart/install is blocked. For a locked-down "look but don't touch" agent.wild- runs almost anything; only a fixed set of known catastrophic/abuse patterns (rm -rf /,mkfs, privileged escapes, reverse shells) is always blocked. For personal/dev boxes where you're the sole user.
Host and Kubernetes agents share these modes but enforce them differently - agent-side Landlock vs backend-side gating. Approvals are structured rules on both: host {bin, args[]} (positional *, trailing ...), k8s {verb, resource, namespace, name}. Full detail (enforcement model, structured rules, access_level): POLICIES.md.
Controlled execution by design: no inbound ports, outbound-HTTPS-only agents, a default command timeout, a catastrophic-command blocklist enforced server-side in every mode (rm -rf /, fork bombs, privileged escapes, known credential-access & exfiltration patterns, reverse shells), and a full audit trail. Sensitive reads (SSH keys, .env, kubectl get secret) are gated like writes - blocked in readonly, approval-required in approved - and command output is redacted for recognizable secrets (an approved secret read is shown unredacted, since approving is the authorization to see it). Kubernetes agents add no-shell + a kubectl allowlist bounded by cluster RBAC. The distribution path matches the runtime bar: every release is signed (cosign keyless), checksummed, and ships an SBOM + SLSA provenance, and the agent installer verifies its download - one-command install stays, with a verifiable path alongside it. Full model: SECURITY.md · POLICIES.md · SUPPORT.md.
A built-in audit log (every action - logins, agent/fleet lifecycle, policy changes, approvals - tenant- or platform-scoped, filterable, with CSV export), plus Prometheus metrics: the backend's /metrics (reach_backend_*, always on) and an opt-in agent /metrics (reach_agent_*). Detail: SELF_HOSTING.md → Backend metrics · agent/README.md → Metrics.
| Doc | What's in it |
|---|---|
| cli/README.md | The reach CLI and reach-mcp server - install, commands, profiles, aliases, MCP setup |
| POLICIES.md | Policy modes (approved/readonly/wild), approvals, host vs Kubernetes enforcement, structured host & k8s rules, access_level |
| agent/README.md | How the agent works - host vs Kubernetes, credential-only identity, the poll loop, execution models, leader election, RBAC self-review, metrics |
| backend/README.md | The backend control plane - one set of handlers on two runtimes (FastAPI + Lambda), the Postgres/DynamoDB storage split, source map, local dev & tests |
| deploy/helm/reach | Kubernetes backend Helm chart - API + console, bundled Postgres/Redis or external, DynamoDB (IRSA/Pod Identity), migrations, and all values |
| deploy/helm/reach-agent | Kubernetes agent Helm chart - install, RBAC (clusterAccess), execution allowlist, and all values |
| SELF_HOSTING.md | Deploy and operate your own backend (Local, AWS Lambda, Docker, Kubernetes), setup, agent lifecycle, grants, blocked-command reference |
| API.md | Complete HTTP endpoint reference, rate limits, pagination, audit-log actions |
| ARCHITECTURE.md | How the pieces fit - command flow, token model, storage split, policy enforcement, approvals, fleets, multi-tenancy |
| SECURITY.md | Threat model, token storage and rotation, revoking access, audit history, production hardening |
| SUPPORT.md | Supported versions and release integrity - signed images/binaries, checksums, SBOMs, SLSA provenance, verifying a release, and installing the agent (one-liner + verifiable path) |
| CI.md | The CI/CD system - per-component pipelines, PR-vs-merge behavior, version-bump enforcement, signing/attestation, CDN hosting, required secrets, and how to cut a release |
MIT - see LICENSE.






