Agent code needs somewhere disposable to run, and Sandstorm turns one modest VPS into a fleet of thousands of isolated sandboxes that wake the moment work arrives. You create sandboxes through a plain HTTP API, starting from a registered template or forking a tagged snapshot, with per-sandbox memory ceilings, attached volumes, and egress rules set on each call. Every sandbox is a gVisor container with its own network namespace, so untrusted agent code runs away from your host and away from its neighbors. Idle sandboxes cool down through four tiers, from running hot, to frozen in place with a wake time near ten milliseconds, to checkpointed on disk and back in about a fifth of a second, so a small machine can hold far more sandboxes than it could ever keep running at once. A single binary acts as master, node, and web console: the master tracks desired state and places work across nodes, nodes behind NAT dial out to join the fleet, and a gateway on each node wakes a sleeping sandbox and forwards its traffic automatically. The built-in Hub pulls ready-made snapshot packs for warmed runtimes like Python with numpy or a pre-warmed Playwright browser, skipping cold starts entirely. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

Containarium gives every AI agent a persistent Linux box of its own, reachable over SSH and driven through structured tools instead of a fragile terminal session. One command creates a named sandbox, syncs the SSH configuration, and wires the box into Claude Code, Codex, Gemini or Cursor through an MCP server that runs inside the container. From there the agent can execute shell commands, read and write files, install services, and expose a port on a public hostname with TLS terminated by a Caddy sentinel. Detached code runs keep working after a laptop sleeps or a connection drops, and the operator reattaches to the same byte-exact log later, checks status, or stops the run without losing output. An optional per-tenant eBPF egress policy limits outbound traffic per box, logs denied attempts for audit, and keeps provider API keys inside a model gateway rather than inside the agent environment. Boxes run on LXC or Kubernetes, keep state between agent sessions, support GPU passthrough for local model work, and stay separate from the host operating system and the cluster control plane. The dashboard presents containers, traffic, security events, audit records, GPU state and monitoring in one place. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

CubeSandbox gives every AI agent its own hardware-isolated MicroVM with a dedicated Linux kernel — not a shared-kernel container but a true KVM virtual machine — booting in under 60ms with less than 5MB of memory overhead per instance, enabling thousands of concurrent sandboxes on a single server via kernel sharing and Copy-on-Write memory. The Rust-built CubeProxy exposes an E2B SDK-compatible REST API on Axum, so existing E2B Cloud applications switch by changing one environment variable with zero client code changes. CubeMaster orchestrates cluster-level scheduling in Go while Cubelet manages node-local sandbox lifecycles including create, run, pause, resume, snapshot, and destroy operations. CubeVS, the eBPF-powered network layer, enforces per-sandbox isolation with LPM trie-based egress policies entirely in kernel space — no userspace context switches — while CubeEgress provides an L7 security proxy with per-domain, per-path, and per-method allowlists plus automatic credential injection that keeps secrets invisible to sandbox code. Hundred-millisecond-granularity snapshots enable checkpoint, rollback, and parallel fork from any saved state. The volume framework supports E2B-compatible pluggable storage with independent lifecycle and cross-sandbox sharing. Production deployment uses Terraform on Tencent Cloud or Helm charts on Kubernetes, K3s, or TKE, with full ARM64 support alongside x86_64 and AutoPause/AutoResume for cost optimization. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

Judge0 is a code execution service that takes source code over a simple HTTP API, compiles and runs it inside a locked-down sandbox, and hands back exactly what the program printed, how long it took, and how much memory it used. Send a snippet in any of more than 90 languages, from Python, JavaScript, Rust, and Go to C, Java, and Haskell, and pick the compiler or interpreter variant you need. Each run accepts standard input, command-line arguments, and custom compiler flags, then reports standard output, errors, and a precise verdict covering accepted, wrong answer, time limit, compilation error, or runtime failure. Per-submission controls cap CPU time, memory, stack size, and output file size, so a fork bomb or an infinite loop dies inside its fence instead of disturbing the host. Submissions run one at a time or in batches, and a synchronous mode answers in the same request for snippets that finish fast. Webhooks call your application the moment a long job completes, which keeps polling loops out of worker queues and classrooms alike. Coding platforms grade student work with it, hiring tools run candidate solutions against hidden tests, and AI agents execute the code they generate before trusting it. Official Python and JavaScript SDKs wrap the raw requests, so most integrations shrink to choosing a language and reading the result fields. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. GPL-3.0 licensed.

