Launching today
KarmaBox
Run your own Claude Code in your pocket.
411 followers
Run your own Claude Code in your pocket.
411 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.
KarmaBox
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?
KarmaBox
@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.
KarmaBox
@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.
KarmaBox
@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.
KarmaBox
@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?
KarmaBox
@barnaby_lloyd Appreciate it 🙌 great question.
KarmaBox
@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.
KarmaBox
@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.
KarmaBox
@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?
KarmaBox
@antonio_manuel1 Totally feel that — it adds up fast.
KarmaBox
@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.
KarmaBox
@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.
KarmaBox
@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?
KarmaBox
@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.
KarmaBox
@elijahbowlby For longer tasks, it’s more like ongoing execution:
things keep moving, results sync back, and you can jump in whenever you want.
KarmaBox
@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?
KarmaBox
@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.
KarmaBox
@xavier_hernandez2 KarmaBox is designed to be lightweight. It works on most modern smartphones
wow interesting, Ill give it a try......
How are you different from Claude's Remote Control?
KarmaBox
@achuth_noob Great question! Claude Remote Control lets you run Claude Code on a remote machine — it's essentially a terminal in the cloud. Karma goes further in a few key ways:
1. Mobile-native, not mobile-adapted
Karma is built from the ground up for your phone. Full conversation history, streaming responses, tool call visualization, voice input — all designed as a mobile-first experience, not a ported terminal.
2. Your machine, your data
Karma runs on your KarmaBox (Mac/Linux). The AI executes on hardware you own. E2E encrypted. Nothing goes through Anthropic's servers except the LLM call itself.
3. Persistent AI teammates, not sessions
Avatars with skills, memory, and personalities that persist across conversations. Think less "remote terminal" and more "AI coworker you can reach from your phone at 2am."
4. Orchestration layer
Multi-agent coordination, skill marketplace, project-level context — built for teams running parallel workstreams, not just a single dev querying Claude.
In short: Claude Remote Control is a power tool. Karma is the operating system around it.
KarmaBox
@achuth_noob Great question — and excited for you to try it out 🙌
Claude’s Remote Control is mainly about accessing and running Claude across devices.
KarmaBox is a bit different — it’s not tied to a single model or a single machine.
It coordinates multiple models and agents, runs them across all your devices as one system, and keeps tasks moving even if you step away or switch devices.
So instead of controlling one AI remotely, you’re essentially running a whole system of them together.