One agent. One Linux home. Ship from chat.

SSHGrid gives you a persistent AI agent on a real Ubuntu account. Describe what you want in plain English — a marketing site, a contact form, an internal tool — and it writes the code, runs commands, and serves it from a subdomain that's already yours. Edit the same files over SSH, SFTP, or Remote-SSH whenever you want to jump in yourself.

The agent

Every account has one persistent agent. It remembers conversations, plans multi-step work, writes files, runs shell commands, and shows you the result — not a script runner with a chat skin.

Think of it less as a chatbot and more as a teammate who happens to share your shell account. Pick up where you left off, change your mind, ask a follow-up. The agent reads its own logs when something breaks and usually fixes itself.

What it can do on your box

The agent doesn't talk to your server — it runs inside it, signed in as your Linux user. Anything you could do over SSH, it can do too.

› save the photos from ~/uploads/team/ into a /about gallery
› back up ~/data nightly at 3am, keep 14 days, log to ~/logs/backup.log
› read ~/logs/error.log and tell me what /products is doing
› add my-domain.com and issue an SSL cert when DNS propagates

Preferred web stack

The agent can build with anything on the box, but defaults to the shortest path from idea to live URL — no build step, no separate database server.

Your Linux home

Every account is a real Ubuntu user with a real home directory. This is where everything you ship lives.

~/                              # /home/<handle>.sshgrid.com
├── public_html/                # served at https://<handle>.sshgrid.com
│   ├── index.php               # your site's entry point
│   ├── assets/                 # css, js, images
│   └── ...                     # whatever the agent (or you) builds here
├── data/                       # SQLite databases, config files, app state
├── uploads/                    # drop files here for the agent to read
├── logs/                       # apache access + error logs
├── backups/                    # automated backups (if enabled)
├── scripts/                    # agent-written helper scripts & cron jobs
├── .agent/                     # the agent's working memory
└── agent.md                    # extra instructions you want it to always honor

The agent treats this tree as the only world it has. When you back up ~/, you've backed up your entire SSHGrid universe.

Chat workspace tabs

The chat UI has tabs across the top. Each one is a different lens on the same Linux home.

Journal & Scheduler

Journal — what the agent did, day by day

As the agent builds and fixes things, it keeps a short daily log of what changed and why. The Journal tab shows it as a calendar: days with an entry are highlighted, and clicking one opens that day's write-up — in plain language, with clickable links to whatever it shipped.

Entries live as Markdown in ~/.agent/journal/<date>.md, so you can also read or back them up over SSH. Ask the agent to "write up what you did today" and it'll add to that day's entry.

Scheduler — your recurring (cron) jobs

Whenever the agent sets up something recurring — a nightly backup, a polling script, a weekly report — it writes a normal crontab entry. The Scheduler tab lists those jobs in plain English alongside the exact command and cron expression.

To add, change, or remove a job, just ask in chat — e.g. "every morning at 7am, back up my database to ~/backups". Raw truth is always available over SSH with crontab -l.

What people build with it

Anything that's a few PHP files, HTML pages, or SQLite tables away from being useful. Copy the block below into chat to get started, or remix the prompts.

# Marketing sites
› build me a one-page landing site for my consultancy, dark mode, with a contact form
› drop the photos in ~/uploads/portfolio/ into a Pinterest-style grid
› import the markdown files in ~/uploads/blog/ as a tiny PHP blog with RSS

# Web apps with SQLite
› build a CRM for tracking 50ish freelance clients — name, email, notes, last contacted
› wire up a support inbox — email comes in, lands in a SQLite table, I reply from a private dashboard
› a Stripe-payments donation page that records every donation in donations.db

# Internal tools
› a daily-standup page where each team member posts a short update — auth via magic link
› a feature-flag toggle UI backed by a JSON file my other apps can poll

# Housekeeping
› tail my apache error log and tell me what broke on /products
› nightly backup of ~/data to ~/backups with 14 days of retention

SSH & SFTP

You don't have to use the agent for everything. Edit by hand, sync with rsync, or wire up your local editor — same files, same live site.