E2A is an open-source email API that lets any application send transactional email and gives AI agents real two-way inboxes of their own, so an assistant can hold a conversation over email without borrowing a person's mailbox. Register an agent and it gets a working address on a shared domain in seconds, or verify your own domain for branded addresses, then connect through the hosted MCP server, a coding-agent plugin with browser OAuth, signed webhooks, a WebSocket stream, REST polling, or the TypeScript and Python SDKs. A local agent behind a firewall needs no public URL at all: it listens over WebSocket and replies in-thread with conversation identifiers keeping multi-turn exchanges coherent across humans and other agents. Every inbound message arrives with structured SPF, DKIM, and DMARC evidence, with the DMARC alignment verdict included, so your agent can judge how far to trust a sender instead of trusting the From header. Flip on the human-in-the-loop gate per agent and outbound messages pause for a person to approve, edit, or reject from the dashboard, the SDK, MCP tools, or magic links in their own inbox, with expiry rules and recipient allowlists narrowing which sends get held. Inbound content screening flags prompt-injection payloads before the agent ever sees them. Support bots triage intake, scheduling agents coordinate meetings, and commerce agents answer order questions from one persistent address. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

WebCodex gives ChatGPT, Claude, and other MCP clients a real development environment on machines you own, so an AI assistant can edit your actual repositories instead of a pasted snapshot. A self-hosted Server authenticates every request and routes it to a Runner sitting next to your code, where file edits, Git operations, test runs, shell commands, and long jobs execute with your real toolchain. Your projects never move into a hosted workspace; only the tool results you authorize travel back to the model. The browser Runtime Console shows project readiness, the work queue, session activity, and connected Runners, and it is where you decide pending approvals or accept and reject finished work, because the model cannot approve its own changes. Runners join with a short-lived pairing code and stay connected over QUIC, WebSocket, or polling, so machines behind NAT still work. One-command sharing opens a temporary session for a single repository, while durable setups run the Server and Runner as system services behind your own HTTPS domain. Workflow Sessions keep evidence and context across conversations, so long tasks survive closed browser tabs and threads you pick up days later. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

Running AI agents in production takes more than a model call: Omnara supplies the durable runtime, tools, approvals, and complete event history around any model, on your own machines. You define an agent once in a small YAML file: instructions, a model from OpenAI, Anthropic, OpenRouter, Bedrock, LiteLLM, Ollama, or your own endpoint, and the machines it may use. Launch agents from the REST API, the TypeScript SDK, the command line, or the dashboard, then stream every event live or receive it as a webhook while the agent works. Agents run shell commands and edit files on sandboxes from twelve providers, or on your own laptops, VMs, and containers through a daemon that connects outward, so no inbound ports or SSH keys are exposed. Every step is written to Postgres as an event log, which means an agent survives crashes, restarts, and disconnected machines and resumes exactly where it stopped. Tool permissions can run immediately, ask a person first, or block outright, and agents can start subagents, follow cron schedules, and keep shared memory files between conversations. Teams meet the agents where they already talk: mention the bot in Slack or Discord, or let a GitHub pull request trigger a review, with questions and approvals handled in the thread. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

