Jason Steving

AI @ Temporal

[Jason Steving @JasonSteving]

The one Temporal Agent Harness explainer to rule them all

[Jason Steving @JasonSteving]

@Alezander9 Really insightful post. Main takeaway is that forking needs to be easy and efficient, then things like the technique you described start to fall out for free.

[Alexander Yue @Alezander9]

Subagents are the biggest cause of AI failures

In most harnesses:
1. Main agent writes a summary of what it knows
2. Subagent starts from that summary only, and makes assumptions
3. Subagent works and sends back a new summary of what it did

Same flaw as compaction: all summaries are lossy. This is how your assistant makes emails you never wanted, or purchases what you told it just to get the price of

So I tried something new: checkpoint agents

The initial agent has complete context of what needs to be done. And that input is already cached

Fork the session where it is. Send the fork ahead to do the task and it will do exactly what the main agent would have done; their context is identical

What is even better is when the fork finishes, the cache of the main agent is kept warm by the subagent (they share the same prefix)

I measured it on a 137k-token session with Opus 5.5:
→ Main agent does it on its own: 67 s, $0.38, context +8-17k
→ Checkpoint: 117 s, $0.68, context +2k
→ Classic subagent: 123 s, $0.57, context +4-5k

But here is what I found: avoiding large input is even more important than keeping cache. And most subagent tasks were done better either in series with retrieval, or split up to be parallel over fresh sessions from the start

I do not think there is a place for subagent delegation at all. There should either be a super-agent that orchestrates and does no work, or a long running agent that can retrieve from previous sessions, not a worker that completes tasks partially and delegates the rest to other workers

Don't design harnesses based on our assumptions of human behavior

[Jason Steving @JasonSteving]

@E_FutureFan @_philschmid @jmqcooper Take a look at Pydantic's Monty python sandbox interpreter for a better idea of how this works. Executing any host function from code mode exec yields to the harness to enforce guardrails and call the underlying impl.

See https://t.co/Hjxoaod2EI for hands on examples

[Jason Steving @JasonSteving]

I've been seeing exactly this. Code Mode is almost definitely the foundation for most useful agents going forward.

Picked up some very interesting techniques in here too: giving the code mode tool a host function to store and retrieve state from a prior execution is brilliant

[Philipp Schmid @_philschmid]

Are Agents soon going to have only 1 tool? We went from a handful of tools, to dynamic tool search, and now to collapsing everything into code mode.

Wrote down how Code Mode works, why a typed JS/Python sandbox can beat raw bash, and why MCP is going to go back strong in 2027. With an a minimal example for Gemini 4 Argon.

https://t.co/IsS9QfEmuD

If you plan to explore code mode i can recommend testing with pi! Easily hackable and comes with strong foundation.

[Maxim Fateev @mfateev]

Agentic AI demos are easy. Reliable production workflows are not. What does it take when workflows run for hours, span multiple systems, and hit failures? Join me on the Day 2 panel at @GovTechSG STACK 2026 in Singapore, Nov 4-5: https://t.co/vnaUCY7mUU

[Arpit Bhayani @arpit_bhayani]

If AI makes you 10x faster at coding, why is your team not shipping 10x faster? Amdahl's law has the answer...

The law says the overall speedup is capped by the part you did not speed up. With `p` as the fraction of the work you accelerate and `s` as the speedup on that fraction, speedup is computed as attached.

Now plug in some numbers. Say writing code is 30% of the time from idea to production, and AI makes that part 10x faster. The overall speedup is 1 / (0.7 + 0.03), which is about 1.37x. Even if coding is half of the cycle, you get about 1.8x.

These numbers are illustrative, so use your own, but the shape stays the same. The rest of the cycle is still there:

- Figuring out what to build
- Aligning product, design, and other teams.
- Code reviews, which are now more than ever
- CI and CD takes the same wall time as before.
- Debugging and incidents, where code that nobody on the team wrote line by line takes longer to understand.

In fact, it can get worse than Amdahl predicts.

Faster code generation increases the load on every stage after it, so the review queue grows and the bottleneck shifts. A team that writes 10x more code with the same review capacity is just building a bigger queue, unfortunately

So if you want the team to actually ship faster, measure the whole path from idea to production and find where work waits. Then apply AI there too: review, test generation, flaky test triage, deploy safety checks. Otherwise, you have optimized the part of the system that was never the constraint.

Speeding up the typing was always the easy part :)

[Temporal @temporalio]

Vibe Check: Agent Harnesses: What, Why, and When Not https://t.co/BZM8MQrNu5

[Jason Steving @JasonSteving]

Had a great time giving some live demos of the Temporal Agent Harness on @temporalio's Vibe Check livestream - thanks for having me @nyghtowl!

https://t.co/IP8b0kIRAU

[Jason Steving @JasonSteving]

I'm getting more and more bullish on Monty every day. Now just to somehow get early access to "Full Monty" to evaluate in my harness work at Temporal

[Pydantic @pydantic]

Taps the sign.

We need new sandboxing technology for a new world.

