self-hosted · your cloud · your rules

Stop shipping code the old way

Turn a Slack conversation — not just a message, the whole back-and-forth — into a reviewed pull request. Steer the agent as it works, right in the thread, and merge when your engineers are happy. All inside your own cloud.

See a demo Talk to us
C coreteam.io 🔒 sbx-health-check in Slack
Today
doryz12:10 PM
add a health-check endpoint at /healthz that returns 200 and the app version
⏳ 1
sandbox-runnerAPP12:10 PM

⌛ Warming up the VM… → 🔒sbx-health-check-12buwj (edited)

sandbox-runnerAPP12:14 PM

✅ Sandbox ready

🌐 App: https://your-app.example.dev

🧠 Working on:

add a health-check endpoint at /healthz that returns 200 and the app version
doryz12:22 PM
wait so you added a second health endpoint ?
✅ 1
sandbox-runnerAPP12:22 PM

🟧 Stopped current — running your message. (edited)

Yes — and I should have flagged that more prominently before committing. Current state:

· /api/health (pre-existing) → { status: 'ok' }
· /healthz (what I added) → { status: 'ok', version }

Three ways to resolve it, your call:

1. Keep both — /healthz is a common convention (k8s-style). Redundant but harmless.
2. Just add version to the existing /api/health — one endpoint. Cleaner.
3. Replace — most invasive; breaks anything hitting /api/health.

Nothing's pushed yet. I'd lean toward option 2 — which do you want?

sandbox-runnerAPP12:31 PM

✅ claude completed in 8m 47s · $1.17

🔀 PR ready: https://github.com/your-org/your-repo/pull/135

BIUS🔗≡</>
Message 🔒sbx-health-check➤
A real run in Slack — chat in, steered mid-flight, reviewed PR out.
Yours to own

Any harness or model. Same workflow.

The agent and the harness are swappable parts, not the foundation — Claude Code, Codex, Cursor, opencode, or one you name. Switch in minutes when a better one drops or a provider goes down. The workflow never changes.

Claude CodeCodexCursoropencode+ you name it
◆ You own it all — harness, cloud, data, bill
doryznow
model opus · harness codex
sandbox-runnerAPPnow
✅ Switched for the next turn — workflow unchanged.
Ship & review

Anyone can ship. Reviews get easier.

Starting work takes one message, not a dev environment — a PM, a founder, an engineer. And every PR arrives with its conversation attached, so reviewers see the why, not just the diff. Engineers keep the gate.

◆ One message in → reviewed PR out
sandbox-runnerAPPnow
🔀 PR ready: …/pull/135 — conversation attached
tomReviewer · now
the whole thread's here — I can see the why. Approving 👍
✅ 2
Together, anywhere

Your whole team, in one thread.

Because anyone can ship — engineer, PM, or founder — the whole team is in the same thread, weighing in and steering the agent together while it works. In Slack, or any chat platform your company already uses.

SlackTeamsDiscord+ any chat you use
◆ One shared thread · everyone can see & steer
mayaPM · now
will this change what our status page shows?
alexEng · now
good flag — keep the existing probe 👍
sandbox-runnerAPPnow
Got it — merging into one endpoint. Updating the PR.
The control plane

Your team works in chat.
You govern from the dashboard.

One workflow every person carries — engineer, PM, founder alike. Every run the team makes, visible in one place, so the same mistake gets fixed once instead of twelve times. And a spend ceiling the system actually enforces.

→ everything above runs in your own cloud
What you get

One shared way to build with AI —
on your infra, under your control.

AI coding is happening at your company either way — today it's scattered across personal tools, invisible spend, and work you can't see or reuse. DevSandboxed turns it into a team capability: secure on your own infrastructure, cost-controlled, and shared by everyone from the CEO to the newest engineer.

💡 The conversation is the new IP

Code is the output. The real asset is your team's intent, decisions, and validation — the conversation that produced it. Here that asset is captured in your threads and stays in-house, instead of evaporating in personal AI tabs.

→ your judgment, captured in-house

🔍 Review PRs at scale — without drowning

AI multiplies pull requests until review becomes the bottleneck — the biggest unsolved problem in AI-assisted engineering. Here every PR arrives with its conversation attached: the intent, the decisions, the validation. Reviewers see the why, not just the diff — and the practices for handling the volume come with the product.

→ review the why, not just the diff

🔄 Transition to AI-first work

Becoming AI-first doesn't happen by buying licenses — it happens by changing how work flows through the team. Start with routine tasks, grow into whole workflows, and learn what to delegate and what to keep human — with an experienced AI-focused engineer guiding the shift.

→ AI-first, one workflow at a time

🙌 Anyone can ship — engineers keep the gate

Starting work takes one chat message, not a dev environment — founders, PMs, and support leads can hand real tasks to an agent and watch them get done. And nothing lands without review: every run ends as a pull request your engineers approve. Everyone gains the power; nobody loses the quality bar.

