want to build a company brain like stripe?
they built it on deepagents, an open source harness. itβs super easy to customize, you can connect to any data source under the sun, and its model agnostic!
https://t.co/TlXAJfmFnD
The team at @stripe is setting the standard for internal AI platforms: minion coding agents, a custom prototyping rig, and now their company brain, Kai.
On today's episode of How I AI, Sharadh shows us how 1.5 engineers and 2 weeks got them a company brain, including:
- projects as governance
- skill routing + telemetry
- a skills platform that works for 10k teammates
Plus, he and I debate the merits of gentle parenting your AI (esp when your company is running evals.)
Full episode on YT: https://t.co/2MiumBjBNH
we just dropped a new landing page for our oss tooling!
good overview here of how deepagents, langchain, and langgraph all fit together and when to use each
https://t.co/RzjzFPVj7e
subagents are great for parallelizing work and delegation to specialized agents, but it's hard to figure out exactly what context to pass to and return from subagents!
this guide details the two input context modes we now support
1. isolated -- subagent gets a completely new prompt
2. forked -- starts exactly where the main agent left off, with a copy of the old message history
as well as when you might want to use each!
Agent auth is hard, but it shouldn't be!
Your agent needs to act as someone: sometimes that's one shared identity, sometimes it's the person asking. To get either right you'll need an OAuth app for each service, a token store, refresh logic, and a consent flow
Today we're fixing this with Managed Connections: define who your agent acts as in code, and the rest is handled for you:
πππππ -> agent uses its own token
ππππ -> agent uses the user's token, guiding them through the consent flow if they haven't connected yet
With a single argument you avoid the whole OAuth dance. Available now, in πππππππ-ππππππππππ 0.7
This is very similar to how we think about context management in Deep Agents: compaction should reduce what is sent to the model, not erase the underlying work history.
In Deep Agents, the logic is:
- every agent gets a filesystem to work with (can be real or virtual)
- when a tool result is too large, we write the full result to the filesystem (/large_tool_results) and replace the model-visible message with a preview
- when the conversation gets long, we offload older messages to the filesystem (/conversation_history) history first, then generate a summary
- the agent can also decide to compact proactively via a compact_conversation tool, which uses the same offload + summarize logic
Summarization middleware with all this logic: https://t.co/kSVB0ykqOz
I just used instinct and stripe link to buy my niece a hot pink pianoβ¦ entirely from the messaging interface π€―π€―
Instinct was even kind enough to find me a 15% off discount!!!!
ICYMI -- yesterday we released support for the new MCP protocol in @LangChain !! what do you need to know?
1. MCP support is now in the main langchain package! get started with `uv pip install 'langchain[mcp]'`
2. it's now built on top of FastMCP v4; FastMCP has ergonomic support for all things MCP (clients, servers, and apps). FastMCP handles things like protocol negotiation, tool name conflicts, connection lifecycle, transport specs, auth, and caching!
3. langchain now supports elicitation (MCP's human in the loop concept) via interrupts!
4. langchain now supports list_tools caching (so you don't have to re-fetch on every agent run; this was a common pain point for TTFT!)
5. the new protocol is stateless, which means the agent <-> server interactions are more efficient, and much more scale-able.
mcp is alive and accelerating:
- mcp's tier 1 sdks are nearing 500m dls per month
- mcp went stateless, making servers much easier to scale and redeploy
- HITL is now native to the protocol
- tool discovery can now be cached for faster agent startup
now in πππππππππ
Weβre looking for someone to lead SmithDB at LangChain!
SmithDB is the database weβve built from the ground up to power LangSmith. Itβs optimized specifically for the access patterns that emerge when youβre storing and querying enormous volumes of agent traces.
Itβs serving production traffic at significant scale with great performance, but itβs still early. The problems we are solving are genuinely fun and very hard: indexing, query execution, compaction, ingestion specifically for agent observability + making all of this fast and cost-efficient at massive scale.
Weβre looking for an exceptional engineering leader to take ownership of this critical project. Youβre likely a great fit if youβve built database or distributed systems, led strong engineering teams through technically demanding projects, and have exceptional execution and project management skills.
Apply here or DM me directly: https://t.co/Pqy0AfYCFO
Learn more about SmithDB here: https://t.co/bjus8tSSfG
we now support the new stateless MCP spec in @LangChain!
we've revamped our entire MCP integration. It now lives in the main langchain package, elicitation works via interrupts, and list endpoints are cacheable.
the new adapter is built on top of FastMCP! FastMCP ships with first class transports, auth, connection management, protocol negotiation, caching, callbacks, and more.
FastMCP v4 is out! This is what we built @LangChain's new MCP adapter on top of.
one of the nicest pieces here is you can connect a client to multiple servers on different protocol versions + FastMCP handles all of the negotiation under the hood.
Agent workspaces should be durable, inspectable, and swappable
Deep Agentsβ virtual file system is intentionally behind a BackendProtocol, so the agent code can keep using read/write/glob/grep while teams choose the storage layer that fits production
Nice to see MongoDB support this!