https://t.co/UznOV9x1JU

[Jason Steving @JasonSteving]

Couldn't have said it better myself. And durability shouldn't be the secondary afterthought bolted on later. Won't be long until we get the Temporal Agent Harness on that shortlist.

[elvis @omarsar0]

Learn to build a custom harness, folks.

Mods in Claude Code, DeepSeek Harness, and now Pi Durable.

What do these all have in common?

Increased extensibility.

Builders need coding agents and harnesses to be more malleable.

Say you are building a simple agentic app for your users, a personalized headless experience, a software factory, or a domain-specific harness; you will quickly find that the generic harness won't cut it. Sometimes you need a different behavior in the UI. Sometimes you just need to easily add a new feature/plugin. Or sometimes you just want to build a completely new experience, like multiplayer support.

You can build it from scratch, as I recommend. I mean, it's not that hard. But if you want to hit the ground running, where do you go? Pi Durable and DeepSeek Harness seem to want to solve that problem.

Users want more customization in their harnesses. And those builders who understand how to build and maintain one will win big time from this next phase of more malleable harnesses.

The battle of the best harness will be very different from the first wave of generic harnesses.

[Jason Steving @JasonSteving]

@steipete @sundarpichai Life goals right there lol

[Johann Schleier-Smith @jssmith]

Preview of WIP at Temporal. Agent Harness is in a different category from coding harnesses like Pi, Codex, or Claude Code. It’s an outer harness providing durability and policy. It mediates how your agents interacts with the world and with one another. Please give feedback!

[Jason Steving @JasonSteving]

Very much worth the watch (and so much more to show since this video was recorded!) exciting times

[Temporal @temporalio]

See a durable AI agent run end to end on the Temporal Agent Harness 👇

https://t.co/IyHzaJjdzv

[Jason Steving @JasonSteving]

Definitely agree, take advantage of the intelligence explosion. Your product gets better and your users paid the token costs rather than you. Filter for high value feedback with Jev and you've got something very useful on your hands.

[Brian Armstrong @brian_armstrong]

Every backend service should have a /feedback endpoint.

Agents are quickly becoming the heaviest users of most APIs. When one hits a missing feature or a bug, it should be able to say so right there, in a structured way.

If the request makes sense, another agent drafts the PR and a human approves it. Software that improves itself based on what its users actually tried to do speeds up recursive self improvement.

[Jason Steving @JasonSteving]

Monty is one of the most impressive pieces of software. Agentic code mode made so so easy. Built the Temporal Agent Harness's code mode on this excellent foundation. Excited to upgrade to Monty V1!

[Samuel Colvin @samuelcolvin]

Fuck it, still early but here goes ...

We've just released Monty v1 - a Python sandbox that starts in 1 millisecond, not 1.5 seconds.

I just ran 10k sandboxed scripts in 674ms, something that would take a cloud sandbox > 3 hours.

This removes the biggest drawback of letting agents write code. The future is fast.

Even better, it's open source, you can install it from PyPI, npm or Crates now.

Serviced platform coming soon. Please get in touch if you want to be a design partner!

Who should try it?

⚡ if you care about startup time, use Monty
⚡ if you care about long-lived sessions, use Monty - Monty can be dumped and resumed at any external function call
⚡ if you care about accessing functions in the agent/host, use Monty - Monty makes it trivial to expose local functions into the sandbox
⚡ if you care about scale, use Monty - Monty workers use as little as 2MB of memory, meaning you can run thousands of concurrent sandboxes on a single machine
⚡ if you care about security, use Monty - we've run 3 rounds of bounty program and thousands of researchers have tried to break into our sandbox, meaning it should be secure to run untrusted code

Who should avoid it?

🚫 if you like to take a coffee break while waiting for sandboxes to start, DO NOT use Monty
🚫 if you enjoy the challenge of routing API requests from sandboxes through your corporate network to access state in your agent without exposing secrets to the sandbox, DO NOT use Monty
🚫 if your agent really needs to install packages from PyPI, Monty won't help you yet (spoiler: it probably doesn't)

https://t.co/avO8TWY5gJ

[Jason Steving @JasonSteving]

https://t.co/YvXWmyHrOP

[Jason Steving @JasonSteving]

Really excited about this new wave of decision models. Models like Jev (or Laya, or even some small LLM) plug in perfectly to the Temporal Agent Harness as an auto mode evaluator. Define your approval criteria, opt your tools in, and you can flip on auto mode.

[Jason Steving @JasonSteving]

Jev powered "auto mode" in the Temporal Agent Harness is such a natural fit. Jev is a big unlock for efficient agent oversight. Very excited to see how straightforward it was to integrate along existing harness seams. More to come here for sure.

[Jason Steving @JasonSteving]

https://t.co/nsSiAw7noq

[Jason Steving @JasonSteving]

Getting access to agents from Slack + Discord was super straightforward thanks to https://t.co/KgDvYcCiHs! Was able to roll a chat server to route these chat app interactions to Temporal Agent Harness agents super easily.