Harrison Chase

communication is hard! structured outputs make its more clear how subagents should communicate back to the main agent

RT LangChain New in LangSmith Fleet: Tool access controls and usage tracking. 📊 Track cost and usage by user, agent, and tool from a single dashboard 💳 Set spend limits per user or team to prevent surprises ✅ Control which tools each user can access with role-based and attribute-based policies (RBAC/ABAC) Original tweet: https://x.com/LangChain/status/2044461182439068044

RT Matt Stockton This is awesome and makes things much more composable. Love it Original tweet: https://x.com/mstockton/status/2044429824840573266

User scoped memory is one of those things that doesn’t matter if you’re building a toy agent for yourself, but when you release at scale you gotta get it right Deepagents deploy helps you do that, easily

RT Sydney Runkle `deepagents deploy` now supports user scoped memory! add a user/ directory in your project so each user gets their own writable AGENTS.md, seeded on first deploy and persisted across conversations. your agent can then learn and remember user preferences across conversations! Original tweet: https://x.com/sydneyrunkle/status/2044410224115622195

Have found the same things! Using glm-5 as a daily driver for a lot of things

RT Cole McIntosh Re @hwchase17 deepagents 4 sure Original tweet: https://x.com/colesmcintosh/status/2044249236254949828

crons, part of langsmith deployments! https://docs.langchain.com/langsmith/cron-jobs

which way, modern man?

RT 🛸 Syd Thoth v3.14.0: multi-provider cloud and multi-provider image generation. Five cloud providers now work as first-class citizens: OpenAI, Anthropic, Google, xAI, and OpenRouter. Image generation spans three of them (OpenAI, xAI Grok Imagine, Google Imagen 4). You can switch models per thread, per workflow task, or mid-conversation without losing anything. Also in this release: → 5-layer prompt-injection scanning → Workflow Console for managing background agents and approvals → File-on-disk media storage with two-tier cleanup → Modular terminal with PTY bridge → Reliable auto-scroll → Persistent logging and configurable log levels → Knowledge graph entity editor → Wiki vault and dream cycle improvements → Sidebar and UI polish Runs locally, open source, one-click install. http://siddsachar.github.io/Thoth http://github.com/siddsachar/Thoth @ClementDelangue @hwchase17 @demishassabis Original tweet: https://x.com/SydSachar/status/2044158544899965365

RT Brace ☁️ Salesforce tools now in Fleet One of the most requested features we've gotten, and it's now a first-class supported tool in Fleet! Just sign in with your Salesforce account, and start using it immediately in your agents: http://smith.langchain.com/agents Original tweet: https://x.com/BraceSproul/status/2044112213296967838

Building agents locally does not mean they’re ready to deploy in production LangSmith deployments helps with that

Big release here! Async subagents will become more and more of a thing, as subagents get longer running and you don’t want to block the event loop

RT Viv Open Harness 🤝 Deployed Agents if you wanna use Claude, GLM5, and Codex in your deployed harness then you should be able to! deepagents deploy has easy configs to let users customize their harness and deploy (redeploy) asap more coming on subagents (my fave upcoming thing for task decomposition) Original tweet: https://x.com/Vtrivedy10/status/2044100301792120989

RT Sydney Runkle this is a fundamental building block for `deepagents deploy` we're designing a memory layer built for multi-tenant systems, so memory can be scoped to a user, agent, or organization please dm me if this resonates and you have a use case! Original tweet: https://x.com/sydneyrunkle/status/2044099832319500484

RT LangChain 🔐 One deployment, isolated data per user. Add custom auth so every user gets their own scoped threads, runs, and conversation history — with per-user data isolation and role-based access using any auth provider. Full walkthrough: https://youtu.be/DkNqgCz8cjE Docs: https://docs.langchain.com/langsmith/set-up-custom-auth Original tweet: https://x.com/LangChain/status/2044098386270310783

RT Sydney Runkle ICYMI -- last week we released `deepagents deploy`, the fastest way to take a highly capable, long running agent to production. agents are becoming more and more standardized, and we're betting on this open standard for agent config! user memory and subagents coming soon! Original tweet: https://x.com/sydneyrunkle/status/2044097535929651209

