a bunch of people at @LangChain are thinking about this new category of proactive agents. some great blogs on this topic: * new context eng challenges from @hwchase17: * why aren't you building proactive agents yet? from @ndrezn * building org harnesses from @caspar_br:

we've been focused on supporting more autonomous, proactive agents; here's what we shipped in deepagents this week: 1. browser use with @Stagehanddev, so your agent can work in a real browser, sometimes on your behalf! * blog: * deep dive: * docs: 2. async subagents, so the main agent remains available to a user while background tasks run * blog: * docs:

stagehand = browser tooling for agents this release features a bunch of enhancements that make lifecycle management easier in the agent loop we're using these in our new 1st party langchain-stagehand integration!

as we ask agents to do more work for longer, async subagents become a very important primitive async subagents enable - continuous human interaction w/ the main orchestrator, since it's not blocked by subagent work - efficient distribution of work across the background workers

i messed up the code block formatting in my blog on "browser use for deep agents" the design agent we tested browser use in fixed it, then used browser use to validate the change. great example of how browser use enhances testing, very full circle!

would love to see some more agent native APIs for uploading articles on @X! the current MCP tooling has ambiguous errors that make it hard for a model to troubleshoot / use correctly i will happily test :)

full transparency, things that went wrong during the filming of this demo... - almost booked a reservation that required a HUGE downpayment / cancellation fee bc my card was saved on resy, so the agent could just book+pay - hit rate limits w/ resy bc i simulated log in so many times trying to get the demo right browser use is a relatively new primitive for agents, so it makes sense that we're working through some growing pains the hardest things rn seem to be guardrails + working at scale

if you give your agent a browser, it can do work on the web, even on sites w/ no agent native APIs! in this demo my agent books dinner reservations for me. i only had to log into the reservation site once; it saved my login and acts on my behalf for every new session!

this piece is worth the read, but quite dense. here's my (relatively) brief breakdown: super agents are defined by 4 characteristics: - continuous: one agent across threads and access points - productive: responds quickly and completes work efficiently - proactive: responds to events in its environment - persistent: durable execution for high availability and crash recovery these constraints apply to personal agents and agents doing commercial work alike, so the underlying architecture should look similar the primitives behind them: - two level architecture: a router layer keeps interaction continuous, and a worker layer runs tasks concurrently - event driven design: the agent reacts to events in its environment and can schedule runs toward a long term goal - multi channel interaction: context carries across channels, and async execution keeps the agent productive - separate compute, state, and environments: the "separate the brain from the hands" idea, which supports persistence and security and lets the system scale - watchdog: an independent control loop that keeps the whole thing running they're upfront about what's still open: - reliable scale - representing tasks and work without the "session" primitive - agent to agent communication and context standards - security and privacy, as always their core claim is that models need less and less human intervention on individual tasks, so the bottleneck to further productivity gains is shifting to human attention which raises the question i'm most interested in: how do we design human-agent collaboration when human attention is the bottleneck?

The @LangChain team evaluated 7 different Browser Tools to power Managed Deep Agents. It's no surprise that Stagehand was simultaneously the fastest, cheapest, and most accurate. Read the full report to learn how.

we're hosting an event on thursday at the @LangChain office with @allietheicon from @typesafeai to chat about all things jev! come learn about - where jev fits in the agent loop - why jev is a "system one" model - jev as a judge for evals

earlier this ~spring, models got good enough to drive browsers in some ways, browsers are the new terminal! a general purpose tool one difference is there is a few different ways to design tools to drive the browser. @sydneyrunkle deep dives into how we did this for MDA

browser use is an important primitive for agents, but it's hard on the agent's context window: 1. tasks are long running, w/ tons of sequential tool calls 2. web pages carry a lot of content that's irrelevant to the task so tool design really matters. we chose @Stagehanddev from @browserbase, a toolset built for agents navigating the web. this blog dives into how we selected that toolset, and how we upstreamed optimizations we found from looking at suboptimal agent trajectories in langsmith traces

joined @TalkPython w/ @mkennedy, @reuvenmlerner, @calvinhp, and pat decker to talk about "the state of python in 2026" so much of it came back to development w/ agents! harnesses, observability, and why ~90% of my coding happens in slack now

"it's underrated how hard it is to build agents!" great convo w/ @hwchase17 and @HarryStebbings on @twentyminutevc an agent = model + context + harness, and you can improve an agent by tweaking any of the three. a few takeaways: 1. the highest roi thing you can do is start by optimizing context (then the harness, then the weights); this is where domain knowledge lives and that's incredibly valuable 2. the story of continual learning is: run an agent, collect traces, aggregate learnings, fix something, measure the fix, loop! the fix can land in any of the three layers. those fixes all look different but the cycle is the same. 3. memory is still massively unsolved, but also massively important. the hardest part is distilling learnings from traces which is incredibly domain specific. 4. when you build agents, you're probably worried about a few things: accuracy, cost, latency, and security. we've seen these themes confirmed year after year in our dev surveys 5. when we think about reducing cost, the pipeline looks like adding visibility into spend, putting controls in place, and only then pushing on agent optimizations. this is how we reduced our coding agent spend @LangChain 6. model routing, which is great for cost controls, is most effective in the harness (where the context needed for a routing decision lives) 7. open models are used for more narrow tasks right now (small parts of the agent loop OR for very specific domains w/ post-training), but as they improve they'll power more core agent loops 8. we're looking at a future with both horizontal agents and vertical agents. horizontal agents will use the vertical agents, and infra needs to change to support this load (agents can do background work at a rate that humans cannot).