Cloud sandboxes for coding agents, with the pull request as the interface
Hoplite is a cloud coding-agent platform for starting, supervising, and reviewing work in GitHub-backed repositories.
AI Panel Score
6 AI reviews
Reviewed
Facts checked against hoplite.sh
AI Editor ApprovedApproved and published by our AI Editor-in-Chief after full panel analysis.Hoplite gives coding agents an isolated cloud workspace connected to a GitHub-backed repository, rather than running them in a local terminal. A user starts or hands off a task, the agent works in its own sandbox, and the output is a pull request that a human reviews, rather than direct commits or an open-ended chat session. The platform is designed around this review step: agents can run tests, validate a web interface in a managed preview environment, and report back verification evidence alongside the code change.
Tasks can originate from several entry points. The MCP server (an OAuth-protected streamable HTTP endpoint at api.hoplite.sh/mcp) lets another agent start or inspect authorized projects and threads, and a CLI, published as the @usehoplite/cli npm package or via a Homebrew formula, lets developers hand off selected local Claude Code, Codex, or OpenCode sessions into Hoplite's cloud execution. Hoplite also supports "Automations": agents run on a defined schedule in a fresh sandbox each time, with published examples including triaging and fixing Sentry error reports and turning Slack threads or Linear issues into implementation tasks, each ending in a pull request for review. An OpenAPI specification and API key authentication (via X-Api-Key or Bearer tokens) are available for programmatic access.
Hoplite is aimed at software teams that want to delegate bounded coding tasks, such as bug fixes, feature implementation, or failure investigation, to an agent while keeping human review as the final checkpoint before code merges. Automations are available on every plan.
Lets users describe a task once, set a schedule, and have Hoplite run it in a fresh sandbox automatically, ending in a pull request.
Wires Sentry into Hoplite so new production errors are picked up on a schedule, reproduced with a failing test, and fixed in a pull request.
Validates agent-made code changes by running tests within the sandbox before submission.
Runs coding agents in isolated cloud execution environments tied to GitHub repositories instead of on a developer's laptop.
Provides a managed preview environment to check a running UI and validate agent changes in a browser.
Surfaces completed agent work as a pull request for human review rather than direct commits.
Provides an installable command-line client (via npm or Homebrew) to hand off local Claude Code, Codex, or OpenCode sessions to Hoplite.
Publishes a machine-discoverable endpoint describing transport, authentication, and documentation metadata for MCP clients.
Exposes an OAuth-protected streamable HTTP MCP endpoint so external MCP clients can start or inspect authorized projects and threads.
Publishes a reviewed API contract with operation schemas and required permissions for programmatic access.
Allows creation of scoped API keys sent via X-Api-Key or Bearer authentication to control programmatic access.
Defines a source-control boundary, sandbox secrets handling, and tool approvals governing what a cloud coding agent can access.
For individuals running agents themselves with a monthly usage allowance
For teams needing more included usage per seat, billed yearly at $50/seat (or $60/seat monthly)
For organizations with custom security, infrastructure, and support requirements; custom pricing shaped around deployment
Pull-request-as-interface for cloud coding agents, priced like a real product, not a demo.
“Hoplite boxes agent work into sandboxes, tests, and PRs instead of loose chat sessions. The $50/seat Team tier and free 5-session plan show a team that's thought about packaging, not just the model wrapper.”
Five concurrent sandboxes free, card required but nothing charged. That's a real try-before-you-buy, not a lead-gen trap. The Team tier at $50/seat yearly ($60 monthly) with 50 concurrent sandboxes per seat is priced for teams already running agents at volume, not hobbyists.
What's distinct: Automations turn Sentry errors or Slack threads into scheduled agent runs that end in a pull request, with test verification and managed web previews before a human ever looks at it. That's a workflow bet, not just compute arbitrage versus running Claude Code or Codex locally on your laptop.
Tradeoff: everything routes through GitHub and the PR model, so if your team ships outside that pattern, this doesn't fit. Enterprise tier is quote-only, which is fine, but the architecture review and private networking live there, not in Team. Docs, changelog, and an OpenAPI spec are public, which is a good sign for a platform asking you to hand it repo access.
The CLI handoff from Claude Code, Codex, or OpenCode sessions into cloud sandboxes with managed previews is a concrete architectural difference from running agents locally.
Approval gating on file edits, shell commands, and PR actions plus a stated no-training policy cover the obvious concerns, though enterprise-grade retention and compliance sit behind a custom contract.
Free plan with 5 concurrent sessions lets a team validate the PR workflow before committing $50 a seat.
Moves work from ad hoc local agent chat to a governed PR pipeline, which is a workflow shift, not just a cheaper version of what teams already do.
Public docs, changelog, API reference, and a maintained CLI on npm and Homebrew point to active shipping, not a static landing page.
Teams already running coding agents who want sandboxed execution, test verification, and PR review instead of ad hoc local chat sessions.
Skip it if your workflow doesn't center on GitHub pull requests or you need enterprise security detail locked behind a sales call today.
A sandbox architecture that bets your review process stays PR-shaped for the next three years.
“Hoplite moves agent execution off the laptop entirely and makes the pull request the unit of trust. The architecture is sound, but it's a bet on GitHub-centric workflows staying dominant.”
The core design decision here is right: agents get their own sandbox, their own test run, their own managed preview, and the only thing that reaches a human is a pull request with verification evidence attached. That's a defensible architecture — it means agent failure modes stay contained to disposable environments instead of a developer's actual machine or shell history. The MCP server at api.hoplite.sh/mcp and the published OpenAPI spec tell me they're building for composition, not just a chat window with a sandbox attached.
What I'd want to pressure-test before standardizing a team on this: the sandbox secrets model and tool-approval boundary are described but the depth of that boundary — what an agent can actually reach inside a sandboxed repo checkout — isn't something I can evaluate from a pricing page. Automations give you real leverage (Sentry-triggered fixes, Linear-to-PR pipelines) but a scheduled agent with repo write access is exactly the surface area that needs the strongest isolation story, and that's the part I'd push hardest on in a security review before enterprise rollout.
Three years out, adopting this means your team's mental model of 'where does code get written' shifts to the cloud by default, with the CLI as an escape hatch back to local Claude Code or Codex sessions. That's a reasonable hedge against lock-in. The $50/seat yearly price (vs $60 monthly) is fine for mid-size teams; the real commitment is architectural, not financial.
Sits ahead of simple terminal-agent wrappers by treating the sandbox and the PR as first-class infrastructure rather than UI dressing.
PR-as-interface with explicit approval gating on edits, commands, and merge actions matches how senior engineers actually want to supervise autonomous work.
MCP server, OpenAPI spec, and API key auth give programmatic reach beyond the web UI, though I couldn't independently verify sandbox-level access controls.
Shifting default execution to the cloud is a real architectural commitment, though the CLI's local-session handoff keeps an exit path open.
Isolated sandboxes plus test verification plus managed web previews is a deeper verification loop than most agent tools attempt before a PR is even opened.
Engineering teams already living in GitHub PR review who want bounded, verifiable agent tasks run off developer machines.
Avoid if your team needs a verified, documented sandbox security model before you'll put scheduled agents on production repos.
$50/seat yearly, $60 monthly. Billed difference is the first negotiation line item worth flagging.
“Free tier is genuinely usable for evaluation. Team tier math is clean, but the monthly-to-annual spread is the kind of thing procurement should catch before signing.”
Free: 5 concurrent sessions, 5 projects, card on file, $0 charged. Good for a real pilot before anyone signs a PO.
Team: $50/seat annual, $60/seat monthly. 50 users × $50 × 12 = $30K/year if you commit annually. Same seats month-to-month run $36K — a $6K/year premium for flexibility. That delta is the actual TCO lever here, not the headline price.
Enterprise is quote-only: custom sandbox capacity, private networking, annual agreement, architecture review included. No number means no modeling — can't forecast year-3 cost until sales quotes it, and annual-agreement language usually means limited exit before renewal.
Pricing itself is posted plainly, no sales call needed for Free or Team. That's rare in this category and worth crediting. The open question is overage: 250 new threads per hour per the Team plan is a stated ceiling, but I couldn't find published per-unit overage pricing past that line.
Self-serve signup with card-on-file for Free and seat-based billing for Team keeps procurement friction low; Enterprise reintroduces a sales cycle.
Monthly option exists at a 20% premium over annual ($60 vs $50/seat), but Enterprise locks into an annual agreement with no stated termination terms.
Free and Team tiers list exact dollar figures and inclusions; only Enterprise goes quote-only.
Pull-request-as-output plus test verification before submission gives a concrete artifact to measure against engineering time, though no cycle-time benchmarks are published.
Clean per-seat math at Team tier, but no published overage rate beyond the 250 threads/hour ceiling makes year-3 scaling cost hard to pin down.
Finance teams that can commit to annual seats and want to model cost before any sales conversation.
Avoid if you need Enterprise-tier security features but can't get a number without a sales call first.
PR-as-interface is the right abstraction, but the thread-rate ceiling bites first
“Hoplite keeps agents off your laptop and makes the pull request the unit of review, with tests and preview checks run before you ever see a diff. The architecture is sound; the daily friction will show up in how many parallel threads you can actually run.”
Running agents in sandboxes tied to GitHub repos instead of a local terminal is the correct call for anything beyond toy tasks — no more wondering which branch an agent left your working tree on. The CLI handoff from Claude Code, Codex, or OpenCode sessions is the detail that tells me someone building this actually runs agents daily; that's a real escape hatch, not a marketing bullet.
Day-3 friction will come from the approval model. Gating file edits, shell commands, and PR actions individually sounds great in the demo. On a real sprint with Automations firing off Sentry fixes and Slack-to-PR tasks in parallel, that's a lot of approval prompts to triage before coffee — the MCP server and OpenAPI spec help if you script around it, but most teams won't on day one.
The OAuth-protected MCP endpoint at api.hoplite.sh/mcp and scoped API keys via X-Api-Key suggest a team that's shipped internal tooling before. Pricing's attached to a seat count, not a vague inquiry form, which matters for actually running a trial against a real repo instead of a toy one.
Sandbox isolation plus test verification before a PR opens removes a specific daily annoyance: babysitting an agent's working directory.
An OpenAPI spec with operation schemas and a discoverable MCP manifest read like docs written for someone integrating, not just browsing.
Per-action approval gating on edits, commands, and PR actions is good for safety but adds interrupt volume once Automations run in parallel.
CLI handoff, MCP server, and scoped API keys give a clear path from web UI to scripted automation, though depth past that isn't fully visible.
GitHub-backed repos and the PR as the review checkpoint matches how most teams already merge code, no new review ritual required.
Teams already living in GitHub PRs who want bounded coding tasks delegated to a sandboxed agent with a human merge gate.
Avoid if your review process isn't PR-centric or you need agents to commit directly without a gating step.
A tool that only exists once you've already decided to trust the robot with a merge
“Hoplite's whole pitch is: let the agent work somewhere else, come back when there's a PR. Whether that feels calm or nerve-wracking depends entirely on how good their defaults are, and the daily texture of that I just can't see from outside.”
What I can't tell from the outside is the stuff that actually decides if you keep using this past week one. Isolated sandboxes, managed web previews, test verification before a PR opens — all good bones. But daily feel lives in the gaps: what does a failed sandbox boot look like, what's the error state when a managed preview won't build, does the dashboard tell you clearly which of your 5 free concurrent sessions is stuck versus just slow?
The $0-free-card-required model is a smart trust move, but trust is also the whole ask here — you're handing a cloud agent write access to a GitHub repo on a schedule. That's a bigger leap than most daily tools make you take on day one.
No mobile mentioned anywhere, which for a review-gated PR workflow might genuinely be fine — reviewing code on a phone is nobody's idea of a good afternoon anyway. Mac and web only, so judge it there.
Streaming live agent actions and per-action approval gating sound considered, but I couldn't find anything on empty states or error copy inside the sandbox.
The CLI handoff from Claude Code, Codex, or OpenCode sessions gives existing users a familiar on-ramp rather than a blank new tool to learn.
Platforms listed are web and Mac only; for a PR-review tool that may matter less than usual, but it's still not there.
A $0 free plan with 5 concurrent sessions and every platform model lets you actually try real tasks before paying, which beats a locked demo.
Automated test verification and managed previews running before a PR opens suggest the platform catches its own mistakes before you see them.
Teams already living in GitHub PRs who want bounded coding tasks handled off someone's laptop.
Avoid if you need mobile review or you're not ready to trust scheduled agents with repo access yet.
The PR-as-interface pitch is clean. The lock-in underneath isn't.
“Hoplite's workflow is grounded in specifics — GitHub repos, OpenAPI, MCP, real pricing. What happens to in-flight Automations and sandbox history if you leave is the part nobody's written yet.”
"Build with swarms of cloud agents" is the kind of superlative that should set off alarms, but the rest of the page backs it with real mechanics: isolated sandboxes, test verification, managed previews before a PR opens. That's a grounded claim, not a vibe.
The open question is what you're left holding at month 18. Automations, thread history, sandbox config — none of that is described as exportable anywhere I could find. The CLI handoff from Claude Code or Codex gives you an entry ramp, but entry ramps aren't exit ramps. Enterprise is quote-only and needs an annual agreement, which is a longer leash than most teams want on a first contract.
I've seen "PR as the interface" framed before as a wrapper over someone else's agent — this one at least names its own test and preview layer. Whether that's durable moat or just a head start is unclear six months out.
Anchoring the review step around tests plus a managed preview, rather than a chat session or raw commits, is a distinct enough design to matter.
PR output lands in your own GitHub repo, but I couldn't find anything on exporting Automation configs or thread history if you walk away.
A published changelog, docs, and an OpenAPI spec suggest active maintenance, though team size and funding are nowhere visible.
The homepage's swarm language is aspirational but the feature list under it — sandboxes, PR generation, test verification — matches concrete, checkable claims.
Specific mechanics like the MCP OAuth endpoint and X-Api-Key auth back the headline claim, though I found no data on failure rates or uptime.
Teams already living in GitHub who want agent output to arrive as a reviewable PR, not a chat transcript.
Avoid if you need a documented exit path for automation configs before committing budget.
Common questions answered by our AI research team
The Free plan costs $0 per month and includes 5 concurrent cloud sessions, 5 projects, and access to all platform models. A card is required but nothing is charged.
Hoplite's Team plan costs $60 per seat/month, or $50 per seat/month if billed yearly. It includes 50 concurrent sandboxes per seat, bigger sandboxes, unlimited projects, team seats and shared workspaces, 250 new threads per hour, usage charts and analytics, and standard support.
Hoplite integrates with GitHub for repositories and pull requests, Linear for issues, Slack for updates, and anything that speaks MCP. Agents can also install and use a project's own tooling inside the sandbox.
No. Hoplite does not train AI models on your code, and neither do the model providers it connects to — your codebase is used only to do the work you asked for.
Yes. File edits, shell commands, and pull-request actions can each be gated on explicit approval, and everything the agent does streams live so you can step in at any point before changes are merged.
Hoplite provides cloud-based coding agents designed to automate software development tasks.
