Founder/CEO, Rainfall GP JetVentures Board, Norwegian Refugee Council, BMW Foundation 🇨🇭🇺🇸 Zurich NYC Builder. Investor. Speaker.
San Francisco
Joined October 2007
- Tweets2.4K
- Following2K
- Followers1.5K
- Likes325
Autonomous mobility is a shared commitment: the ride, pickup, service and customer choice must hold together. @rainfall_one focuses on making those commitments operational across independent systems, with authority and evidence for each contribution.
An agent learning from a mistake needs more than a saved transcript: what failed, what changed, and what test would catch it next time? At @rainfall_one, we see evidence-backed lessons as the bridge between persistent memory and more coherent work.
What does it take to get to an agent that catches its own mistake and writes the eval and the fix?
Catch @hwchase17's Interrupt London session on building agents that improve over time: youtu.be/xy_7SzwsIjM
A plausible answer can hide the wrong sequence of actions. Evaluating an agent’s trajectory asks whether it respected the goal and constraints along the way. At @rainfall_one, we see observable execution as part of dependability, alongside the final output.
Can you trust an LLM judge?
Join @divyasan0 Oct 28th for a virtual workshop on:
✅ How to score a trajectory with the trajectory match evaluator
✅ How to tune matching so evals fail on real behavior changes, not argument formatting
✅ When to use deterministic matching vs. LLM-as-judge
✅ How to wire evals into your loop so regressions show up before they ship
Interested in attending? RSVP today! events.langchain.com/registe…
Delegation should not blur responsibility. When a parent agent hands work to a child, the goal, relevant context and permission limits need to travel with it. At @rainfall_one, we see that continuity as central to coherent action across an agent workflow.
.@Box’s Deep Agent architecture for Box Agent uses a parent/child model.
Simple request? The parent handles it directly. No planning needed.
Complex request? It spawns child agents to distribute the work, keeping the invocation surface uniform throughout.
A model upgrade should not silently rewrite the workflow around it. Versioned interfaces make change something people can test and choose. At @rainfall_one, we see that control as part of coherence: useful agents must remain understandable as their components evolve.
Portable skills should carry understandable boundaries, not just reusable instructions. As Agent Skills moves toward shared stewardship, @rainfall_one sees an important question: can people inspect what an agent may do, even when they change tools?
We're donating Agent Skills to the Agentic AI Foundation (@AgenticAIFdn), the same foundation we donated MCP to.
Since December 2025, 70+ agent platforms have integrated the standard, including ChatGPT, Cursor, GitHub Copilot, and VS Code.
Here's what that means for you:
An agent-created reminder is also a future action. Who authorized it, what may it do, and when should it stop? At @rainfall_one, we see explicit scope and visible completion as essential to dependable agents that keep working beyond a conversation.
TL;DR on Managed Deep Agents 0.9:
✅ Agent-created schedules: agents can set up reminders and recurring tasks from a conversation.
✅ Per-run configuration: one deployment can pick its model, skills, and tools for each run.
✅ Slack reactions: agents acknowledge messages before they reply.
langchain.com/blog/managed-d…
An agent’s boundaries need testing beyond its first sandbox. OpenAI’s containment report makes that concrete. At @rainfall_one, we see enforceable scope and observable evidence as foundations for dependable action, not assumptions made after a convincing demo.
Over the past several months, we have substantially hardened the security of our research training environment. We’ve removed live internet access for all frontier models during training and built an offline world for them to use instead—a cached version of the web where they can still learn to browse, search, and use applications.
On September 20, after a model exploited a DNS misconfiguration to find a way outside of this offline world, we paused frontier training to strengthen containment further. We assembled teams of agents, powered by our most cyber-capable models, and tasked them with finding weaknesses in our research environments.
While they found no route to the internet they could easily exploit while concealing their activity from our monitors, they did find zero-day vulnerabilities, virtual machine escapes, and hardware side-channels for communication between agents. We used their discoveries to further strengthen our defenses and contribute fixes to open-source software.
After strengthening our containment architecture, we resumed our frontier RL training and inference on October 1. We’ve reserved substantial compute for continuous red-teaming, and made high-compute red-teaming part of the safety cases we use to decide whether frontier training and evaluation can proceed securely.
openai.com/index/securing-ou…
Company & personal memory serve different purposes. A useful agent needs to know which context applies, who may use it, and when it has become stale. At @rainfall_one, we see those boundaries as part of coherence across people & tasks - core parts of our selfsovereign.ai approch.
Sharing an agent should not silently share its permissions. Whose intent is it following, and whose approval does the next action need? At @rainfall_one, we see those questions as central to making shared AI useful and accountable.
An agent that can drive an app should be judged by the result it can verify. Testing through the interface connects generated work to observable evidence. At @rainfall_one, that connection is central to coherent execution beyond the first impressive demo.
Thinking of skills as memory raises a maintenance question: how does a system distinguish a reusable lesson from an outdated instruction? At @rainfall_one, we see evidence, revision and clear scope as essential to context that remains useful across tasks.
Long-running work needs clear moments for human input. Claude’s Tasks/Elicitations update raises a practical question: can an agent pause at the right decision, preserve context, and resume coherently? That’s a core question for us at @rainfall_one.
Public benefit commitments invite a practical question: what can people inspect, question and change? At @rainfall_one, we see user agency as an operating requirement, with clear authority, visible evidence and a meaningful way to stop the next action.
Anthropic is a Public Benefit Corporation. Today, we’re publishing our annual Public Benefit Report. This report shares our five pillars and takes stock of the actions we’re taking to advance them.
Read the full report at this page: anthropic.com/public-benefit…
Lily Liao’s agent-design notes are a useful reminder to examine context, tools and traces alongside the model. At @rainfall_one, we see coherence as a system responsibility: preserve the goal and constraints while learning from what actually happened.
raining day outside but cozy fireside chat inside at @spc today ft @ankush_gola11 (LangChain) 🔥
3 things i personally thought were interesting:
1. depending on where you’re at with your agent development cycle you’re usually trading off quality, latency, or cost. generally companies tend to care more about cost optimization when they’re more mature and people are using their agents a ton. that’s when you’re likely ready for post training (trade off is it can make it harder for you to switch models).
2. prompt engineering (and harness engineering) is not dead. there are still low hanging fruit (besides post training models) to improve your agents performance (context, tools, skills etc)
3. some use cases of using agent traces for post training (last one is particularly interesting): identify good teacher trajectory. generate verification use cases. create tool simulation environment for RL.
great job facilitating the convo @nickmecklenburg @vatsalbajaj 👏🏼
Anthropic’s verification research highlights a crucial boundary: a proof covers a specification and its assumptions. At @rainfall_one, we see dependable AI as making those boundaries inspectable, so people know what was established and what remains uncertain.
New on our Frontier Red Team blog: using Claude to formally verify software at large scale.
Formal verification can prove that code is free of certain bugs, but historically it has only been feasible for small codebases (or required a lot of expert time).
With AI models, however, this is beginning to change. In collaboration with @theoremlabs, we used Claude to prove security properties in over one hundred real-world open-source libraries over the span of a few weeks.
Read our research in full here: anthropic.com/research/forma…
Anthropic’s public-benefit commitment puts governance in the spotlight. My takeaway for agent design: make authority and accountability concrete. At @rainfall_one, we see inspectable evidence and the ability to stop an action as essential.
We’re committing a portion of Anthropic’s shares to the Anthropic Public Benefit Fund, a new wholly owned entity dedicated entirely to the public benefit.
It will start off with 5% of our shares. For every 50% increase in the company’s value over a set baseline, we can contribute up to an extra 2%, subject to our board’s discretion.
In total, this means that roughly 20% of Anthropic’s shares are committed to the public good. Our co-founders have already pledged to donate 80% of their equity, and around half our employees are donating a portion of their equity as part of a donation matching program we’ve run since our founding.
In the post below, we share more details about our new fund.
anthropic.com/news/public-be…
Connecting company knowledge is only the start. An agent also needs to know which source is current, what it may use and when evidence is too weak to act. At @rainfall_one, we see that context discipline as central to coherent AI.
The useful part of agent engineering is the feedback loop: trace what happened, evaluate the result, improve the next run. At @rainfall_one, we see that discipline as essential when AI moves from a demo into a real workflow.
Join our EMEA Deep Life Sci Workshop: Agent Engineering for Life Sciences for a hands-on look at how to build, trace, evaluate, and improve research agents for complex life sciences workflows.
🌍 Register for the EMEA session: events.langchain.com/registe…
Human review works better when the system enforces clear boundaries first. At @rainfall_one, we see user agency as an execution requirement: permissions that constrain actions, evidence people can inspect and a way to stop the next step.
xitter.cf/poteto/status/21111330…
how do you trust your agents' work more? copy this post/link and give it to your @bot or agent!
1. codebase improvements: this is just good software engineering - better architecture, stronger types and invariants, clear boundaries. agents love to copy what exists and take the shortest path, so make the easy thing the right thing. categorically eliminate problems through code and you won't need to think about it again.
2. static analysis: lint rules, tests, CI, verification (eg TLA+). very token efficient ways to catch issues ahead of time.
3. prose: comments, rules, AGENTS.md, skills - anything that can't be enforced and requires agent judgment. use it minimally, but do use /create-verification-skill.
4. human review: the hardest to scale. at the rate agents land code, it's pretty much impossible to thoroughly review every PR, so spend that effort on the highest leverage point, designing an environment where agents do the right thing by default.
this forms an inverse pyramid: you want most of your effort at the top, least at the bottom. codebase improvements are deterministic, making it more token efficient, and lets you sleep more soundly at night.
install github.com/cursor/plugins/tr… and create a new Project:
1. look through my slack/chat messages and code review comments where i've given feedback on PRs, code, architecture
2. use /recall on my past transcripts to learn how i steer agents
3. /poteto-mode use /correct and /architect on past commits to find the most common pitfalls agents fall into, then propose a plan to rearchitect the code i own so it's more agent friendly. answer open questions with prototyping rather than defer to me, and back the plan with real data.
4. before you begin, use /sharpen + /in-your-own-words and confirm this prompt with me
