KarmaBox
Run your own Claude Code in your pocket.
767 followers
Run your own Claude Code in your pocket.
767 followers
Run hundreds of AI agents from your phone. Turn your devices into a private compute pool, route every task to the best AI, and use Claude, Codex, Gemini and more — no infra, no lock-in.
Free Options
Launch Team / Built With
Customer.ioAutomate Messaging Everywhere — Startups Get 12 Months Free
Promoted
This looks different, great work Team
Does it work if some devices are offline or low battery, or does the whole pool need to be active for tasks to route properly?
@boyuan_deng1
KarmaBox continuously monitors device status (online/offline, battery, load). When routing tasks, it only uses available devices:
The system is designed to be resilient — devices can come and go without breaking anything.
@boyuan_deng1 Great question — and thanks!
It doesn’t require all devices to be online. We separate compute and state:
Compute is stateless (VPS / sandbox / laptop), so tasks can run on whatever is available.
State is persisted separately, so progress isn’t tied to any single machine.
If a device goes offline or runs low on battery, the system just routes work to others. No need for the whole pool to stay active.
@boyuan_deng1 Thanks 🙏 — and good question, because this is where the design choice actually matters.you're asking about the KarmaBox pool — the machines you've connected (laptop, desktop, home server, etc.).
Heartbeat-based registry. Each KarmaBox keeps a lightweight WebSocket to Server announcing state — online/idle, online/busy, offline (last-seen timestamp), plus power state (plugged in / on battery / low
battery). Server's machine pool is a live view of who's available right now.
@boyuan_deng1 Box drops mid-task. If the chosen box disappears mid-flight (lid closes, network drops), the task checkpoints via Digest and either: (1) waits for that box to come back, (2) re-dispatches to another
eligible box, or (3) escalates to Cloud — your choice, per project.
Low battery. Box self-reports. Server avoids dispatching heavy autonomous loops to a low-battery laptop, and prefers a plugged-in box if one is available. You can set policies per machine ("never run
autonomous loops on this laptop unless plugged in").
Project ↔ box binding. Each project picks a primary box and an optional fallback chain. "Client work" might be locked to your work Mac; "personal research" can fall through laptop → desktop → Cloud.
So no — the pool doesn't need to be all-on. Run one box and it works. Run five and the smartest one wins. Partial availability is the default assumption, not the edge case.
Happy to dig into a specific scenario you have in mind 🙂
Well done, Viveka! This feels huge. How do you handle API costs does it get expensive if agents run 24/7 on my device?
@barnaby_lloyd Appreciate it 🙌 great question.
@barnaby_lloyd Running 24/7 doesn’t mean it’s constantly burning tokens — agents are mostly event-driven and only call APIs when there’s actual work to do.
On top of that, we route tasks across different models depending on the job, so you’re not always hitting the most expensive one.
Since compute runs on your own devices, you also avoid a lot of the infra cost you’d normally have.
So it’s pretty controllable in practice — and we’re adding more knobs for users to tune cost vs quality as well.
@barnaby_lloyd Thanks 🙏
To answer at the layer beneath the user-facing controls — because the cost story is partly about routing, but mostly about what we run behind the routing.
Aggregated LLM credit pool. Karma negotiates volume rates across Anthropic / OpenAI / Gemini / Qwen / DeepSeek and pools usage across our user base. That's 20–40% better unit economics than any individual
user gets on direct API. Variance gets absorbed by the pool — you don't feel the spikes, and the energy unit stays stable across vendor pricing changes.
Aggregated cloud execution pool. Sandbox runtimes (E2B), VPS-class compute, GPU resources for image/video — all warm-pooled with second-scale provisioning. No cold-start tax billed to your task, no per-VM
rental on your account. When an avatar fans out to a sandbox or spins up a longer container, the capacity is already there.
This is what lets routing stay quality-neutral. If we were a thin passthrough, every "Sonnet not Opus" call would be a quality-vs-cost tradeoff for the user. Because the backend is pooled, routing optimizes
against pool economics — you still get the right model for the task; the savings come from infrastructure leverage, not from downgrading your output.
@barnaby_lloyd Same logic for multi-model orchestration. When Sonnet plans, Haiku greps, Opus reasons, and Gemini handles long context — each handoff would be brutal at retail cross-vendor rates. At pool rates, it
composes. That's why Karma can route and combine models freely without it feeling like every step costs you.
For 24/7 agents: steady state runs on cheap models on warm pooled infra; the rare expensive cycles still benefit from negotiated rates. The $10/month monitoring loop stays $10 not because we cap quality —
but because the math underneath is structurally cheaper.
So the user-facing controls (routing, budget, local KarmaBox) sit on top of an aggregated backend that makes them mean something. Without the pool, "smart routing" is just "downgrading to save money."
With the pool, it's "right model for the task, and we absorb the optimization."
So cool congrats on the launch! Most annoying part for me is logging into 5 different AI tools every morning. Does KarmaBox handle auth across them automatically?
@antonio_manuel1 Totally feel that — it adds up fast.
@antonio_manuel1 KarmaBox doesn’t auto-log into everything, but once you connect your models/services, everything runs through one system.
So you’re not jumping between tools or re-authing every time.
@antonio_manuel1 Thanks 🙏 — this is one of the pain points that motivated the whole thing, so let me be specific.
Short answer: yes — connect once, never log in again.
Karma handles AI provider access entirely. Use the energy wallet — no separate ChatGPT / Claude / Gemini accounts to log into at all. One Karma login, all the models. Most users land here.
@antonio_manuel1 Beyond AI providers — same model applies to Gmail, Slack, Telegram, GitHub, Notion, etc. via the Connections layer. OAuth once at setup; every avatar uses those services without a popup ever again.
Quick scope note: the auth aggregation is a Karma platform feature, not strictly KarmaBox. KarmaBox is the local execution daemon — your Mac running tasks. Both Cloud and KarmaBox use the same unified
credentials, so when work moves between runtimes (phone → Mac → cloud sandbox), auth follows automatically. Switching devices mid-conversation never triggers a re-login.
So your "5 logins every morning" becomes: set up once, never again. That includes the moments most products break — device switches, model switches, skills calling external APIs on your behalf.
This is exactly what I've been wanting. I use Claude Code daily for development but being tied to my laptop for it feels limiting. Being able to kick off a task from my phone while commuting and check results later would change my workflow completely. How does it handle long-running tasks? Does it queue them and notify you when done, or is it more of a real-time interactive session?
@elijahbowlby That’s exactly the use case we had in mind 🙌
It’s not really tied to a single session. Once you kick off a task, it keeps running in the background across your devices.
So you can start something on your laptop, close it, and pick it up from your phone later — the system just keeps progressing.
@elijahbowlby For longer tasks, it’s more like ongoing execution:
things keep moving, results sync back, and you can jump in whenever you want.
@elijahbowlby
This is a simple copywriting task, no tools needed.
KarmaBox handles both:
Long-running tasks: We queue them and run them in the background on your devices. You get notified when complete.
Real-time sessions: For interactive work (like coding), you can maintain live sessions and check in anytime.
Perfect for your commute use case — kick off a task on the train, and KarmaBox keeps working while you're offline. Results waiting when you check back!
Huge congrats! Typiest is so real lol. Quick question: can I run this on an old phone or does it need beefy hardware?
@xavier_hernandez2 Haha appreciate it 🙌 Typiest is very real 😄
You don’t need a beefy phone. The phone is mainly the control center — sending tasks, monitoring, and continuing workflows.
The actual heavy lifting runs across your other devices (laptop, workstation, servers, etc.), so even an older phone works fine.
@xavier_hernandez2 KarmaBox is designed to be lightweight. It works on most modern smartphones
wait — hundreds of agents on a phone? curious how you handle the battery + thermal side of long-running tasks. is it more of a remote-control-your-mac thing or actually executing on-device?
@tijogaucher Heavy AI compute runs in the cloud (Claude, Gemini, etc.), while your device handles lightweight orchestration — so minimal battery/thermal impact. You can also set battery limits and pause tasks when needed.
@tijogaucher Haha yeah — definitely not melting your phone 😄
@tijogaucher The phone is mainly the control layer, not where the heavy work runs.
Actual execution happens across your other devices (laptop, workstation, servers, etc.). The phone just lets you trigger, monitor, and continue tasks.
So battery/thermal impact on the phone is minimal — it’s closer to “remote control + command center” than on-device execution.