→ everyone ships, engineers approve

🔀 Never hostage to one AI vendor

Claude Code, Codex, opencode — the agent and the model are swappable parts, not the foundation. Switching a model or a harness has never been easier: a better model drops, adopt it in minutes; your provider has an outage, switch and keep shipping while competitors wait it out. The workflow — and your team's habits — don't change.

→ best model today, a better one tomorrow

🔒 Secure — runs on your own infra

Everything runs inside your own cloud account, within your existing security boundary. Code, secrets, and customer data never touch a third party — the answer to "where does our code go?" is nowhere. Your security team doesn't have to trust a new vendor, because there isn't one in the data path.

→ your code goes nowhere

🎛️ Costs you control — no surprises

You decide what runs, when, and for how long; environments shut themselves down when the work is done, so nothing idles and nothing quietly burns money overnight. And you pay your cloud provider directly — no per-seat pricing, no markup, no mystery line items.

→ the bill is never a mystery

…and it compounds from there

⚡

Idea to PR in minutes, not sprints

The distance from "we should fix that" to a reviewable pull request collapses to one message. Small fixes stop waiting a sprint — and big ideas get a working draft the same day.

→ ship today, not next sprint
🤝

Tight collaboration — and shared learning

Work happens in shared threads, not on someone's laptop. Anyone can watch, steer, or jump in — and learnings compound in team channels, not one person's chat history.

→ building in the open, together
🧭

One standard workflow

The whole team shares the same tools, the same flow, the same guardrails. No snowflake setups, no "works on my machine," no five AI tools doing the same job five ways.

→ one flow, zero snowflakes
🧪

Fearless experimentation

Every run gets its own disposable environment, so the risky refactor or the weird spike costs nothing to try. Throw the sandbox away, keep the learning.

→ break things that don't matter
Where this sits

Not another sandbox SDK

Sandbox infrastructure, IDE copilots and hosted agents all touch this space — from different layers. DevSandboxed is the finished workflow your team ships with, running in your own cloud.

DevSandboxed Agent harnesses
Claude Code, Codex CLI		 AI IDEs
Cursor, Windsurf		 Claude in Slack
chat assistants		 Sandbox SDKs
E2B, Daytona		 Hosted agents
Devin & co
What it is The finished workflow: chat in, reviewed PR out A powerful agent in one engineer's terminal An AI copilot inside each engineer's editor An assistant in your team chat Raw sandboxes + an SDK to build on An agent in someone else's cloud
Who ships with it The whole team, CEO to newest engineer The engineer driving it The engineer at the keyboard Anyone, inside their flows — you don't control how it works or what you see Developers building agent products Developers, via their platform
Where code runs Your own cloud account One laptop Each developer's laptop Their cloud Their cloud, or infra you assemble Their cloud, with your repo
Security Disposable, isolated sandboxes inside your VPC — nothing persists, nothing leaves your account Full repo + credentials on developer laptops — as safe as each machine Repo + keys on every laptop; code context flows through the vendor's cloud for completions Your code and context in their cloud, under their policies Isolated, but in third-party custody Your repo and secrets live in their environment
Collaboration Everything happens in the shared team chat — everyone sees it, steers it, learns from it Solo sessions, invisible to the rest of the team Shareable chat transcripts — but the work itself stays per-seat Shared chat, but no shared engineering workflow Whatever you build Per-user sessions in their UI
The conversation
your new IP		 Lives in your chat and attached to every PR — searchable, auditable, yours forever Scattered across terminals, gone when the window closes Editor chat history — shareable after the fact, not attached to the PR record In their threads — chat history, not an engineering record Wherever you build logging Locked inside their platform
To get started Nothing to build — deployed for you, ships day one Per-engineer setup and habits Install + configure per engineer Install the app You build the workflow yourself Hand over repo access
The agent Yours to choose: Claude Code, Codex, opencode — swappable. We orchestrate the harnesses you already trust That one harness The IDE vendor's stack Claude only Bring and wire your own Theirs only
Costs Your cloud bill, your API keys — visible, capped, yours to control Subscriptions + token spend, per engineer Per-seat subscriptions + usage The steepest markup: bundled pricing, hidden costs, zero control Usage-priced, on their meter Premium seats + marked-up compute
Lock-in Design partners keep the source code, forever Solo workflows, no team layer Subscription — and your workflow lives inside that editor Subscription Open core, usage-priced cloud Subscription + their infra
Six ways to do AI coding
◆
DevSandboxed — this product
Chat → reviewed PR, in your own cloud
>_
Agent CLIs
An agent one engineer runs in a terminal
Claude CodeCodex CLI
{ }
AI IDEs
An editor with an AI copilot built in
CursorWindsurf
💬
Chat assistants
A general assistant in your team chat
Claude in Slack
🧩
Sandbox SDKs
Raw sandboxes — you build the workflow
E2BDaytona
🤖
Hosted agents
An AI engineer in the vendor’s cloud
Devin & co
QUESTION 1 OF 6