OpenMA lets you build and run AI agents with the model, harness, and sandbox you choose, on infrastructure you control, while it handles the sessions, execution, and recovery around them. Create an agent in the console, give it work, and come back later to the same session, because conversation history, streamed progress, and execution attempts are preserved rather than tied to one process that might die. Agents start with shell, file, web, and browser tools, then grow through MCP services and reusable Skills, while resources such as GitHub repositories, uploaded files, and shared memory attach to the work that needs them. Deployments run agents manually or on schedules you define, environments carry their own networking and package configuration, and model cards keep provider settings in one place instead of scattered environment files. If a sandbox fails, the session survives it; a replacement harness can rebuild context from durable events and workspace checkpoints. Operate everything through the console, the API, or the CLI, and plug in the database, queue, and object storage your deployment already trusts. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

AgentBox is a self-hosted browser workspace that runs Claude Code and Codex CLI on a server you control, so a task goes from chat to reviewed code without leaving one place. Open a workspace from an empty project, an uploaded archive, or a Git clone, then talk to the agent in streaming web chat or drop into its original interactive terminal when you want the CLI itself. Files persist between sessions along with your home configuration and chat history, so a project picked up on a laptop continues on a phone exactly where it stopped. Review per-file diffs line by line before committing, pushing, or opening a pull request, and download the result when no Git connection is configured. Shared files, layered home templates, Claude skills, and MCP configuration carry your setup into every new workspace, with per-workspace overrides when a project differs. A trusted team shares central account pools with per-user scopes, while every model request is recorded with tokens, cache hit rate, cost, and latency, exportable to CSV and optionally capped by credits. An optional tunnel reaches allowlisted repositories and databases on private networks, and six interface styles with light and dark modes keep long sessions comfortable. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

AgentDock turns the computers and servers you already run into machines an AI assistant can operate for you through one secure MCP endpoint. Connect ChatGPT, Claude, Codex, or any other MCP client and the agent works in the real environment: reading and writing files, searching code, running shell commands, and driving Git where the project actually lives. Long jobs survive interruptions because task state and checkpoints persist on the node, ready to resume where they stopped. Browser work is covered as well, with web pages driven through a native Chrome DevTools connection that reuses your logged-in sessions, captures screenshots, and can even operate macOS desktop applications. Capabilities grow through installable Skills and dynamic MCP servers, so a node picks up new tools without a rebuild. Run a single node on a laptop, or spread nodes across VPS hosts and containers and pair them with the optional NexusDock console for one fleet view, shared Recall memory, reusable workflow templates, and a single MCP address for every machine. Access stays locked down with Bearer tokens or OAuth sign-in, loopback-only defaults, and optional Cloudflare Tunnel or HTTPS exposure when a remote client needs a way in. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

One endpoint for every MCP server you run: MCPHub gathers local and remote Model Context Protocol servers behind stable URLs, so AI clients connect once and see what you allow. Claude Code, Cursor, and Cherry Studio can use four routes: everything at /mcp, a named group at /mcp/{group}, one server at /mcp/{server}, or semantic tool search at /mcp/$smart. Smart routing runs vector search on PostgreSQL with pgvector and an OpenAI-compatible key, so the model gets a shorter tool list. Servers attach over stdio, SSE, or streamable HTTP, OpenAPI services can be wrapped as MCP tools, and changes apply without downtime. In the other direction, MCP tools can be exported as an OpenAPI 3.0.3 spec for OpenWebUI and other OpenAPI clients. Bearer keys, OAuth 2.0 (client and server modes), and GitHub or Google sign-in in database mode control access, with per-user visibility for servers and groups. Encrypted per-user credentials let one shared server use each person's own key. Logs show tool-call activity, request status, and latency, health checks track each connection, and the dashboard controls which tools, prompts, and resources each server exposes. Large text tool results can be compressed, interactive MCP Apps are proxied through MCPHub routes, and a built-in market lets you browse a server catalog. Typical uses include a team-wide gateway, per-project groups, and direct single-server routes for debugging. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