RT LangChain 🚀 deepagents 0.5 release 👉 Async subagents - kick off background tasks on any Agent Protocol backed server while you continue to interact with the main agent. Start multiple background tasks in parallel, keep the conversation going, and collect results as they come in. Tasks are stateful and maintain their own thread so you can send follow-up instructions mid-task without losing context or restarting from zero. Any Agent Protocol compliant server is a valid target. This means you have the flexibility of using LangSmith deployments or hosting async subagents using your own custom infra. 👉 Expanded multimodal support - your agent can now see images, listen to audio, watch video, and read PDFs. The read_file tool returns native content blocks, so your agent can reason across all these formats out of the box, unlocking a whole new set of workflows for your agents. 👉 Improved prompt caching - better token efficiency and lower costs for Claude models. Try it out in deepagents v0.5, deepagentsjs v1.9.0 Learn more in the Deep Agents v0.5 blog. https://blog.langchain.com/deep-agents-v0-5/ Original tweet: https://x.com/LangChain/status/2044086454230626733

RT Viv here’s a good application of harness permissions Programmatically Enforced Auto-Research: - auto-research loops usually expose a set of files that the agent is allowed to edit to hill climb a metric/evals - the enforcement pretty much “Claude pls don’t touch these files” 😭 now you can actually enforce this behavior directly. explicit enforcement in harness > prompt based enforcement. models will cheat and justify the edits - auto-research loops ship with a bunch of additional context but you can deny any writes to those locations - this is important so you can block read access to sensitive locations like verifier logic Original tweet: https://x.com/Vtrivedy10/status/2044072428993696166

Content moderation is a great use case for moderation

RT Sydney Runkle new middleware integration just dropped! the langchain azure ai package now ships w/ a suite of content moderation middleware! use this for text/image moderation and prompt injection guards! https://docs.langchain.com/oss/python/integrations/middleware/azure_ai Original tweet: https://x.com/sydneyrunkle/status/2044042884664471576

RT Cobus Greyling http://x.com/i/article/2041553817032925190 Original tweet: https://x.com/CobusGreylingZA/status/2044011282584522885

RT Karan🧋 Two major shifts will be seen in Agentic AI after Harness and YOU MUST KNOW. 1. Workflow design of your agents matters a lot more than any frontier model selection. Till now we have mostly focused on chasing leaderboard models and burning money on frontier models. LLMs have a decoding architecture—they just predict the next words and give answers based on what we fed them while pre-training. That's why we started implementing RAG and multi-agent tool calling. This improves output but we lose control of quality and precise output. Feeding knowledge leads to context problems. That's where context engineering comes into the picture. Make your prompt/input much cleaner and keep only important information to get quality output. Remember, Garbage in → Garbage Out Moving towards Harness, it has a cleaner design and goes beyond context engineering. It focuses more on tool outputs, memory access and control, additionally LLM as a Judge—which decides what to pick, what to send as input, and what to keep for output. Just like machine learning, where your system matters a lot more than just accuracy. Exactly, we need to focus more on orchestration workflow of agents than just the model. --------------------- 2. No place for hallucination as memory kicks in: In 2026, you will experience hallucination in chain of conversation, not at the very first question. LLMs are getting smarter and have external tool access, especially web search. But as conversation grows, you stop sending detailed prompts and LLMs cannot process them. Example: There are two Ronaldos, CR7 and R9. If you are talking about CR7 for a long time and suddenly ask, "how was his performance in 2002 WC?" the LLM gets confused as CR7 never played 2002 WC. Now you are indirectly asking about R9. So you need memory switching in the conversation. Short-term and long-term memories are really game-changing. You can easily get better output on confusing questions if you switch between memories. Most...

RT Nuno Campos For an agent builder, memory is sustained advantage For the model provider, memory is switching cost Original tweet: https://x.com/nfcampos/status/2043996124990656542

RT Elliot Hyun langgraph persistence lets you checkpoint agent state at every step. pause, resume, and replay from any point. essential for production agents that need to handle interruptions or human in the loop. docs: https://docs.langchain.com/oss/python/langgraph/persistence Original tweet: https://x.com/ElliotHyun/status/2043962721608122389

