DevSpanner is a desktop AI console for developers. Run frontier models side by side as lanes, pick up any of your existing sessions, and watch every routing decision as it happens.
Share any machine you're not using, Mac, PC, Linux box or home server, earn tokens overnight, and spend them by day on any lane. How the mesh works
The mesh exists because the current way of buying AI is expensive, centralised and wasteful, and because most of the hardware that could fix that is already sitting in people's homes doing nothing.
Frontier tokens are priced for data centres. On the mesh the heavy lifting runs on compute you already own, and the tokens your machines earn pay for the rest. Only the manager's tokens stay premium.
See the savingsGPU and memory prices went where the data-centre orders went. The mesh doesn't fix the market; it sidesteps it. Your idle box competes with a data centre for the first time, and the money stays with the people who own the boxes.
Off-peak tariffs make the same computation several times cheaper at night. Tariff-aware sharing schedules your machines into the cheap windows, so "earn tokens overnight" is literally the cheapest way to run AI. opening with the beta
A battery full at four and idle at midnight is stranded energy. Grid-green mode shares when your power is your own or the grid is at its cleanest, using the public carbon-intensity feed. Efficient, and green without the greenwash. planned
The serious version is sovereignty: your AI runs in your house, on hardware you can unplug, and your code never ends up in someone else's training run. The joke version stands too.
Energy scheduling uses the tariff windows you set and, where available, the grid's public carbon-intensity feed. The mesh runs when your power is cheapest or cleanest; it makes no carbon-neutral claims.
Your machine does nothing all night, whether it's a Mac, a PC, a Linux box or the home server in the cupboard. On the GoLLeM Mesh it earns tokens while you sleep, and you spend them by day. Every member is a peer: the more the mesh shares, the more it can run, and nobody pays for a data centre they don't use.
Add every machine you own to one account: the laptop, the desktop with the GPU, the home server. Pick the hours and limits for each, CPU and GPU share, battery rules, thermal ceiling. Jobs run in an isolated sandbox with no access to your files, and stop the moment you touch the keyboard.
Every job a machine serves earns mesh tokens, weighted by the work done and by demand, and every machine on your account pays into one wallet. Peers come online in each region's local night, so the mesh follows the moon. A laptop left sharing overnight banks a little; a desktop with a GPU or a home server sharing around the clock earns all week.
Tokens pay for your own jobs on any lane, frontier or open-weight. Run out and the console falls back to the subscription you already have, so nothing stalls.
Sharing is opt-in with hard limits you control and opens with the beta opening with the beta. Clients for macOS, Windows and Linux, plus a headless mode for servers. Mesh tokens are compute credits on the GoLLeM Mesh, not a currency. Rates per node class are published before earning goes live.
Tasks are quick questions and vibes: ask, get an answer now on a fast lane, keep moving. Projects are bigger and slower: a proper brief, a plan, and the mesh doing the heavy lifting on cheaper lanes while you get on with something else. The mesh will never be the fastest, and it doesn't need to be. Projects keep going overnight, several at once, at a fraction of the cost, and a task can grow into a project the moment it turns out to be one: one click promotes it, and the manager seeds the brief from the conversation so far, then asks for what's missing.
A question, a fix, a riff. Answered in seconds on the lane you pick, with the routing shown. This is the console you use all day, and any task can be promoted into a project.
shippedDefined, planned, run, verified and reviewed. Hours or overnight, on the cheapest lanes that can do the work, while you do something else. Chat stays; projects sit beside it.
betaA human-led session, not a text box. The manager interviews you until all eight parts of the brief are in place: goal, outputs, acceptance checks, constraints, inputs and context, service class and token budget, review checkpoints, definition of done, plus an optional list of commands workers may run unattended. "None" is an answer; blank is not. Vague briefs don't start. That's the point.
The manager, a frontier model, breaks the brief into small tasks with a check attached to each, estimates tokens and time per service class, and shows you the plan to approve.
Tasks go to the cheapest lane that can do them, on the mesh by day or overnight, checkpointed so a peer going to bed costs nothing. Checks and commands are pre-approved in the brief; anything outside that list stops and waits for you. Several projects run at once.
Every task is checked before it counts: tests and commands by exit code, schema checks, or a typed judgment. A second attempt agreeing is coming. Failures retry a bounded number of times, then go back to the manager, then to you.
You see the summary, the diff and the test results, and decide. Anything stuck can be expedited to an express lane with one click.
Frontier lanes, on demand, for the parts that must be fast or right first time. Priced at the going rate, with a floor.
demand price · money or tokensThe scheduler picks the right lane per task during the day. Hours, not seconds, at the standard rate.
standard rate · earned tokensRuns in the 23:00 to 07:00 window on your clock, on peers seeding in their own night around the world, which is what makes it cheap. The slowest, at half rate.
half rate · fewest tokensProjects, briefs, service classes and the escalation ladder run today in the beta beta. Beta limits: two tasks per project, three in flight across projects, three attempts per task before the manager steps in, then you. Estimates and savings are shown per project before you approve the plan, and nothing runs unattended that the brief did not pre-approve.
DevSpanner puts the model, the conversation and the routing on one screen. No spinner hiding what happened to your request.
Frontier models sit side by side as lanes, grouped by vendor. Switch lanes per message and keep the conversation going.
Browse every session on your machine across projects, open one read-only, and continue it in a safe fork. The original transcript is never touched.
A live trace shows which lane took each job, time to first token, token counts and the health of the mesh. The topology view turns it into something you can watch.
Topology on the left, routing trace beneath it, the conversation on the right. Pick a lane in the header and every job says which lane served it.
A frontier model manages; the mesh does the heavy lifting. Only the manager's tokens are premium, the scheduler routes everything else to cheaper lanes, and tokens you have already paid for get reused. Every saving is shown per job in the trace, so you can see it rather than take it on trust.
Hand-offs send drafts, extraction and summaries to cheaper lanes while the frontier lane does the thinking. Cached and fractional tokens stop you paying twice for the same context.
betaRun a job on an open-weight lane, or pay with tokens your machine earned overnight, and there is no per-token bill at all. You pay with compute you already own.
private betaEach job reports the lane, the tokens, what was handed off and what was shared, and the console keeps a running total per session.
shippedBeta targets from the DevSpanner beta lanes. Your savings depend on the mix of work; open-weight lanes run on hardware or hosting you provide, so compute costs still apply.
The console is the foundation. The point is a developer AI workbench with every lane and every tool in reach. Early-access members get each piece as it lands and shape what comes next.
Frontier models side by side, grouped by vendor, switchable per message.
Every session on your machine, searchable, resumable, forked on continue.
Live topology across five regions with real link profiles, routing trace, per-job lane, timing and token accounting. Hidden by default; show it when you want to watch the swarm.
The manager keeps the thinking; the cheap parts of a job go to cheaper lanes. The trace says what was delegated and what share of tokens it took.
Questions, fixes and vibes answered in seconds on the lane you pick, routing shown, several sessions open at once.
Define, plan, run, verify, review. Several projects in flight, checkpointed, running overnight while you sleep.
The manager interviews you until goal, outputs, checks and constraints are nailed down, because a good brief is most of a good result.
Express, standard and overnight, priced in tokens, chosen per project and changeable per task.
Repeated context is served from cache at a fraction of the price, and every job shows the share it got from cache.
An intent gate and typed judgments run before the expensive compute, so routing decisions cost almost nothing.
The console knows node health, capacity and routing at the moment you ask, and can tell you.
Unhealthy nodes drop out, spares are promoted, saturated nodes shed load, and jobs reroute without you noticing.
Thirty-plus frontier, open-weight and custom builds as selectable lanes, with status per model.
Kimi, DeepSeek, Qwen, GLM and Llama lanes hosted on the mesh, with zero per-token cost.
In-house builds on open weights, tuned for your codebase, served as lanes.
Contribute idle hours on your schedule, sandboxed, with hard limits, and bank mesh tokens for every job served.
Enter your off-peak hours or pick a tariff, and your machines share only in the cheap windows.
Share when your solar or battery has spare, or when the grid's carbon intensity is low, using the public feed.
Add as many machines as you like to one account, each with its own schedule and limits, and see them all on one screen.
One wallet for the whole fleet: what each machine earned, what you spent by day, and the balance carried forward.
File, shell and browser tools run behind a permission card you can actually read. There is no bypass mode, by design.
Worker sessions run each task with fresh context, visible in the trace, allowed only the edits and commands the brief pre-approved.
Run open-weight models on your own hardware and route to them like any other lane.
Share a session or a fork with a colleague, with the routing trace intact.
Spend by lane, by project and by day, with the savings from hand-offs and shared tokens broken out.
We're onboarding developers in small batches while the tools work lands. Leave your email and we'll send an invite when your batch opens.