Developers

Agent servers with sandbox-grade isolation

Persistent Linux servers for AI agents. Run code, manage files, use the terminal, and publish project URLs when ready. Connect over MCP in one config line, or delegate end-to-end with prompt().

View docs

Coding agentsBackground automationsDeep researchData analysisMCP tool serversDeployed apps

srv_2k9 · running

LIVE

exec()

Tier

medium

Workspace

12.4 / 20 GB

Projects

4 / 10

execread_filewrite_filepromptdeploy

How it works

From MCP config to live URL in four steps

Same mental model as sandbox SDKs: connect, provision, run code, extract results. We add persistence, templates, and optional staffed delivery.

Tool surface

exec()write_file()prompt()deploy()

01

MCP host

assistant · IDE · your loop

02

Server

Isolated Linux + volume

03

Projects

Workspaces + git

04Live

Public URL

*.apps.server4agent.com

01

Connect your agent

Add one MCP config entry or call the REST API with a scoped API key. Works with IDE agents, assistant connectors, LangChain, or any tool-calling loop.

02

Provision a server

Create an isolated Linux server sized for your workload. Add projects from a template or start blank. Secrets inject as env vars.

03

Run work in the sandbox

Drive exec, read_file, and write_file yourself, or hand off with prompt(). Install packages, use git, run tests, iterate until done.

04

Ship or extract results

Deploy to a project URL, pull stdout and artifacts, or subscribe to webhooks. Persistent projects resume where the last session left off.

Use cases

Built for AI agents, MCP hosts, and agentic workflows

The same categories teams run on sandbox infrastructure, plus a staffed build agent when you want a finished URL back.

Coding agents

Your agent drives the primitives directly: provision a server, write code, run commands, iterate on errors, deploy when ready. Same surface as a sandbox SDK, exposed as MCP tools.

execwrite_fileread_filedeploy

Building blocks

Sandbox primitives + staffed delivery

Learn five concepts and you understand the whole surface.

Server

Isolated Linux compute. Sized small, medium, or large. Persistent volume, scale-to-zero idle, wake on demand.

Project

Workspace per app or job. Public or private URL, persistent or ephemeral lifecycle, git-backed files.

Sandbox primitives

exec, read_file, write_file, list_files. Install packages, use the terminal, run any stack your agent needs.

Template

Starter catalog via list_templates. Pre-fills visibility, lifecycle, and description for the flagship alerts, monitors, pages, watchers, and cleanup portals.

prompt()

Optional staffed path. Send a goal; the build agent plans, writes, runs, and ships without your loop driving every step.

Templates

Starter projects, not blank slates every time

Like custom sandbox images, but opinionated for real deliverables: landing pages, APIs, monitors, and standing automations.

Webhook to Slack lead alert

Catch events, save them, alert the team

persistent · private

URL uptime monitor

Scheduled checks with a status page

persistent · public

Landing page + waitlist

Public page with email capture

persistent · public

Price/job watcher

Watch external pages for changes

persistent · private

CSV cleanup portal

Upload, clean, dedupe, export

persistent · private

Invoice & quote maker

Generate numbered invoices and quotes as PDFs

persistent · private

REST API

A JSON API server

persistent · private

Data pipeline

One-shot ETL or processing job

ephemeral · private

Web scraper

One-shot scraping task

ephemeral · private

Dashboard

Live admin or analytics view

persistent · public

Invoice processor

Read invoices, push to your books

persistent · private

CRM sync

Enrich + dedupe leads into your CRM

persistent · private

Report digest

Scheduled report, pulled and emailed

persistent · private

Flight fare watcher

Track fares, alert on price drops

persistent · private

Job listing watcher

Watch listings, ping on new matches

persistent · private

Wishlist price monitor

Watch products, ping when they fall

persistent · private

Telescope deal watcher

Track gear prices, alert on real deals

persistent · public

One server hosts many projects. Templates pre-fill visibility, lifecycle, and description via list_templates.

Template reference

Get started

Write files, run code, ship a URL

Your agent writes real source files, installs dependencies, and runs them over MCP, REST, or its own tool-calling loop. No Server4Agent SDK required on the outer side.

Assistant connectorsIDE agentsLangChainLangGraphAny MCP hostRaw HTTP

Diagram: MCP host connects to an isolated server and deploys to a project URL

Need help? Read the quickstart, browse examples, or email hello@server4agent.com.

MCP: https://mcp.server4agent.com
REST: https://api.server4agent.com

mcp.config.json

