Vercel Open-Sources durable-harness for Crash-Proof Coding Brokers

Vercel has launched durable-harness, an open-source package deal that retains coding agent periods alive by means of crashes and timeouts. Vercel durable-harness wraps current harnesses, together with Pi, OpenCode, Claude Code and Codex, with out altering them. Every session lives in a sturdy log. A useless perform now not means misplaced work. For groups shifting brokers off laptops and into the cloud, that closes an actual hole.

TL;DR

Dimension: npm package deal, model 0.0.x, Apache-2.0. Adapters cowl 5 harnesses: Pi, OpenCode, fx, Claude Code, Codex.
Runs on: Vercel Capabilities plus Vercel Queues, Node.js 22+ with Postgres, or laptop computer recordsdata. Claude Code and Codex want a Vercel Sandbox.
Efficiency: No latency or throughput benchmarks printed. All restoration claims are self-reported by Vercel.
Greatest: Completed mannequin and gear calls are learn again from the log, by no means re-run or billed twice.
Worst: Experimental 0.0.x API. Claude Code and Codex run solely in a Vercel Sandbox, even self-hosted.

What’s durable-harness?

durable-harness is a set of adapters from Vercel that retailer a harness session in a Workflow SDK World. A World bundles storage, a queue and a stream behind one interface. The package deal makes use of the identical equipment that powers Vercel’s Workflow SDK.

Why do coding brokers lose work within the cloud?

Harnesses like Pi and Claude Code had been designed as long-lived native processes. They preserve the session in reminiscence. Regionally, the workspace and historical past sit on the identical disk, so resuming takes 1 immediate. Within the cloud, a VM with persistent storage doesn’t monitor which calls accomplished. Vercel workforce notes a failed flip or community error then means misplaced work.

How does durable-harness work?

It writes every step of a flip to a sturdy log. Earlier than a mannequin or instrument name runs, it information an intent. When the decision finishes, it information the end result. Every flip is backed by a message on Vercel Queues. If the perform dies, the queue arms the flip to a brand new perform. That perform reads the log and continues.

After a crash, the log exhibits what completed, what was working and what by no means began:

Accomplished calls are learn from the log, so completed mannequin tokens usually are not billed once more.
replay: 'secure' instruments, similar to lookups, can run once more.
replay: 'by no means' instruments, similar to refunds, by no means run twice. The mannequin is informed the decision might have occurred.

Harness session recordsdata are mirrored into the log as properly. That covers Claude Code’s transcript, Codex’s rollout and OpenCode’s occasion retailer.

The place do recordsdata and shell instructions run?

Mannequin-chosen instructions by no means run on the perform’s personal disk. The instruments docs record 3 workspace choices:

digital() retains recordsdata within the session log, with a bash-compatible shell and no community. It holds about 500 recordsdata.
digital({ sturdy: false }) retains scratch recordsdata in reminiscence and clears them each flip.
sandbox() provides every session a Vercel Sandbox, with /workspace on a Drive.

Typed JSON paperwork, similar to a to-do record, additionally reside within the log. Every holds at most 64 KB.

<div class="pane on" id="p1">
<div class="cols">
<div class="field"><h4>With out sturdiness <span class="tablet">state in reminiscence</span></h4>
<ol class="steps" id="sA"></ol>
<div class="stat"><span>Steps run twice <b id="aRe">0</b></span><span>Mannequin calls <b id="aMc">0</b></span></div>
</div>
<div class="field"><h4>With durable-harness <span class="tablet">state in log</span></h4>
<ol class="steps" id="sB"></ol>
<div class="stat"><span>Steps run twice <b id="bRe">0</b></span><span>Mannequin calls <b id="bMc">0</b></span></div>
</div>
</div>
<div class="btns">
<button class="b" id="go"> Run flip</button>
<button class="b crimson" id="kill" disabled>Kill perform</button>
<button class="b ghost" id="rst">Reset</button>
</div>
<div class="log" id="lg"><div>Press Run flip, then kill the perform whereas CI is working.</div></div>
<p class="be aware">State of affairs from Vercel’s submit: an agent provides a pricing web page, opens a PR, and waits for CI. Illustrative simulation, not a benchmark.</p>
</div>

