⌘K

Install guide

For private agents: run a short install step, then watch Reachability and Outcomes here
Walkthrough

We check agents from outside. If the agent sits inside a company network, you run a small install next to it. That lets us monitor without opening their firewall.

1Create

Add a Private agent under Agents.

2Connect

Embed the connector in your product startup, or paste the one-liner for a quick ops test.

3Deploy

Inject agent_id and token at deploy time. Whoever runs the agent never runs a CLI.

4Monitor

Open the agent for Summary, Reachability, Outcomes, and Incidents.

1
Embed in your product
Recommended

Start the connector beside the agent. Whoever runs the agent never installs AgentStatus. Create the Private agent once here, inject credentials via env at deploy, and keep monitoring continuous.

Dependency
pip install "agent-status-sdk[tunnel]"
In product startup (customer never runs CLI)
import os
from agent_status.tunnel import expose_http

expose_http(
    agent_id=os.environ["AS_AGENT_ID"],
    token=os.environ["AS_TUNNEL_TOKEN"],
    target="http://127.0.0.1:8080",  # your agent’s local HTTP
    blocking=False,
)
# … start your agent as usual
2
One command
Ops / smoke test

After you create a Private agent, the portal’s Copy & connect fills agent_id + token. Use this to prove the tunnel on a laptop or bastion before embedding. Default target is http://127.0.0.1:8080.

Shape of the one-liner (portal fills ids)
pip install -q "agent-status-sdk[tunnel]" && agent-status expose --agent-id <uuid> --token rtun_… --target http://127.0.0.1:8080
3
Always-on Docker
Optional

Only if you cannot embed and need a process that restarts itself. Same connector, wrapped in python:3.12-slim. Prefer embed when you control the agent process. This is an ops appliance, not the default.

docker run
docker run -d --restart unless-stopped --name agent-status-connector \
  --add-host=host.docker.internal:host-gateway \
  -e RORA_TUNNEL_TOKEN=rtun_… python:3.12-slim \
  bash -c 'pip install -q "agent-status-sdk[tunnel]" && agent-status expose --agent-id <uuid> --token "$RORA_TUNNEL_TOKEN" --target http://host.docker.internal:8080'
Where to get it

Published on PyPI as agent-status-sdk. The GitHub repo is private. Customers install from PyPI only.

How the private tunnel works

Use Private (tunnel) when the agent has no public URL. No inbound firewall hole. Your connector dials out; independent nodes still probe from the outside.

Probe path · private tunnel
Dial-out only · no inbound

Ordered hop from an independent node to your private agent. Your side only runs an outbound connector.

  1. Independent nodes

    Outside-in

    Distributed nodes originate the probe. Your VPC never opens inbound. This is the attestation path, not a claim that users can reach the agent.

    Evidence

    HTTP GET/POST from distributed nodes

  2. Probe URL

    Public

    Nodes hit Carmel’s public relay URL. This is not your VPC address — do not open inbound firewall for it.

    Evidence

    https://rora-tunnel.carmel.so/probe/{agent_id}

  3. Tunnel relay

    Carmel

    Relay holds your connector’s WebSocket and forwards each probe. Orchestration only — nodes still originate.

    Evidence

    wss://rora-tunnel.carmel.so/ws/connect

  4. Your connector

    Outbound

    Process you run next to the agent. Dials out with the portal rtun_ token. Must stay running.

    Evidence

    agent-status expose --agent-id … --token rtun_…

  5. Private target

    Your network

    Connector proxies the probe to an HTTP URL only your network can reach.

    Evidence

    --target http://127.0.0.1:8080 (or private IP / hostname)

  6. Your agent

    HTTP

    Any framework behind that URL is fine — it must answer HTTP. No public URL required.

    Evidence

    Private HTTP response → back through the same path

Requirements
HTTP face
Required
Agent (or thin adapter) must speak HTTP/HTTPS at --target.
Network path
Required
Connector host reaches the private agent and the internet outbound (WSS to the relay).
SDK + process
Required
pip install "agent-status-sdk[tunnel]" and keep expose running.
If your agent is not HTTP
gRPC / TCP / message bus
Extra step
Put a small HTTP gateway in front of it first, then point the install at that gateway.
Unix socket only
Extra step
Expose a local HTTP listener that talks to the socket, then point the install at that listener.
After create
Paused until connect
Expected
Monitoring stays paused until a connector attaches with a valid rtun_ token.
Token once
Secret
rtun_ is shown once. Store it, or rotate later from Setup.
Real --target
Required
Point at the private HTTP path you actually want probed — not a dummy port.
Verify
Portal status

Connector should read Connected.

Probe from outside
curl -i "https://rora-tunnel.carmel.so/probe/{agent_id}"

With connector up, this reaches your private target.

Common failures
Waiting for connector
Reach
Process down, bad token, or outbound WSS blocked.
502 / forward failed
Target
Wrong --target or agent down behind it.
Auth rejected
Token
Token rotated. Update connector from