Archestra delivers the enterprise AI infrastructure layer that organizations need when managing multiple LLM providers, MCP servers, and AI agents across teams becomes unmanageable. The LLM gateway routes requests across Anthropic, OpenAI, Azure, Bedrock, and DeepSeek with virtual API keys, per-team cost limits, and dynamic model routing — giving every developer one token for Claude Code, Cursor, or Codex while finance tracks spend per department. The MCP gateway authenticates tool calls with OAuth 2.1 and On-Behalf-Of tokens so each tool executes as the calling user, not a shared service account, eliminating credential sprawl. The private MCP registry lets teams publish custom tool servers with approval flows promoting servers from dev through staging to production, each environment maintaining its own credentials and network egress policies. The Kubernetes operator manages MCP server lifecycle — deploying containers, scaling, health-checking, and routing gateway traffic to local servers automatically. The agent runtime supports scheduled triggers, email and webhook invocations, sub-agent delegation, reusable skills, and sandboxed code execution with a K8s-native filesystem. Deterministic guardrails including Dual-LLM verification and Lethal Trifecta protections prevent dangerous tool calls before execution. Built-in OpenTelemetry traces and Prometheus metrics provide full observability without additional tooling. Docker deployment exposes the Admin UI on port 3000 and API on port 9000 with a single command. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. AGPL-3.0 licensed.

Deploy autonomous conversational AI agents and coordinate complex multi-agent workflows through EDDI, an open-source orchestration middleware that turns declarative configuration files into secure, production-grade enterprise assistants. Engineering teams connect AI models from twelve different commercial and local providers, using bilateral Model Context Protocol tools to let external desktop clients and coding assistants interact directly with running conversational services. Autonomous agents collaborate through structured group interaction patterns including round table discussions, peer reviews, Delphi consensus rounds, and devil's advocate debates to refine generated solutions before delivery. Declarative workflow extensions automate external REST API calls with dynamic request templating, extracting structured properties into persistent conversation memory and chaining multi-step service interactions without custom script glue. Built-in secret vaults safely manage sensitive API credentials, while the centralized web dashboard provides live conversation inspection, token quota enforcement, and comprehensive audit logging for regulatory compliance. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

Building LangGraph agents in code means imagining the graph; LangGraph GUI turns that graph into something you draw, wire, and run from the browser instead. You place a start node, add step nodes, and drag edges between ports to define the flow, with cycles created by simply connecting nodes back toward each other. Condition nodes split execution into green true paths and red false paths, info nodes append context to stage output, and subgraph nodes run a whole named graph inside another one. Tool steps call real Python functions that you define in tool nodes with the familiar decorator style, so file saving, lookups, and custom logic sit inside the visual flow. Graphs save to JSON on your computer, load back for editing, and upload to the server as workflow files ready to execute. You configure which LLM to use and its API key in the panel, run against local models through Ollama or hosted APIs, then download every file the run produced in the workspace. Files upload to the server workspace as working environment, and a cache clean clears it between runs. Example graphs for role-playing loops, lottery branch switches, and tool-using flows show patterns you can copy and refine with your own prompts. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

When an AI agent goes wrong at step seven of twelve, Opik, an open-source LLM observability platform, shows the exact trace, tool call, and prompt behind it, then scores your fix against test datasets. Full trace trees capture every LLM call, retrieval step, and tool execution, and you can annotate traces and spans with feedback scores in the UI or through the SDK. Native integrations for OpenAI, Anthropic, LangChain, LlamaIndex, CrewAI, Google ADK, and DSPy, plus OpenTelemetry for any language with an OpenTelemetry SDK, feed traces in, or add the @track decorator to your own functions. Datasets and experiments compare prompt and model versions, scored by LLM-as-a-judge metrics for hallucination, moderation, and RAG relevance, with a PyTest integration to run evaluations in CI. A Prompt Playground tests prompts across models, and the Agent Optimizer SDK helps improve prompts and agents. Production dashboards track feedback scores, trace counts, and token usage, online evaluation rules score live traces, and optional guardrails add safety checks. An MCP server lets Claude Code, Cursor, VS Code Copilot, Codex, or opencode read traces and run evaluations from chat. Run it yourself with the ./opik.sh script on Docker Compose, or a Helm chart on Kubernetes, so trace data stays in your infrastructure. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.