<div class="pane" id="p2">
<p class="sub" model="margin-bottom:12px">Click on a instrument, then crash it mid-call.</p>
<div class="guidelines">
<div class="field instrument sel" data-r="secure"><h4><code>get_order</code><span class="tablet">replay: ‘secure'</span></h4><span class="be aware">A lookup. Protected to repeat after a crash.</span></div>
<div class="field instrument" data-r="by no means"><h4><code>refund_order</code><span class="tablet">replay: ‘by no means'</span></h4><span class="be aware">A refund. Mustn’t ever run twice.</span></div>
</div>
<div class="btns"><button class="b crimson" id="crash">Crash mid-call</button></div>
<div class="verdict" id="vd">Decide a instrument and press Crash mid-call.</div>
<pre id="code">{ identify: ‘get_order’, replay: ‘secure’, … }</pre>
</div>

<div class="pane" id="p3">
<div class="ws">
<div class="field sel" data-w="0"><h4><code>digital()</code></h4><span class="be aware">Information within the session log. Bash-compatible shell, no community.</span></div>
<div class="field" data-w="1"><h4><code>digital({sturdy:false})</code></h4><span class="be aware">In-memory scratch. Cleared each flip.</span></div>
<div class="field" data-w="2"><h4><code>sandbox()</code></h4><span class="be aware">Per-session Vercel Sandbox, <code>/workspace</code> on a Drive.</span></div>
</div>
<div class="field" model="margin-top:14px" id="wsd"></div>
</div>

<div class="pane" id="p4">
<div class="worlds">
<div class="field world sel" data-g="0"><h4>Vercel</h4><span class="be aware">Vercel World + Agent Runs traces</span></div>
<div class="field world" data-g="1"><h4>Laptop computer</h4><span class="be aware">Native recordsdata, zero config</span></div>
<div class="field world" data-g="2"><h4>Self-host</h4><span class="be aware">Postgres World, Node.js 22+</span></div>
</div>
<pre id="wc"></pre>
<p class="be aware" id="wn"></p>
</div>

<div class="pane" id="p5">
<desk>
<tr><th>Harness</th><th>Bundle</th><th>Runs in</th><th>Standing</th></tr>
<tr><td>Pi</td><td><code>durable-harness/pi-durable</code></td><td>Your perform + digital workspace or Sandbox</td><td class="y">Supported</td></tr>
<tr><td>OpenCode</td><td><code>durable-harness/opencode</code></td><td>Your perform + digital workspace or Sandbox</td><td class="y">Supported</td></tr>
<tr><td>fx</td><td><code>libfx</code></td><td>Sturdy by itself</td><td class="y">Supported</td></tr>
<tr><td>Claude Code</td><td><code>durable-harness/claude-code</code></td><td>Vercel Sandbox solely</td><td class="n">Experimental</td></tr>
<tr><td>Codex</td><td><code>durable-harness/codex</code></td><td>Vercel Sandbox solely</td><td class="n">Experimental</td></tr>
</desk>
<p class="be aware">Claude Code and Codex are single-user CLIs that preserve state on disk, so every session will get its personal Sandbox.</p>
</div>