{
  "mcpServers": {
    "server4agent": {
      "url": "https://mcp.server4agent.com",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

fastapi-app.ts

// Primitives: your agent writes real files, installs, and runs them
await mcp.call_tool("create_server", { tier: "medium" })
// → { id: "srv_2k9", url: null }

// A multi-file FastAPI service
await mcp.call_tool("write_file", {
  server_id: "srv_2k9",
  path: "app/main.py",
  content: `from fastapi import FastAPI

app = FastAPI()

@app.get("/health")
def health():
    return {"status": "ok"}

@app.get("/price/{symbol}")
def price(symbol: str):
    return {"symbol": symbol.upper(), "usd": 42.0}
`,
})

await mcp.call_tool("write_file", {
  server_id: "srv_2k9",
  path: "requirements.txt",
  content: "fastapi\nuvicorn[standard]\n",
})

await mcp.call_tool("exec", {
  server_id: "srv_2k9",
  command: "pip install -r requirements.txt && uvicorn app.main:app --port 8080",
})
// → { stdout: "Uvicorn running on http://0.0.0.0:8080" }

static-site.ts

// Create a public project, write a page, ship it to a live URL
await mcp.call_tool("create_project", {
  server_id: "srv_2k9",
  name: "launch-page",
  visibility: "public",
})
// → { id: "prj_88c", url: "https://launch-page.apps.server4agent.com" }

await mcp.call_tool("write_file", {
  server_id: "srv_2k9",
  path: "public/index.html",
  content: `<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>Northstar Labs</title>
  </head>
  <body style="font-family: system-ui; text-align: center; padding: 4rem">
    <h1>Launching soon</h1>
    <p>Built and deployed by an agent.</p>
  </body>
</html>
`,
})

await mcp.call_tool("deploy", { server_id: "srv_2k9" })
// → { url: "https://launch-page.apps.server4agent.com", status: "live" }

node-script.ts

// Node: write package.json + a script, install deps, run it
await mcp.call_tool("write_file", {
  server_id: "srv_2k9",
  path: "package.json",
  content: `{
  "name": "stars",
  "type": "module",
  "dependencies": { "node-fetch": "^3" }
}
`,
})

await mcp.call_tool("write_file", {
  server_id: "srv_2k9",
  path: "index.js",
  content: `import fetch from "node-fetch";

const res = await fetch("https://api.github.com/repos/vercel/next.js");
const repo = await res.json();
console.log("stars:", repo.stargazers_count);
`,
})

await mcp.call_tool("exec", { server_id: "srv_2k9", command: "npm install" })
await mcp.call_tool("exec", { server_id: "srv_2k9", command: "node index.js" })
// → { stdout: "stars: 124000" }

delegation.ts

// Staffed path: one goal, full delivery
await mcp.call_tool("create_server", {})
await mcp.call_tool("prompt", {
  server_id: "srv_2k9",
  prompt: "Build a Slack bot that posts yesterday's Stripe revenue every morning. Deploy it."
})
// → { run_id: "run_71a", status: "running" }
// Build agent writes, installs, schedules, ships.
// Poll the run or subscribe to deployment.live.

curl

# Provision a server
curl -X POST https://api.server4agent.com/servers \
  -H "Authorization: Bearer $SERVER4AGENT_API_KEY"
# → { "id": "srv_2k9", "url": null, "status": "running", "tier": "small" }

# Write a file into the workspace
curl -X PUT https://api.server4agent.com/servers/srv_2k9/files \
  -H "Authorization: Bearer $SERVER4AGENT_API_KEY" \
  -d '{ "path": "main.py", "content": "print(\"hello from REST\")" }'

# Run it
curl -X POST https://api.server4agent.com/servers/srv_2k9/exec \
  -H "Authorization: Bearer $SERVER4AGENT_API_KEY" \
  -d '{ "command": "python main.py" }'

agent.py

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client("https://mcp.server4agent.com", headers=HEADERS) as (r, w, _):
    async with ClientSession(r, w) as mcp:
        await mcp.initialize()
        tools = (await mcp.list_tools()).tools
        # Standard tool-calling loop: your LLM picks exec, prompt, deploy, …
        result = await mcp.call_tool("prompt", {
            "server_id": "srv_2k9",
            "prompt": "Build a status page and deploy it.",
        })

Features

Features your agents will love

Real-world tools for agentic workflows: isolation, persistence, shell access, and a path to production URLs.

Works with any MCP host

Assistant connectors, IDE agents, LangChain, LangGraph, or your own tool-calling loop. One JSON config entry.

Persistent, not per-call

Servers keep workspace state between tasks. Pick up where the last session left off instead of cold-starting every run.

Run anything on Linux

Python, Node, Go, Rust, shell scripts, cron. If it runs in a container, your agent can run it here.

Secure & isolated

Each server is tenant-scoped. Agent-generated code runs in sandboxed compute with secrets injected as env vars.

Long-running work

Persistent projects for monitors and bots. Ephemeral projects for one-shot pipelines you clean up when done.

Ship to a stable URL

Deploy to *.apps.server4agent.com with managed TLS when visibility is public. The deliverable is an addressable app, not just stdout.

Illustration of tenant-scoped server isolation with nested project workspaces

Isometric illustration of a server hosting multiple sandbox projects with a public deploy target

Use terminal

exec any command

Git history

per-project commits

Budget caps

account-wide, set by you

MCP tools

Full tool surface

Sandbox-style primitives and higher-level build tools on one server.

Lifecycle

create_server
list_servers
get_server
get_usage
update_server
control_server
delete_server

Projects

list_templates
create_project
list_projects
get_project
update_project
cleanup_project
delete_project

Build

prompt
start_build
get_build
deploy

Primitives

exec
list_files
read_file
write_file
delete_file

MCP reference SDKs REST API Webhooks llms-full.txt

Cookbook

Get inspired by our examples

Production-shaped patterns for MCP hosts, REST clients, and autonomous agents. Filter by language or integration style.

Language / host

Pattern

32 examples

Connect Cursor over MCP

New

Example · Docs

Full agent loop in Python

Example · Docs

Generic tool-calling loop in TypeScript

Example · Docs

LangChain + MCP tools

Example · Docs

LangGraph + MCP tools

Example · Docs

ChatGPT MCP connector setup

Example · Docs

Hand off a goal with prompt()

Example · Docs

Slack revenue bot via prompt()

Example · Docs

Write and run a Python function

Example · Docs

Write and run code in TypeScript

Example · Docs

Run a data script with exec

Example · Docs

Build and deploy a Next.js app

Example · Docs

All docs examples Browse showcase

Compare

Sandbox SDK vs staffed agent servers

We cover the same ground as ephemeral sandboxes, then add persistence, MCP-native tools, and optional full delivery via prompt().

Sandbox SDK

Server4Agent

Core unit

Ephemeral VM per call

Persistent server + projects

Code execution

runCode / exec in your SDK

exec MCP tool + full shell

Typical output

stdout, files, charts in memory

stdout + optional project URL

Who ships the app

Your agent orchestrates

Your agent or our build agent via prompt()

Integration

Language SDK

MCP + REST + webhooks

Spend control

Per invocation metering

Account-wide cap, set by the owner

Starter environments

Custom sandbox templates (Docker)

17 list_templates starters

State between runs

Pause and resume sandboxes

Persistent servers + project git history

Git workflow

Clone repos, push from sandbox

Per-project commits in the dashboard

Delivery signals

SDK polling for run status

10 webhook events (build, deploy, budget)

Many teams use a sandbox for quick code execution and Server4Agent when the deliverable is a deployed app, a standing automation, or a project engineers will take over. See the manager-facing story.

Documentation

Quickstart, MCP tools, REST API, webhooks, and worked examples.

Browse docs

SDKs

Typed Python, TypeScript, and Go clients for the code around your agent: backend, CI, and webhooks.

Explore SDKs

API reference

Provision servers, run tasks, manage files, deploy, subscribe to events.

View API

LLM context

Machine-readable product summary for assistants and codegen tools.

llms-full.txt

Get started today

Persistent agent servers with real-world tools. Connect over MCP and ship your first project URL.

Sandbox primitives: exec, files, shell, deploy
Staffed path: prompt() for end-to-end delivery
Account-wide budget cap your agent cannot override

View docs

Agent servers with sandbox-grade isolation

From MCP config to live URL in four steps

MCP host

Server

Projects

Public URL

Connect your agent

Provision a server

Run work in the sandbox

Ship or extract results

Built for AI agents, MCP hosts, and agentic workflows

Coding agents

Agent delegation

Deep research agents

Data analysis & viz

Background automations

Vibe coding & apps

Secure MCP servers

Public deploy surface

Sandbox primitives + staffed delivery

Server

Project

Sandbox primitives

Template

prompt()

Starter projects, not blank slates every time

Webhook to Slack lead alert

URL uptime monitor

Landing page + waitlist

Price/job watcher

CSV cleanup portal

Invoice & quote maker

REST API

Data pipeline

Web scraper

Dashboard

Invoice processor

CRM sync

Report digest

Flight fare watcher

Job listing watcher

Wishlist price monitor

Telescope deal watcher

Write files, run code, ship a URL

Features your agents will love

Works with any MCP host

Persistent, not per-call

Run anything on Linux

Secure & isolated

Long-running work

Ship to a stable URL

Full tool surface

Lifecycle

Projects

Build

Primitives

Get inspired by our examples

Connect Cursor over MCP

Full agent loop in Python

Generic tool-calling loop in TypeScript

LangChain + MCP tools

LangGraph + MCP tools

ChatGPT MCP connector setup

Hand off a goal with prompt()

Slack revenue bot via prompt()

Write and run a Python function

Write and run code in TypeScript

Run a data script with exec

Build and deploy a Next.js app

Sandbox SDK vs staffed agent servers

Documentation

SDKs

API reference

LLM context

Get started today