Agentic SSH · hosted MCP · zero keys on the agent

Every server. One portal.

Ask your agent to fix prod. One ask fans out across every server you've scoped — and every command travels through one portal, policy-checked, certificate-signed and recorded, before it touches a machine.

agent: ops-bot · via sshportal.ai · scope: web tier (3 endpoints) ● recording
you ▸ 502s on the web tier — find the bad box and fix it

[portal] ops-bot ▸ run_command web-01 web-02 web-03 check api + mem · parallel
[portal] policy ✓ · 3 certs minted, 5-min TTL ✓ · scope ✓ · ● recording
web-01  healthy · p95 180ms · mem 2.1G
web-03  healthy · p95 170ms · mem 2.3G
web-02  api worker rss 7.9G → oom-kill · 502s climbing
[portal] ops-bot ▸ run_command web-02 journalctl -u api -n 50
web-02  leak in /v2/export since 02:14 · worker never frees buffers
[portal] ops-bot ▸ systemctl restart api on web-02 — waiting for your approval
you ▸ approve
[portal] approved ▸ executing on web-02
web-02  api.service — active (running) · 502s stopped
[portal] done in 41s · one ask, three servers · full replay saved
zero keys on the agent policy on every command replayable end to end
  • No keys on the agent
  • Approvals on risky commands
  • Every session replayable
  • One-click kill switch

Hands for your agents

Anything that speaks MCP — Claude Code, claude.ai, Cursor, Codex, your own tool loop — points at one hosted URL and can list its servers and run commands immediately. No SSH config, no jump hosts, no keys wired into yet another tool.

You keep command

Every command passes your policy engine. The routine runs, the reckless is blocked, and the gray area waits in an approval queue for your click. Revoke an agent and its token dies with its live sessions, mid-command.

Humans welcome too

The same fleet is yours from any browser: full terminal, file transfers, nothing to install. Teammates get the same clean, keyless treatment the agents do — and the same audit trail.

Give agents hands.
Keep command.

AI agents are already writing your code and triaging your incidents. This is how they touch real servers: scoped, supervised, disposable access — and never a raw key in a config file.

One URL. Any agent. Every server.

A single hosted MCP endpoint exposes your fleet: list_endpoints, run_command, full interactive sessions. Browser clients like claude.ai connect with OAuth consent; CLIs use a bearer token.

Scope is a list you control

Attach an agent to one staging box; when it earns trust, attach the web tier or everything you own. Detach an endpoint and the agent loses it mid-conversation — scope is re-checked on every single call.

Your rules, on every command

A per-org policy engine sees every command before it runs. Allow the routine, block the reckless, and route restarts, deletes and schema changes to a human approval queue. The agent waits politely; you decide in one click.

A kill switch that means it

Revoke an agent and it's over: the token dies, live sessions are torn down mid-command, and nothing lets it back in later — because it never held anything to begin with. No credentials to rotate, no doubt.

Replay every move

Person or agent, every session lands in a tamper-evident, hash-chained audit log. See exactly what your agent did at 3 a.m., prove it to your auditors, and settle "who changed that?" with a replay instead of an argument.

Hosted agent runs

Bring your Claude Code, Codex, Gemini or Grok account and launch the CLI from any terminal session. It runs in a locked-down container whose only reach is your fleet through the same scoped, policied MCP tools.

A real terminal for people

Full xterm sessions from any browser, with drag-and-drop file transfers and live session sharing. Watch an agent work in read-only, or jump into the same PTY beside it.

Dedicated egress IPs

All sessions reach your servers from published relay addresses — or from a dedicated IP that's yours alone. Allowlist it, and port 22 goes dark to everyone else on the planet.

Explore the full platform →

What will you
stop doing by hand?

Every chore below is one sentence to an agent on sshportal.ai. It works the fleet; you approve the moments that matter.

Patch the fleet and reboot one box at a time

The agent upgrades all 23 servers, drains and reboots them in sequence, and reports what changed.

Find out why the API is throwing 502s

It greps logs across the tier, spots the OOM-killed worker, and queues the restart for your approval.

Verify last night's backups actually restore

A scheduled agent restores the dump into a scratch database and row-counts it — every morning.

Renew every cert expiring in 30 days

It sweeps the fleet for expiring certificates, renews them, and reloads only what needs reloading.

Ship v2.14 to staging, smoke-test, then prod

Deploys, runs the checks, promotes — and the prod step waits in your approval queue.

Who is hammering us? Block them

It tails access logs, finds the abusive IP, and proposes the firewall rule. You click approve.

See a dozen more, with real session transcripts →

From zero to agent
in 60 seconds

Deploy an agent in the console, pick which servers it may touch, and copy one config block. That's the whole integration: the agent token is the only secret, and it can't do anything your scope and policy don't allow.

Browser tools skip the token entirely — claude.ai, ChatGPT and Grok connect with an OAuth consent page. Prefer batteries included? Built-in AI chat works your fleet from the console through the exact same scoped, recorded path.

  • Works with Claude Code, claude.ai, Cursor, Codex — anything that speaks MCP
  • OAuth consent for browser connectors, bearer tokens for CLIs
  • Scope and policy re-checked on every call
  • No side channels, no unlogged shells
Deploy an agent
.mcp.json
{
  "mcpServers": {
    "sshportal": {
      "type": "http",
      "url": "https://sshportal.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${SSHPORTAL_TOKEN}"
      }
    }
  }
}
tools: list_endpoints · run_command · sessions scoped to the servers you attach

Why it's safe to hand
an AI a shell

Not because we promise the agent will behave — because the plumbing makes misbehaving pointless. The boring, bank-grade details, so you don't have to think about them:

  • Agents never hold keys. Your SSH keys stay sealed in the vault. Each session gets a certificate signed by your org's own CA that expires in five minutes and only works from our relay. Steal it and it's already dead.
  • One session, one server. Every session runs in its own sealed sandbox that can reach exactly the machine it opened, so an agent gone sideways has nowhere to go.
  • Close port 22 to the internet. All sessions arrive from published relay IPs or your own dedicated address. Allowlist those, and your servers go dark to everyone else.
  • Rotate nothing, revoke anything. Certificates expire on their own; agent and team access dies the moment you click revoke, live sessions included.
Add your first server The full security model →

One plan.
Everything included.

You pay per server, not per seat. Deploy as many agents and add as many teammates as you want, free.

Base

Pack

$9.95/mo

  • 10 servers included
  • Unlimited AI agents & teammates
  • Hosted MCP + AI chat
  • Policy engine & approval queue
  • Web terminal & file transfers
  • Audit trail & recordings
Start with the Pack

Hardened egress

Dedicated IP

+$4.95/mo each

  • One egress IP, one tenant: you
  • Pin firewall rules to a single address
  • Never shared, never recycled
  • Stack as many as you need
Claim an IP

Worked examples and billing FAQ →

Your fleet is one URL away
from having an agent.

Add a server, deploy an agent, and watch it run its first command in under five minutes.

https://sshportal.ai/mcp
Get started · $9.95/mo