<div class="ft"><span>Supply: vercel.com/weblog/making-every-harness-durable · Vercel docs · Oct 2026</span><b>© Marktechpost</b></div>
</div>
<script>
(perform(){
var R=doc.getElementById(‘mtp-dh’);
perform $(s){return R.querySelector(s)}perform $$(s){return R.querySelectorAll(s)}
perform rz(){attempt{guardian.postMessage({mtpEmbedHeight:R.offsetHeight+40,id:’mtp-dh’},’*’)}catch(e){}}
$$(‘.tab’).forEach(perform(t){t.onclick=perform(){$$(‘.tab’).forEach(perform(x){x.classList.take away(‘on’)});$$(‘.pane’).forEach(perform(x){x.classList.take away(‘on’)});t.classList.add(‘on’);$(‘#’+t.dataset.t).classList.add(‘on’);if(t.dataset.t===’p3′)ws(cur);setTimeout(rz,60)}});
var S=[[‘model’,’Plan the change’,1],[‘read’,’app/page.tsx’,0],[‘write’,’app/pricing/page.tsx’,0],[‘run’,’gh pr create’,0],[‘wait’,’CI checks on the PR’,0],[‘model’,’Reply with the result’,1]];
perform draw(id){var o=$(id);o.innerHTML=”;S.forEach(perform(s){var li=doc.createElement(‘li’);li.innerHTML='<span class="okay">’+s[0]+'</span>’+s[1];o.appendChild(li)})}
var i=0,tm=null,killed=false,ma=0,mb=0;
perform log(t,c)
perform reset(){clearTimeout(tm);i=0;killed=false;ma=mb=0;draw(‘#sA’);draw(‘#sB’);$(‘#aRe’).textContent=0;$(‘#bRe’).textContent=0;$(‘#aMc’).textContent=0;$(‘#bMc’).textContent=0;$(‘#go’).disabled=false;$(‘#kill’).disabled=true;$(‘#lg’).innerHTML='<div>Press Run flip, then kill the perform whereas CI is working.</div>’}
perform li(id,n){return $(id).kids[n]}
perform step(){if(i>=S.size){$(‘#kill’).disabled=true;log(‘flip full’,’o’);return}
[‘#sA’,’#sB’].forEach(perform(id){var e=li(id,i);e.className=”run”});
log(‘intent ‘+S[i][0]+’ ‘+S[i][1],’i’);
tm=setTimeout(perform(){[‘#sA’,’#sB’].forEach(perform(id){li(id,i).className=”completed”});if(S[i][2]){ma++;mb++;$(‘#aMc’).textContent=ma;$(‘#bMc’).textContent=mb}log(‘end result ‘+S[i][0]+’ okay’,’o’);i++;step()},i===4?1800:700)}
$(‘#go’).onclick=perform(){reset();$(‘#go’).disabled=true;$(‘#kill’).disabled=false;$(‘#lg’).innerHTML=”;step()};
$(‘#rst’).onclick=reset;
$(‘#kill’).onclick=perform(){if(i>=S.size)return;clearTimeout(tm);killed=true;$(‘#kill’).disabled=true;var okay=i;
li(‘#sA’,okay).className=”useless”;li(‘#sB’,okay).className=”useless”;log(‘perform 1 died at step ‘+(okay+1),’x’);
setTimeout(perform(){log(‘with out sturdiness: handbook restart, flip begins over’,’x’);
draw(‘#sA’);var re=0,j=0;(perform a(){if(j>=S.size){$(‘#aRe’).textContent=re;return}var e=li(‘#sA’,j);e.className=”run”;setTimeout(perform(){e.className=j<okay?’rerun’:’completed’;if(j<okay){re++;$(‘#aRe’).textContent=re}if(S[j][2]){ma++;$(‘#aMc’).textContent=ma}j++;a()},260)})();
log(‘with durable-harness: queue arms flip to perform 2′,’o’);
for(var q=0;q<okay;q++)li(‘#sB’,q).className=”fromlog”;
i=okay;(perform b(){if(i>=S.size){log(‘flip full, 0 steps repeated’,’o’);return}var e=li(‘#sB’,i);e.className=”run”;setTimeout(perform(){e.className=”completed”;if(S[i][2]){mb++;$(‘#bMc’).textContent=mb}i++;b()},450)})();
},600)};
reset();
var rule=”secure”;
$$(‘.instrument’).forEach(perform(t){t.onclick=perform(){$$(‘.instrument’).forEach(perform(x){x.classList.take away(‘sel’)});t.classList.add(‘sel’);rule=t.dataset.r;$(‘#vd’).textContent=”Decide a instrument and press Crash mid-call.”;$(‘#code’).textContent=rule===’secure’?"{ identify: ‘get_order’, replay: ‘secure’, … }":"{ identify: ‘refund_order’, replay: ‘by no means’, … }"}});
$(‘#crash’).onclick=perform(){var v=$(‘#vd’);v.model.opacity=0;setTimeout(perform(){v.innerHTML=rule===’secure’?'<b model="shade:#50e3c2">Resumed:</b> the interrupted lookup can run once more. Pi reruns it; Claude Code, Codex and OpenCode inform the mannequin it’s secure to repeat.’:'<b model="shade:#f5a623">By no means re-run:</b> the mannequin is informed the refund might or might not have occurred, so it will probably test first. Each harness waits for the log to document a ‘by no means’ name earlier than it begins.’;v.model.transition=’opacity .3s’;v.model.opacity=1;rz()},150)};
var W=[{t:’Short tasks and small workspaces’,f:[‘Files kept’,’In the session log’],m:[[‘Workspace size’,’about 500 files’,55]],x:’A crash mid-call leaves nothing behind, and the decision runs once more. Value: perform CPU plus log occasions and storage.’},
{t:’Scratch work inside a flip’,f:[‘Files kept’,’Cleared every turn’],m:[[‘Persistence’,’none across turns’,8]],x:’Nothing goes to the log. The mannequin is informed recordsdata are cleared. Value: perform CPU solely.’},
{t:’Actual tasks and long-running work’,f:[‘Files kept’,’On a Drive that outlives every Sandbox’],m:[[‘Isolation’,’1 Sandbox per session’,100]],x:’A command a crash interrupts might have partly run, and the mannequin is informed. Value: Sandbox and Drive utilization, plus a begin on first use.’}];
var cur=0;perform ws(n){cur=n;var w=W[n];$(‘#wsd’).innerHTML='<h4>Greatest for: ‘+w.t+'</h4><div class="be aware">’+w.f[0]+’: <b model="shade:#fff">’+w.f[1]+'</b></div>’+w.m.map(perform(m){return ‘<div class="meter"><i></i></div><div class="ml"><span>’+m[0]+'</span><span>’+m[1]+'</span></div>’}).be part of(”)+'<p class="be aware">’+w.x+’ Typed JSON paperwork reside within the log too, as much as 64 KB every.</p>’;setTimeout(perform(){$$(‘#wsd .meter i’).forEach(perform(e){e.model.width=w.m[0][2]+’%’});rz()},40)}
$$(‘.ws .field’).forEach(perform(b){b.onclick=perform(){$$(‘.ws .field’).forEach(perform(x){x.classList.take away(‘sel’)});b.classList.add(‘sel’);ws(+b.dataset.w)}});ws(0);
var G=[["// On Vercel: @workflow/world-vercel is picked automaticallynimport { claudeCode } from ‘durable-harness/claude-code’nexport const agent = claudeCode({ model: ‘anthropic/claude-sonnet-5.5′ })",’Sessions show up in Agent Runs with each model and tool call. Resumed turns appear in the same trace.’],
["# Local dev: @workflow/world-local, no configurationn# sessions live in .workflow-data by defaultnnpm install durable-harness",’The local World suits development and a single server with a persistent disk.’],
["# Self-host: 2 variables move every agent to PostgresnWORKFLOW_TARGET_WORLD="@workflow/world-postgres"nWORKFLOW_POSTGRES_URL="postgres://user:password@host:5432/database"",’Needs @workflow/world-postgres 5.0.4+ and Node.js 22+. It is a reference implementation: no route auth, no encryption, not tuned for scale.’]];
perform wd(n){$(‘#wc’).textContent=G[n][0];$(‘#wn’).textContent=G[n][1];rz()}
$$(‘.world’).forEach(perform(b){b.onclick=perform(){$$(‘.world’).forEach(perform(x){x.classList.take away(‘sel’)});b.classList.add(‘sel’);wd(+b.dataset.g)}});wd(0);
window.addEventListener(‘load’,rz);window.addEventListener(‘resize’,rz);setTimeout(rz,300);
})();
</script>
</physique></html>
“>

The place are you able to run durable-harness?

The agent code stays the identical throughout Worlds:

Vercel: the Vercel World, with each session traced in Agent Runs.
Native: recordsdata in your machine, with no configuration.
Self-hosted: the Postgres World, model 5.0.4 or later, on Node.js 22+. Vercel’s weblog additionally lists MongoDB, Redis and Turso.

2 surroundings variables, WORKFLOW_TARGET_WORLD and WORKFLOW_POSTGRES_URL, transfer an agent to Postgres.

How does durable-harness evaluate?

Characteristic	durable-harness	Temporal + OpenAI Brokers SDK	Inngest AgentKit	Cloudflare Brokers SDK
What it’s	Sturdiness adapters for current coding harnesses	Sturdy execution wrapper for OpenAI Brokers SDK	TypeScript multi-agent framework	Stateful brokers on Sturdy Objects
Wraps Claude Code / Codex	Sure, experimental, Sandbox-only	Not disclosed	Not disclosed	Not disclosed
Sturdiness backend	Workflow SDK World (Vercel, native, Postgres)	Temporal server or Temporal Cloud	Inngest orchestration engine	Sturdy Objects, Cloudflare Workflows
Language	TypeScript	Python	TypeScript	TypeScript
License	Apache-2.0	MIT (server)	Apache-2.0	MIT
Standing	0.0.x, experimental	GA since Mar 23, 2026	Not disclosed	Not disclosed

Key Takeaways

durable-harness logs each mannequin and gear name, then resumes crashed activates a brand new perform.
Completed calls are by no means repeated, so tokens usually are not billed twice.
Pi and OpenCode run in your perform; Claude Code and Codex want a Vercel Sandbox.
Self-hosting works with 2 env vars and a Postgres World.
It’s 0.0.x and experimental, with no printed benchmarks.

Try the GitHub repo, docs and Vercel’s announcement. All credit score goes to the researcher of this venture. Additionally, be happy to observe us on Twitter and don’t neglect to hitch our 150k+ML SubReddit and Subscribe to our Publication. Wait! are you on telegram? now you may be part of us on telegram as properly.

The submit Vercel Open-Sources durable-harness for Crash-Proof Coding Brokers appeared first on MarkTechPost.