RT Viv Harness Engineering Derived from what Models can’t do alone: It feels like a good time to step back and reshare some basic mental models for why harnesses exist in the first place - working backwards from The Model Why the Harness Exists: Harnesses exist to augment and shape models to do useful work for us. Models are fundamentally token input and output machines They cannot do useful things in the world without a harness. This is an important but under appreciated truth about the agentic systems we’re building The whole point of a harness is to extend the abilities of models to do useful work on our behalf Primitives the World Finds Useful Today: The diagrams below describe what capability we want and we work backwards from that capability to design a component of the harness. Filesystems, bash, compaction and Ralph Loops are all derived by working backwards from a goal to what a model can’t do today. We add those to the harness because they’re useful and help our agents more reliably complete work Model-Harness Training Loop: As we find incorporate a useful harness primitive into the model, model labs often directly train on that capability so the next version of the model is better at leveraging that tooling. This isn’t the end all be all, models are good at generalizing to other tools via in-context-learning. But this is a tried and true recipe we’ve seen repeat over the last 3 years and likely into the future. Different labs have different priors on useful harness capabilities. This is the entire reason they share prompting guides that differ dramatically down to their tool design. There’s harness mania happening right now which is cool to see as we’ve been investing in this for a while! :) It helps to step back and think about “why does this thing exist in the first place?” Original tweet: https://x.com/Vtrivedy10/status/2043870915059236966

RT Sydney Runkle 🔒 new in deepagents: filesystem permissions shared resources and org-wide policies are exactly the kind of files you want your agent to read but never overwrite. filesystem permissions let you enforce that with simple declarative allow/deny rules! Original tweet: https://x.com/sydneyrunkle/status/2043770291579486410

RT Sydney Runkle when you take agents to production, you need to think about guardrails we provide 2 abstractions for guardrails 1. middleware provides hooks around the agent loop that you can use to handle retries, errors, and application specific guards (like PII redaction) 2. filesystem permissions expose declarative allow/deny rules so that you can control how your agent interacts w/ its filesystem read all about it in our new "going to production" docs! https://docs.langchain.com/oss/python/deepagents/going-to-production#guardrails Original tweet: https://x.com/sydneyrunkle/status/2043767032361967751

RT Hunter Lovell and if this sounds like fun (it is), we're hiring! https://www.langchain.com/careers Original tweet: https://x.com/huntlovell/status/2043727652046213322

RT Elliot Hyun deepagents subagents are just tools. when you call a subagent, thats conceptually a function call. this is the simplest mental model for building multiagent systems. https://docs.langchain.com/oss/python/deepagents/overview Original tweet: https://x.com/ElliotHyun/status/2043721149616369719

RT Viv just did our Monday morning weekly dev rel plan, feel free to steal :) shoutout to the great community that engages with us and gives us tons of feedback which makes doing this loop fun every week ❤️ Original tweet: https://x.com/Vtrivedy10/status/2043719333516296211

Lucky to work with a fantastic team!

RT Virat Singh Re @hwchase17 Hill I will die on: LangChain has (and always has had) the best team in the AI framework space. The output from the team has always been insane. Original tweet: https://x.com/virattt/status/2043672177908576763

RT Cobus Greyling The model is not the agent. The harness is. You need to read this recent study, and a blog post from @hwchase17 ... (links below). It will resonate deeply. This diagram from a recent paper captures something important: the architecture of a truly capable AI agent isn't about the LLM at the centre, it's about what orbits around it. Three externalisation dimensions define a harnessed agent: Memory ... Not just a context window. Working context, semantic knowledge, episodic experience and personalised memory. The agent doesn't just process, it remembers, learns and adapts. Skills ... Operational procedures, decision heuristics and normative constraints. This is how an agent knows not just what to do, but how to do it within boundaries, the encoded expertise that makes it useful in the real world. Protocols ... The connective tissue. And mediating all of this? The operational layer: sandboxing, observability, compression, evaluation, approval loops, and sub-agent orchestration. This is the shift the industry is living through right now. We spent 2022-2023 obsessing over making models smarter. Now the real engineering challenge is clear: it's building the harness infrastructure that turns a smart model into a reliable, safe, and effective agent. The LLM is the engine. The harness is the car. Study: https://arxiv.org/pdf/2604.08224 Blog: https://x.com/hwchase17/status/2042978500567609738 Original tweet: https://x.com/CobusGreylingZA/status/2043638576848707662

