Hoplite Review 2026 — YC S26's Cloud Coding Agents, From Request to Reviewed PR
✅ Pros
- • Every thread gets an isolated sandbox cloned from your repo, with the app booted on a live URL — you can click through a PR's changes without checking anything out locally, which Cursor's cloud agents don't offer easily
- • Agent has a persistent Chromium session: it can start a preview, seed data, then walk old vs new UX flows for before/after visual QA, and save those flows to a replayable QA library
- • Model-agnostic by design: Anthropic, OpenAI, and open-weight models (Kimi K3, GLM 5.2) per thread — no provider lock-in like Copilot Cloud or Codex Cloud
- • No upcharge on token or sandbox costs — pricing is per-seat with a credit balance, so running more agents doesn't financially disincentivize you
- • Automations connect to real triggers: webhooks and schedules can auto-fix Sentry/PostHog issues as they arrive, and an MCP server lets you delegate tasks from your existing local setup
⚠️ Cons
- • Local-to-cloud transition is incomplete: switching an active local thread to the cloud doesn't carry over filesystem state — you must push to a remote branch first
- • Launch HN feedback called the landing page 'Claude slop' and the founder agreed; the marketing copy and a generic animated hero don't reflect the product's polish
- • Infrastructure is still settling: Modal is primary with Daytona as fallback, and autoscaling requires stop/resize/start — the team is evaluating AWS Lambda MicroVMs
- • Pricing was flagged as confusing in the launch thread; $82.50/seat + credits is higher than competitors, justified by the no-upcharge stance but needs clearer framing
- • Young product (YC S26) — thin third-party track record, no public case studies yet, and sandbox capacity limits apply on all but the top plan
Teams that want agent-driven development with real verification (tests + browser QA on live previews) without managing their own sandbox infrastructure
Pro $82.50/seat/month ($990/yr, billed annually), $100 credits/seat/month, 25 pooled sandboxes/seat, 2 vCPU/8GiB/1TB per sandbox; Scale $249.17/seat/month ($2,990/yr)
Quick Verdict
Hoplite launched on Hacker News on August 3, 2026 as Launch HN: “Effortlessly deploy cloud coding agents” (49 points, 17 comments) — a YC S26 company founded by Bence (BenceRed). The pitch: connect a GitHub repo, describe a task, and a coding agent works through it in an isolated development environment, reads and edits the code, runs tests, drives a real browser against a live preview URL, and opens a pull request for human review.
The positioning is deliberately between two extremes. It’s more turnkey than exe.dev (which requires significant configuration to reach parity) and more verification-focused than Cursor’s cloud agents (whose key gap — per one enthusiastic commenter — is that “every sandbox boots your app on a live URL”). At 7.2/10, Hoplite is a promising, well-designed take on cloud agent infrastructure with real differentiation, still early and still rough around the edges — the founder openly concedes the marketing is being redesigned.
How It Works: One Thread, One VM, One Live URL
The core model is simple and powerful:
- Connect a GitHub repository — configure the base branch, setup script, and encrypted environment variables.
- Start a thread with a task description.
- The agent works in an isolated sandbox: reads/edits the repo, runs tests, and — crucially — boots the app on a live URL so you can watch it build itself.
- Approve sensitive actions when required; review the agent’s verification evidence.
- Receive a pull request, then keep iterating in the same thread as review feedback arrives.
The “one thread = one VM” isolation model got immediate validation from HN users. r5Khe (who uses Amp, ampcode.com): “One thread = one VM feels like a solid model going forward.” The founder’s framing: per-thread VMs are “quite similar to how local agents use worktrees to avoid cross contamination, but with the added benefit of being able to easily scale up/down compute requirements on demand.” yoanwaidev noted the parallel local pattern: “One agent per worktree so they do not thrash the same checkout. Cloud VMs buy isolation and scale; worktrees buy cheap isolation.”
The Killer Feature: Live-URL Verification
The most insightful comment came from fishtoaster, who initially dismissed Hoplite (“my first thought was ‘this is just cursor’s cloud agents’”) before landing on the differentiator:
“The key thing here for me is ‘Every sandbox boots your app on a live URL.’ Cursor doesn’t easily have that, and that’s what would allow me to ditch my local env entirely — the ability to actually try out a PR without needing to check it out locally.”
This is the right lens for evaluating Hoplite. The differentiator isn’t “agent writes code” — that’s table stakes now. It’s the verification loop: agents have a persistent Chromium session, and the documented workflow is:
- Start the preview.
- Seed data.
- Walk through old and new UX flows for a before/after view.
- Save those flows to a QA library so they can be replayed without an agent running through them again.
That last point — a replayable QA library — turns agent verification into a regression asset. It’s the first real answer I’ve seen to the “agents write code but nobody tests it” problem.
Model Flexibility and the No-Upcharge Pricing Stance
On the model question, the founder was explicit in the thread:
“We’re not locked into a specific provider, and are able to offer open weight models like Kimi K3 and GLM 5.2.”
That’s a meaningful differentiator against Copilot Cloud / Codex Cloud, which are model-tied. mellosouls framed it as exactly what they were looking for: “alternatives to things like Github Copilot Cloud and Codex Cloud… especially ones that might be flexible wrt models.”
Pricing drew the most sustained criticism, and the founder’s defense is genuinely interesting:
“Our pricing is higher than other providers because we do not upcharge on token or sandbox costs. We believe that people should be running as many agents as they possibly can handle, and an upcharge would create a monetary incentive for us to slow them down.”
Current plans: Pro at $82.50/seat/month ($990/yr billed annually) with $100 credits/seat/month, 25 pooled sandboxes/seat, 100 new threads per rolling hour, 25 enabled automations, 2 vCPU / 8GiB / 1TB per sandbox, and 30-minute sandbox idle timeout. Scale at $249.17/seat/month ($2,990/yr) adds capacity and direct support. The model-usage is metered against the credit balance; sandbox capacity is plan-limited.
It’s a defensible stance — the incentive alignment argument is real — but fishtoaster’s “noted the pricing feedback” is the honest read: at launch, the per-seat + credits structure is harder to evaluate than a flat per-agent fee.
The Founder’s Honest Answers to Criticism
The launch thread was genuinely useful because the founder engaged directly with hard questions rather than deflecting:
On infrastructure choice (lionls asked why Modal instead of Firecracker): “Modal has a lot of small niceties… such as filesystem snapshots and programmatic build images. But I did see that AWS recently launched Lambda MicroVMs, and since we’re an AWS house we may transition.” Also notable: “My main issue with Modal is that their autoscaling is not as good as Daytona’s. You have to stop the machine, resize, then start it.”
On local-to-cloud continuity (Bnjoroge — “I don’t wanna always work on the cloud”): the current approach is an MCP server that asks a local agent to start a new Hoplite thread, but “it doesn’t carry over file system changes. (Unless you first push the contents to a remote branch.)” The founder acknowledged this is still being worked on — the honest answer for a launch-week product.
On the landing page (docheinestages: “showing an actual screenshot or video of your app is a much better indicator of effort than a generic Claude made animation… parts of it smell”; nzjrs: “Your website text reads like Claude slop”): Bence agreed with both and said a complete redesign with a designer is in progress. It’s refreshing to see a founder validate this criticism — too many AI launches gaslight on it.
On exe.dev (abtinf — “Why would I use this over exe.dev?”): “exe.dev works quite well for giving an agent a computer and managing it remotely, but seems to require a fair bit more configuration to achieve parity with what we offer out of the box. Namely automations, PR autofix, visual QA, and general UI/UX polish… it comes down to whether configuration or ease of use is valued more, and Hoplite favours the latter.”
Use Case: A Real Onboarding Pattern
The founder’s suggested starting point is the most practical one from the thread (in answer to FailMore’s “is this my day-to-day harness or something additional?”):
“If you don’t want to migrate over fully, I’d recommend setting up an automation to fix Sentry/PostHog issues as they come in. You can get a good feel for the platform and how it fits into your workflows that way.”
That’s the wedge: incident-driven automation. Connect a GitHub repo, wire a webhook from your error tracker, and Hoplite picks up issues, reproduces them in a sandbox, fixes the code, runs tests against the live preview, and opens a PR. You review PRs instead of writing fixes. Only after that works do you graduate to delegating feature work and research tasks via the MCP server.
Alternatives
| Option | Why | Cost |
|---|---|---|
| Hoplite | Isolated per-thread VMs, live-URL verification, browser QA library, model-agnostic, no token upcharge | $82.50/seat + credits (Pro) |
| Cursor Cloud Agents | Deep IDE integration, but weak live-preview verification per HN comparison | Included with Cursor subscription tiers |
| Codex Cloud / Copilot Cloud | Polished, provider-locked to OpenAI/Microsoft models | Subscription tiers |
| exe.dev | More control, more configuration; agent computer management | Subscription |
| Amp (ampcode.com) | Similar thread-per-VM workflow, established | Subscription |
| Self-hosted (Claude Code + worktrees) | Maximum control, free software, but you manage infrastructure | Your compute |
Verdict
Hoplite is a genuinely well-thought-out entry in the cloud-agent space, and the launch thread shows a founder who understands his product’s strengths (verification, isolation, model flexibility) and concedes its weaknesses (marketing, local-to-cloud continuity, pricing clarity) without spin. The live-URL verification loop with a replayable QA library is a real differentiator that addresses the actual pain point of agent-generated code: nobody verifying it. If you’re evaluating whether to offload agent orchestration to the cloud, Hoplite is worth a serious trial — start with the Sentry/PostHog automation pattern, not a full migration. Watch for the landing-page redesign and the Lambda MicroVM transition; both signal where the product is heading.
Rating: 7.2/10. Best for teams wanting verified, isolated cloud coding agents without infrastructure management — especially those frustrated by model lock-in and missing preview workflows in incumbent tools.