You already built this. Stop maintaining it.
A working agent stack is usually five vendors in a trench coat: a microVM service, object storage, a queue, a vector DB, and some auth you wrote. It works — and every piece is yours to patch, bill, and page on. sys9 replaces it with atomic, agent-native services you compose, and opt into one at a time.
What you wired together → one service.
A part-for-part map from the stack you maintain to the service that replaces it. Take the rows you need; leave the rest.
| What you wired together | The sys9 service | What changes |
|---|---|---|
| microVM vendor (e.g. E2B, Firecracker) | run9 | Fork the whole OS — data and packages — in ~50ms. Run up to 1,000,000 in parallel, pay only when running. No image pipeline to maintain. |
| Object storage (e.g. S3) + glue | db9 + drive9 | File storage built into the database, no bucket wiring — plus a shared FUSE filesystem across sandboxes with semantic grep. |
| A queue / job runner | task9 + tape9 | Atomic work-claim with no queue to declare, and an append-only stream with real-time replay. One winner per task, liveness-backed. |
| A vector DB / search service | drive9 + mem9 | Semantic grep (vector + BM25 in parallel) over your files, and one persistent memory shared across every agent. |
| Agent-to-agent messaging glue | inbox9 + pulse9 | FIFO mailboxes with guaranteed delivery and a liveness registry — the coordination layer, without the broker you stood up. |
| Homegrown auth | auth9 · soon | Sign in once, unlock every service; use-first claim-later for your service too. Until it lands, scope secrets per agent with drive9’s vault. |
| DIY logging / tracing | owl9 | Wrap the binary for zero-config capture — sub-agents auto-traced, human-readable transcripts, no code changes. |
Same capabilities. Far fewer seams.
A DIY stack
Capabilities glued across five vendors you operate yourself.
- Five bills, five dashboards, five on-call surfaces
- Glue code between every pair of services
- Idle compute often still costs you
- Auth and isolation are yours to get right
- Not built for agents — you adapt SDKs to the loop
sys9
Atomic services that compose, driven by APIs, CLIs, and Skills.
- One agent-native suite; opt into only what you use
- Services designed to compose — less glue to write
- Pay only when running; idle sandboxes sleep free
- Isolation by construction — a fork per tenant, not a policy
- Use-first, claim-later — hand an agent the skill
Migrate a row at a time.
You don’t have to rip out the stack. Replace the piece that hurts most, keep the rest, and compose from there.
Start with the sharp edge
Swap the one service that pages you most — usually compute. run9 forks drop in where your microVM vendor sat.
Compose outward
Add storage, a database, coordination, or traces as you go. Each is independent; nothing forces a big-bang cutover.
Retire the glue
As services move over, the integration code between them goes away — the seams were the point.
Replace the stack one service at a time.
Tell us what your DIY stack looks like. Start by forking a sandbox today — no signup, pay only when it runs.