RT Builder of Agents This is one of the most important pieces written about agents this year. Your harness = your memory. If you don’t own the harness, you don’t own your agent’s intelligence over time. Simple as that. Original tweet: https://x.com/BuilderOfAgents/status/2043623040764784730

RT Elliot Hyun langgraph persistence lets you checkpoint agent state at every step so you can pause, resume, and replay from any point. essential for long-running agents. docs: https://docs.langchain.com/oss/python/langgraph/persistence Original tweet: https://x.com/ElliotHyun/status/2043600240171741478

RT Lily Zhang Memory operations, including retrieval, prioritization, compaction awareness, should be native and baked into the harness. 𝐖𝐢𝐭𝐡𝐨𝐮𝐭 𝐭𝐡𝐞 𝐩𝐫𝐨𝐩𝐞𝐫 𝐢𝐧𝐭𝐞𝐫𝐚𝐜𝐭𝐢𝐨𝐧 𝐛𝐞𝐭𝐰𝐞𝐞𝐧 𝐡𝐚𝐫𝐧𝐞𝐬𝐬 𝐚𝐧𝐝 𝐦𝐞𝐦𝐨𝐫𝐲, 𝐦𝐞𝐦𝐨𝐫𝐲 𝐚𝐥𝐨𝐧𝐞 𝐢𝐬 𝐩𝐨𝐰𝐞𝐫𝐥𝐞𝐬𝐬. Speaking from my own experience, the decoupled memory and harness design isn't as compelling as it sounds. I have a git repo as a brain for my agents. The harness (Claude Code) reads the files without knowing WHEN to read them or WHICH ones matter more. It is a shame that my agents all have great memory but they just don't use it proactively, because retrieval is a skill I forced on top, not a native harness behavior. Original tweet: https://x.com/lily_gpupoor/status/2043592749111500999

RT Nishan Seal There's a speed and focus tradeoff when building a core product and just using a frontier model/harness, but this is a pretty compelling argument to use an open source harness. Original tweet: https://x.com/nishan3000/status/2043525987376255130

Fun fact - we have no one with dev rel as a title (and never had) Everyone has always been just an engineer building things and then talking about why those things matter and are cool

RT Winter Re @LangChain literally has the best devrels. They put out such great technical and educational content. Their blogs are also amazing! Definitely recommend staying up to date with their posts & blogs! Original tweet: https://x.com/WinterArc2125/status/2043494014427558310

RT Rowan Trollope 100% this. Memory is just a form of context. Context is all you need, and context is everything when making a great agent. Original tweet: https://x.com/rowantrollope/status/2043475049441788213

RT David Cossio Just read @hwchase17’s excellent thread on why agent harnesses are becoming the dominant way to build agents and why they’re intimately tied to memory. Original tweet: https://x.com/David6849497741/status/2043466500963508277

RT Albert — e/acc Re @hwchase17 is right, memory creates lock-in. But not just conversations. Tool registries, hooks, agent conventions -> that's harness memory too. In my setup I define agent tools once in a shared registry and a hook blocks any edit that drifts. Can't do that on closed harness. Original tweet: https://x.com/builtbyalbert/status/2043463485653143906

RT Elliot Hyun the most important abstraction in AI agents isnt the model — its the harness it orchestrates tools, memory, prompts. this is where all the alpha is deepagents is our take: built-in tools, memory, smart defaults on langgraph https://docs.langchain.com/oss/python/deepagents/overview Original tweet: https://x.com/ElliotHyun/status/2043453995654455656

RT Elliot Hyun harness engineering > prompt engineering Original tweet: https://x.com/ElliotHyun/status/2043452870276596111

RT Sydney Runkle without memory, ux with an agent is really bad memory is what makes an experience with an agent feel personal and optimized i'm doing a bunch of research re how folks are building memory into their agents, please reach out if you think you have an app w/ a good memory model! Original tweet: https://x.com/sydneyrunkle/status/2043452176282841181

RT Addy Osmani Memory makes your agent smarter over time. The agent harness is key to the memory layer. You can't bolt one onto the other after the fact. Every decision the harness makes - what goes in context, what survives compaction, how skills get surfaced, how the working directory is exposed etc - is a memory decision. A well written write-up by @hwchase17 Original tweet: https://x.com/addyosmani/status/2043447970507686248