ssh    your-handle.sshgrid.com@51.222.16.250
sftp   your-handle.sshgrid.com@51.222.16.250
rsync  -avz ./site/ your-handle.sshgrid.com@51.222.16.250:~/public_html/

SSH keys — add your public key in the Settings tab (or /account). Recommended for daily use.

Password auth — optional, toggled in Settings. Uses the same password as your SSHGrid account. Handy for SFTP clients that don't support keys.

Works with rsync, scp, Transmit, Cyberduck, and any SFTP-aware tool. The agent and your edits coexist — you're both writing into the same files.

Connect your editor or your own agent

Because it's a normal SSH account, point Cursor, VS Code, or your own CLI agent straight at ~/ and work alongside the SSHGrid agent.

Cursor / VS Code (Remote-SSH)

Add a host block to your local ~/.ssh/config:

Host sshgrid
    HostName 51.222.16.250
    User your-handle.sshgrid.com
    IdentityFile ~/.ssh/id_ed25519

• Cursor: Command Palette (Cmd/Ctrl+Shift+P) → Remote-SSH: Connect to Host… → pick sshgrid. Open ~ as the workspace folder.
• VS Code: same flow — install the Remote - SSH extension first.

Cursor's agent (or Copilot) reads and writes the same ~/public_html/, ~/data/, and ~/scripts/ as the SSHGrid agent. Save in the editor and it's live on the next request.

Point your own CLI agent at it

# run a single command remotely
ssh sshgrid 'cd ~/public_html && php -l index.php'

# open a shell for an interactive CLI agent to drive
ssh sshgrid

• Same files, live. No staging copy — treat it like editing production.
• Stay in ~/. Your account cannot reach /etc, other users, or sudo.
• Cron is shared. Tag your jobs with # sg-user:<handle> so they appear in the Scheduler tab.

Paste this to your agent

Onboarding a new project or switching to a different AI tool? Drop this block into chat or your system prompt so the model knows how your box works on the first try.

I'm building on SSHGrid — a real Linux home directory with a persistent AI agent.

MY BOX:
- Home: ~/  (served at https://<my-handle>.sshgrid.com)
- Web root: ~/public_html/
- Databases: ~/data/*.db (SQLite files)
- Uploads for you to read: ~/uploads/
- Logs: ~/logs/
- Default stack: PHP 8.3 + SQLite + Tailwind CSS (CDN) — no build step
- Apache runs as my UID; saving a PHP file makes it live immediately

WHAT YOU CAN DO:
- Read/write any file under ~/
- Run bash commands (git, curl, sqlite3, composer, npm, ffmpeg, etc.)
- Schedule cron jobs (scripts go in ~/scripts/)
- Add custom domains + SSL via the spool
- Pin standing instructions in the Context tab (~/.agent/user-context.md)

SSH ACCESS (same files you edit):
  ssh <handle>.sshgrid.com@51.222.16.250
  Keys in Settings tab; password auth optional (same as account password)

CONVENTIONS:
- End browser-visible work with a clickable Markdown link to the live URL
- One dispatch = one message from me; tool calls are included
- Agent finishes with DONE or WAITING_FOR_CUSTOMER
- Docs: https://sshgrid.com/docs  ·  Temp deploy API: https://sshgrid.com/api

Dispatches & quotas

One dispatch = one message you send the agent. Every tool call in the response counts as part of that same dispatch.

The agent ends each turn with a status marker:

DONE                    # task complete, dispatch closed
WAITING_FOR_CUSTOMER    # needs your input (e.g. DNS hasn't propagated)

What we don't do (yet)

• MySQL / Postgres — SQLite only at this tier. Point at managed Postgres elsewhere and the agent can wire it up.
• Long-running workers — no systemd --user. Use cron for scheduled tasks.
• Outbound email — bring your own SendGrid, Postmark, or Resend key.
• Multi-region — one box, one home directory, one URL.
• Team accounts — one human per subscription, for now.

Where to get help

If something goes sideways, ask the agent first — it can read its own logs and usually fixes itself. For a human:

• Email hello@sshgrid.com
• Standard & Studio plans get priority response within 24h
• Deploy API questions: /api docs + OpenAPI spec