Where does your code run?

◆
DevSandboxed
Your own cloud account — nothing leaves it
>_
Agent CLIs
One engineer’s laptop
{ }
AI IDEs
Each dev’s laptop + the vendor’s cloud
💬
Chat assistants
Their cloud
🧩
Sandbox SDKs
Their cloud, or infra you assemble
🤖
Hosted agents
Their cloud, holding your repo
QUESTION 2 OF 6

Who can ship with it?

◆
DevSandboxed
The whole team — CEO to newest engineer
>_
Agent CLIs
The engineer driving it
{ }
AI IDEs
The engineer at the keyboard
💬
Chat assistants
Anyone, loosely — no controls
🧩
Sandbox SDKs
Developers building agent products
🤖
Hosted agents
Developers, via their platform
QUESTION 3 OF 6

How does the team collaborate?

◆
DevSandboxed
One shared thread — everyone sees & steers
>_
Agent CLIs
Solo sessions, invisible to the team
{ }
AI IDEs
Per-seat; transcripts shareable after
💬
Chat assistants
Shared chat, no engineering workflow
🧩
Sandbox SDKs
Whatever you build
🤖
Hosted agents
Per-user sessions in their UI
QUESTION 4 OF 6

How safe are code & secrets?

◆
DevSandboxed
Isolated, disposable sandboxes inside YOUR VPC
>_
Agent CLIs
Full repo + keys on every laptop
{ }
AI IDEs
Laptops + context through vendor cloud
💬
Chat assistants
Your code under their policies
🧩
Sandbox SDKs
Isolated — but third-party custody
🤖
Hosted agents
Repo + secrets in their environment
QUESTION 5 OF 6

What does it cost?

◆
DevSandboxed
Your cloud bill, your API keys — no markup
>_
Agent CLIs
Subscriptions + tokens, per engineer
{ }
AI IDEs
Per-seat subscriptions + usage
💬
Chat assistants
Bundled pricing, steep hidden markup
🧩
Sandbox SDKs
Usage-priced, on their meter
🤖
Hosted agents
Premium seats + marked-up compute
QUESTION 6 OF 6

How locked in are you?

◆
DevSandboxed
Agents swappable; partners keep the source
>_
Agent CLIs
Solo workflows, no team layer
{ }
AI IDEs
Your workflow lives inside that editor
💬
Chat assistants
Subscription
🧩
Sandbox SDKs
Open core + usage cloud
🤖
Hosted agents
Subscription + their infra
Seen in the wild

Not a concept — a workflow that already ships every week

This model was built and battle-tested inside a real startup's daily workflow before it became a product. Read the story of how it changed who gets to ship — or watch the demo run live.

"Last week our CEO shipped a PR from his phone. So did our PM. So did our designer. … They're active members of our dev team now, building features and shipping real reviewed code every week, alongside the engineers." — from "Sandboxes Are the New Dev Environment"
Read the full story →
Runs where you run

Your cloud, your agent, your chat

No rip-and-replace. DevSandboxed plugs into the stack you already have: the cloud account you already pay for, the chat your team already lives in, and the coding agent your engineers already trust — each one swappable, none of them locked in. And no black boxes: the code running in your cloud is code you can read.

Google Cloud · available now
AWS · in active development
Azure & others · on the roadmap
Who it's for

Built for teams whose code can't leave the building

🚀 Startup engineering teams

Ship like a team twice your size — without hiring, without a platform team, and without your IP on someone else's servers.

  • More output per engineer: routine work runs itself while the team builds product
  • Investor- and customer-safe: IP and data stay inside your own account
  • No infrastructure tax — nothing new to stand up or maintain per developer

🤝 Services & consulting firms

Win the clients your competitors can't — the ones whose security teams won't let data leave their environment.

  • Deploy per engagement, inside the client's cloud, under their governance
  • Auditable deliverables: every piece of work lands as a reviewable PR
  • Clean exits — tear the whole thing down when the engagement ends
More than software

An AI engineering partner in your corner

Adopting agents isn't installing a tool — it changes how your team works. Design partners don't just get the platform: they get an experienced, AI-focused engineer working alongside them to make the transition stick.

🧠 Best practices from day one

Skip the trial-and-error tax. Get proven practices for working with coding agents — how to scope tasks, set guardrails, and structure your repos so agents actually deliver.

📈 Level up your engineers

Hands-on guidance that turns your developers into effective AI engineers — people who lead agents and multiply their output, instead of competing with them.

Early access

We're looking for design partners

A small number of teams get hands-on deployment in their own cloud, direct access to the founder, and a real say in the roadmap — in exchange for honest feedback on real work. Design partners get the source code and keep it forever: run it, change it, support it yourselves if you ever choose to.

If cloud coding agents are on your roadmap but third-party exposure is the blocker, let's talk.

See a demo