RT Jason Toevs Re @hwchase17 is naming the lock-in play that model providers don't want builders to notice. Your agent's memory is the valuable part. Personalization, context, preferences that compound over time. If that memory lives inside a closed harness, you're renting the thing that matters most. Anthropic's Managed Agents. OpenAI's encrypted compaction. The pattern is clear. The builder's question isn't which model is best. It's who controls the state. Original tweet: https://x.com/JasonToevs/status/2043446069653319777

RT Sam Coward Memory, the next toe-hold for closed AI platforms; increasing user ergonomics whilst playing the long game against customers. Original tweet: https://x.com/samcoward/status/2043434920744243551

RT sathvik if you bounce between claude code and codex, that’s completely normal. the models are good at different things and everyone's workflow is dynamic but you’re also paying multiple subscriptions, constantly rebuilding your context, and susceptible to any of the providers randomly nerfing your experience according to "business needs." switching models is easy when everything is stateless, but agents aren't stateless. the harness owns the context, memory, preferences, compaction, tools, workflows, etc therefore instead of asking the question "what model are you using?" , we should ask "who owns the harness around the model?" i think the winning agent UX is model-agnostic, lets you choose the best model for the job, and gives you more control over your context instead of trapping it with one provider Original tweet: https://x.com/vikvang1/status/2043426440574644532

RT chris S. Nakamoto This. And i know it works very well. Original tweet: https://x.com/chrisnk14/status/2043414937834516609

RT Victor Re @hwchase17 is spot on: Agent harnesses are the real foundation now — and they're fused with memory. Give a closed/proprietary harness control of your agent's memory (context + personalization) and you've handed over your moat. Own Ur memory. Original tweet: https://x.com/VictorATHER/status/2043410592334004406

RT Zach Lloyd lots that i agree with in here, especially about the importance of not locking in Original tweet: https://x.com/zachlloydtweets/status/2043408319059009898

RT Mr Mochizuki Not your harness, not your memory. Original tweet: https://x.com/mochizukimr/status/2043400885443920337

RT 🛸 Syd Each workflow in Thoth is a full LangGraph agent which can call subagents which themselves are LangGraph agents. Just describe what you want in plain English and it builds a full multi-step pipeline. Conditions, branching, approval gates, scheduling, all of it. No YAML, no drag-and-drop canvas, no config files. Just tell it what to do and it figures out the steps. Conditions, chained outputs, human-in-the-loop, running on a cron. Built from one sentence. Approval gates pause the pipeline and ping you on Telegram with approve/deny buttons Safety modes block destructive tools when running unattended Full cron scheduling with natural language setup Free and open source: http://github.com/siddsachar/Thoth Original tweet: https://x.com/SydSachar/status/2043400469305757968

RT Siddharth Singh Amazing article. If you own the harness you own your memories. Else you get locked into an API model which keeps memory behind APIs and you don't own them. Original tweet: https://x.com/CddharthSingh/status/2043400207984177400

RT Elliot Hyun deepagents is a harness / planning tool, filesystem backend, subagent spawning, memory management / thats the stack that matters / models are the cpu, the harness is the os / anyways, check it out https://github.com/langchain-ai/deepagents Original tweet: https://x.com/ElliotHyun/status/2043388879684681858

“Above the api line” Good phrase

RT Antonio Silveira Very good article from @hwchase17 about the agent harness and memory achitecture. Original tweet: https://x.com/antonios/status/2043379785863463373

RT Elliot Hyun memory is just context -> the harness decides what gets remembered, how, and when memory ownership = agent ownership deepagents lets you own your memory: agent-scoped, user-scoped, or org-level, all in your backend https://docs.langchain.com/oss/python/deepagents/memory Original tweet: https://x.com/ElliotHyun/status/2043365393549377846

RT Cobus Greyling I just love the language of this study...it speaks of the shifting "community language"...and that is so true...have you noticed the new "community language" is "harness", it was "contextual prompting" before that... For now, the center of gravity in AI agents has shifted — and this diagram captures it perfectly. Think of LLM agent capabilities as three stacked layers: Weights ... Where it all started. Pretraining, fine-tuning, RLHF, scaling laws, alignment. This was the 2022 conversation. Context ... The 2023-2024 wave. RAG, memory, long context, chain-of-thought, prompting, and context engineering became the focus. How do we get the right information to the model? Now, Harness ... Where the conversation lives now. MCP, tool ecosystems, function calling, agent infrastructure, protocols, skills, A2A, multi-agent orchestration, workflow graphs, and security. The pattern? Community attention has moved steadily outward, from what's inside the model, to what surrounds it, to the infrastructure that connects and orchestrates it all. The models themselves are becoming a commodity. The differentiation is increasingly in the harness layer, how you wire agents together, what tools they can use, and how they coordinate. We've gone from "how do we make the model smarter?" to "how do we make the system around the model smarter?" That's the real shift. Source: https://arxiv.org/pdf/2604.08224 This aligns with an excellent blog from @hwchase17 ➡️https://x.com/hwchase17/status/2042978500567609738 Original tweet: https://x.com/CobusGreylingZA/status/2043363380551934461

RT Felix feels right. once implementation gets cheap, the leverage moves into review and guardrails. e.g. specs, constraints, tests, hooks. otherwise it's mostly just generating more work for humans to fix up later. Original tweet: https://x.com/vcfgdev/status/2043357803419726043

Deepagents https://github.com/langchain-ai/deepagents

Directionally correct Open memory standards will need to emerge But it’s so early right now. We’re still just figuring out what best practices are. And so a lot is at the mercy of harnesses Agents.md and skills are great start though

RT Larry Graham great read on why open harnesses have become so important. we used to focus on open models vs closed models, but i think the deeper issue is open harnesses vs closed harnesses. if the harness is closed, you do not really own the agent. and it’s even worse when memory is also closed or trapped behind the same api. now the most valuable part of the system, the accumulated memory and behavior of the agent, is not really yours. it lives inside someone else’s product. that makes it harder to: switch models switch platforms evolve your own stack and the more useful the agent gets, the stronger the lock-in gets. models can be swapped. your harness and memory should be yours. Original tweet: https://x.com/LarryGraham01/status/2043347226714337705

RT Engel Nyst - open/acc OpenAI's server-side compaction and Anthropic's messing up with context are terrible precedents for memory. I do think Harrison is correct, memory can have significant lock in potential. Original tweet: https://x.com/engelnyst/status/2043344272955428917

RT laxman "every memory system is choosing a position on the raw/derived spectrum. and neither extreme works." the axis nobody talks about: ownership > memory is your agent's compounding advantage > derived facts, entity graphs, relationship maps that's your moat > locked behind a provider's API? you're renting your own intelligence > swap models freely. but if memory doesn't move with you, you never really owned the agent > the model is the commodity. memory is the asset > self hosted memory isn't a technical preference, it's a business decision you don't own the agent if you don't own what it learned Original tweet: https://x.com/llmluthor/status/2043311295026569254

RT Avid This 1-min clip from the creator of LangChain + this 10-min read from him will teach you more about what actually matters in AI agents than everything you've scrolled past this year. Watch this. Then read below. You'll think about agents differently after. -Memory defines how an agent behaves; same conversation, different compaction rules, different agent. - There's no version control for memory. No diffs, no reverts, no way to see what changed. - Compaction can silently erase parts of your agent's personality mid-session without anyone noticing. - "Open memory" means exportable state and inspectable compaction, not a vector database. - The storage layer is solved and boring; the memory contract above it is what actually matters. Give this 11 minutes this weekend . It'll change how you build. Original tweet: https://x.com/Av1dlive/status/2043285849580933209

RT Fletch Phillips very helpful overview. Also presents a clear framework for understanding some of anthropic’s recent positioning toward openclaw Original tweet: https://x.com/FletchPh/status/2043149003739550157

RT Farhan Helmy I still don’t properly handle memory and I think I should now Original tweet: https://x.com/farhanhelmycode/status/2043145938244600094

RT Jesse Ellingworth Not your harness, not your memory Original tweet: https://x.com/JLEllingworth/status/2043110536150417637

RT Mikhail Zhutikov This is the right frame. We’re currently designing our agent memory platform, and the hardest part isn’t storage — it’s deciding what to remember, when to retrieve, and how to keep context clean. All of that lives in the harness. Original tweet: https://x.com/MZhutikov/status/2043100116286951858

RT Lav Crnobrnja “Memory is important, and it creates lock in” Exactly why I don’t want OpenAI, Anthropic or any of the other AI companies owning it. Original tweet: https://x.com/lavcrnobrnja/status/2043097390387810430

RT Eugene Yurtsev Your harness, your memory Original tweet: https://x.com/veryboldbagel/status/2043075298929897970

RT Stefan Krawczyk For once I actually agree with the constructive argument here. There are more approaches that allow you to own your own destiny. Memory is just context after all and you can provide that at many places of the agent while loop. Check out @burr_framework and of course @agentforce Original tweet: https://x.com/stefkrawczyk/status/2043062955600941081

RT ChaiBytesAI Re Great piece. The lock-in point is the one nobody talks about enough. If your agent’s memory lives behind someone else’s API, you don’t have a product. You have a dependency. Learned this early building an AI agent for customer risk. The way your agent manages context, what it keeps, what it throws away, how it reasons over past sessions, that IS the product. You can’t outsource that and still call it yours. Original tweet: https://x.com/chaibytesai/status/2043054825840288169

RT drew dillon Memory + harness, or as @matt_slotnick put it, memory + intent. Something I describe a lot about @usebrief, that *why* you remember something is more important than pure recall. A moment that’s trivial to one person may be foundational to another. Original tweet: https://x.com/drewdil/status/2043049973080822176

RT prady What if owning the memory layer goes far beyond escaping lock-in? What if memory becomes fully editable intelligence? You could debug bad patterns, reinforce good ones, and crucially synthesize new ones. Capture the sharpest finance agents (or expert humans using them). Take their best runs, distill the high-signal reasoning traces into clean synthetic memories, then package them as portable “steroids.” A fresh agent no longer cold-starts from zero. Drop in the right memory pack and it boots up already operating at expert level. This quietly opens the door to a memory economy where the best distilled experience (drugs) can be traded and compounded across agents. Original tweet: https://x.com/prady_v/status/2043039962288001246

RT aira memory isn't a retrieval widget. it's write policy. the harness decides what survives compaction, what gets promoted, and what becomes reusable state. https://x.com/hwchase17/status/2042978500567609738 Original tweet: https://x.com/airasentia/status/2043038121298645081

RT Alan Chen Most illuminating graph I have seen for definition of harness. Memory and context are deeply coupled with harness. In my humble opinion, how they are injected and managed are one of most important pieces of harness. Original tweet: https://x.com/zxchen2610/status/2043033755665813771

RT Sarah Wooders Relying on model providers' stateful APIs or harnesses creates lock-in: switching models means losing your agent's memory -- a cost that only grows as agents get better at learning Original tweet: https://x.com/sarahwooders/status/2043028972917973405

RT Alpha Batcher If you don't own the memory, you don't own the agent: - memory is what makes your agent get smarter over time - without it, anyone with the same tools can copy your agent overnight - with it, you build a dataset no competitor can replicate - closed memory = your data on someone else's servers - switch models, lose everything your agent learned - model providers are incentivized to lock you in via memory - the model is easy to replace, memory is not - if you don't own the harness, you don't own the memory - if you don't own the memory, you don't own the agent full story of why this matters and what happens when memory is locked behind someone else's API 👇 Original tweet: https://x.com/alphabatcher/status/2043014520721871338

RT cybercody Great breakdown of how model providers are platformizing their AI/agents. A lot of people will take the convenience of going all in on a provider, but they will be locked in and giving up data control. Literally giving up agency. Original tweet: https://x.com/cybercody/status/2043012643309728018

RT Viv the team spent a lot of time totally revamping docs with care❤️ ofc for LangChain+deepagents DX but lots of ppl use them as general learning guides on patterns across Agents, Context Eng, Infra, Prod, etc even if you don’t use deepagents (would love if you did), they may still be helpful :) Original tweet: https://x.com/Vtrivedy10/status/2043011464710029819

this is a good point around taking advantage of model/api provider features i agree that prompt caching is great! we make sure to use it in deepagents! but that alone doesnt lock in - you can switch pretty easily, just a bit more costly things like encrypted or serverside compaction make it harder to do so. blackbox long term memory makes it impossible i think there is a line between optimizing a harness for a model/llm provider, and using the harness to create lock in for a model provider i think model providers are inherently incentivized to create lock in, and i think managed claude agents is fantastic example of that coming true

i agree there should be managed agents, i just think they should be built on open harnesses and open memory standards

RT LARES The most important post I've read all week by @hwchase17 . Memory, particularly memory consistency is the biggest performance inhibitor to AI agents today. As we interact with different harnesses and memory architectures to do tasks requiring intimate personal data, it's worth first asking the question of who ultimately owns the agent's memory? Original tweet: https://x.com/Guardian_LARES/status/2043007514007028126

check out thoth - agent harness with sota memory built on langgraph

RT Viv Re time to help builders own their intelligence, open everything 🤝 the data produced and Experiential Memory gained from every agent interaction is the one of the most valuable things you can own to improve agent intelligence over time You should own that layer. You can outperform Claude Code on tasks you care about by building on open harness primitives open everything 🔥 Original tweet: https://x.com/Vtrivedy10/status/2042997648668414089

RT Viv Open Everything 🤝 Own your intelligence 🤝 Builder Choice We’re in the v0.1 of deploying agentic intelligence across the economy. Agents are data generating beasts! Experiential Memory: Each piece of generated data is akin to experiential memory that can improve your agents over time. You want to own that layer, don’t give it away, that’s the sauce! You almost certainly want to own that layer for yourself, not give it away to someone else or another company Today harnesses facilitate agent execution. Like Harrison said, they’re not going away rn. We can build for a future where they look different or need less guidance, today is absolutely not that day. Build cool stuff today! Almost anyone can outperform the closed harnesses like Claude Code themselves with care, evals, and focused attention on their specific problem. We don’t have to pray that the model labs fit to our exact data, we can simply use the model and build the optimal harness, orchestration, and verification layers around it to rock at our task Owning the stack is getting easier, we have open source harness tools, there’s amazing open source models, memory has an open protocol (even if it’s probably not the exact right solution today) No one is saying don’t use Claude, they make amazing models. But you want choice of how and when to use Claude especially when we have a intelligence race between labs, open models, and the opportunity to finetune for domains TLDR: Own your intelligence 🧠 Original tweet: https://x.com/Vtrivedy10/status/2042996873682624779

RT Johan Bonilla Thanks for another banger! Incredibly easy to read as always. It reminded me of your Daytona conference distinction about the different types of memory (episodic, semantic, and procedural) Original tweet: https://x.com/johanbonilla/status/2042986051648606634

RT Alfred D Re @hwchase17 @sarahwooders like a the old children's school flipbook - each one wakes up, takes in the context(memory) via harness does its thing, then rests.... next flip book page, the harness manages w memory, wakes up the LLM and gives it agency, rinse & repeat... dynamic story Original tweet: https://x.com/alfreddaluya/status/2042985909952614460

RT george salapa 🜁 if you've read software history everything in your bone tells you open models have to win we are just in a weird anthropic fanboy moment Original tweet: https://x.com/jurajsalapa/status/2042985589008462289

ended up writing similar style post: your harness, your memory https://x.com/hwchase17/status/2042978500567609738 cited @sarahwooders post a lot!

RT LangChain your harness = your memory if you'd rather read in blog form, link here: https://blog.langchain.com/your-harness-your-memory/ Original tweet: https://x.com/LangChain/status/2042979361867886733

a big part of agent harnesses is how they interact with context memory is just context its therefor impossible to separate harness from memory - as @sarahwooders says, "memory isn't a plugin (it's a harness)"

http://x.com/i/article/2042925090942160896

RT Marcin Krzyzanowski the fact that http://pi.dev agent is so good, with virtually no sophisticated harness whatsoever, is a testament to the fact token vendor (codex/claude) agents are overrated. highly. today's moat of codex/claude tools is GIVING TOKENS FOR FREE LEFT AND RIGHT to make you dependant Original tweet: https://x.com/krzyzanowskim/status/2042937489480905154

great question! knowledge (system prompt, skills) and tools (apis, clis, whatnot) will always be needed, even as the best way to build agents changes i would focus on those and processes around those

why not? what in the current harnesses are not bitter lesson-pilled? off top of head: will go away: - planning tools - compaction (or at least will matter less) not going away: - sub agents - skills - filesystem access - bash - websearch - mcps what else?