正在加载视频...

视频加载失败

加载此视频时出现问题。这可能是由于临时网络问题，或视频可能不可用。

New short course: LLMs as Operating Systems: Agent Memory, created with Letta, and taught by its founders Charles Packer and Sarah Wooders. An LLM's input context window has limited space. Using a longer input context also costs more and results in slower processing. So, managing what's stored in this... context window is important. In the innovative paper MemGPT: Towards LLMs as Operating Systems, its authors (which include the instructors) proposed using an LLM agent to manage this context window. Their system uses a large persistent memory that stores everything that could be included in the input context, and an agent decides what is actually included. Take the example of building a chatbot that needs to remember what's been said earlier in a conversation (perhaps over many days of interaction with a user). As the conversation's length grows, the memory management agent will move information from the input context to a persistent searchable database; summarize information to keep relevant facts in the input context; and restore relevant conversation elements from further back in time. This allows a chatbot to keep what's currently most relevant in its input context memory to generate the next response. When I read the original MemGPT paper, I thought it was an innovative technique for handling memory for LLMs. The open-source Letta framework, which we'll use in this course, makes MemGPT easy to implement. It adds memory to your LLM agents and gives them transparent long-term memory. In detail, you’ll learn: - How to build an agent that can edit its own limited input context memory, using tools and multi-step reasoning - What is a memory hierarchy (an idea from computer operating systems, which use a cache to speed up memory access), and how these ideas apply to managing the LLM input context (where the input context window is a "cache" storing the most relevant information; and an agent decides what to move in and out of this to/from a larger persistent storage system) - How to implement multi-agent collaboration by letting different agents share blocks of memory This course will give you a sophisticated understanding of memory management for LLMs, which is important for chatbots having long conversations, and for complex agentic workflows. Please sign up here!show more

Andrew Ng

1,828,555 subscribers

201,127 次观看 • 2 年前 •via X (Twitter)

科学技术教育

Anya Rossi• Live Now

Private livecam show

10 条评论

Rémi 📎 的头像

Rémi 📎2 年前

@Letta_AI @charlespacker @sarahwooders Would be very happy to give a course on structured output for LLMs @AndrewYNg @dottxtai

Charles Packer 的头像

Charles Packer2 年前

@Letta_AI @sarahwooders @Letta_AI is open source and free to use at our github 👉

Sarah Wooders 👾 的头像

Sarah Wooders 👾2 年前

@Letta_AI @charlespacker Was great working together and fantastic summary on the importance of memory for agents :) Really excited for this course to finally be released!

Tim Urista 的头像

Tim Urista2 年前

@Letta_AI @charlespacker @sarahwooders Multi-agent collaboration unlocks new potential for shared learning and efficiency.

Franck SN 的头像

Franck SN2 年前

@Letta_AI @charlespacker @sarahwooders That's why we need to build large reasoning models and drop o1

Vasek Mlejnsky 的头像

Vasek Mlejnsky2 年前

@Letta_AI @charlespacker @sarahwooders Whoa, nicely done @charlespacker @sarahwooders !

Omariba Collins 的头像

Omariba Collins2 年前

@Letta_AI @charlespacker @sarahwooders Did you by any chance get this idea from @karpathy ?

Sir Mr Meow Meow 的头像

Sir Mr Meow Meow2 年前

@Letta_AI @charlespacker @sarahwooders ooh so it's like a summary type memory where the key-values are stored and attention is applied to compress it. :3 interesting.

Ali Sheheryar 的头像

Ali Sheheryar2 年前

@Letta_AI @charlespacker @sarahwooders From LSTMs to Transformers. We have indeed come a long way!

Tim Urista 的头像

Tim Urista2 年前

@Letta_AI @charlespacker @sarahwooders An LLM agent deciding what enters the input context is reminiscent of MemGPT's strategic context window use.

相关视频

New short course: Long-Term Agentic Memory with LangGraph. Learn to build an agent with long-term memory in this course developed in collaboration with taught by its Co-Founder and CEO, Harrison Chase! Personal assistance and productivity tasks have become important use cases for agents. An important feature of an AI assistant, such as a coding or calendar assistant, is its ability to keep improving over time from its experience. Agent memory is the key capability that enables this. To add memory to an agent, you must first figure out what to store and what to retrieve when it is time to use the information. Additionally, you’ll have to decide when to update the stored information. For example, you might update in each iteration loop of the agent or perform updates in the background, with a helper agent. In this course, you will learn a mental framework to build agents with long-term memory. You'll create a useful email assistant that can respond, ignore, and notify using writing, scheduling, and memory-management tools. You’ll develop your agent's memory by adding facts to its memory store, provide examples to learn the user's preferences, and optimize system prompts to evolve instructions based on previous responses. In detail, you’ll: - Learn how the three types of memory--semantic, episodic, and procedural–and the two update mechanisms–via hot path and in the background–apply to your agents. - Build an email agent with writing, scheduling, and availability tools, along with a router that triages incoming email and handles it accordingly by ignoring, responding, or notifying the user. - Add tools to your email agent that allow it to operate on semantic memory by learning facts about the user, storing them in a long-term memory store, and searching over them in future interactions. - Incorporate episodic memory, in the form of few-shot examples, in the triage step of your agents to help them learn and update user preferences. - Add procedural memory as system prompts, optimized with feedback to improve the instructions the agent follows. Learn how to approach memory in agents, and start building agents with long-term memory with LangGraph! Please sign up here:

New short course: Long-Term Agentic Memory with LangGraph. Learn to build an agent with long-term memory in this course developed in collaboration with taught by its Co-Founder and CEO, Harrison Chase! Personal assistance and productivity tasks have become important use cases for agents. An important feature of an AI assistant, such as a coding or calendar assistant, is its ability to keep improving over time from its experience. Agent memory is the key capability that enables this. To add memory to an agent, you must first figure out what to store and what to retrieve when it is time to use the information. Additionally, you’ll have to decide when to update the stored information. For example, you might update in each iteration loop of the agent or perform updates in the background, with a helper agent. In this course, you will learn a mental framework to build agents with long-term memory. You'll create a useful email assistant that can respond, ignore, and notify using writing, scheduling, and memory-management tools. You’ll develop your agent's memory by adding facts to its memory store, provide examples to learn the user's preferences, and optimize system prompts to evolve instructions based on previous responses. In detail, you’ll: - Learn how the three types of memory--semantic, episodic, and procedural–and the two update mechanisms–via hot path and in the background–apply to your agents. - Build an email agent with writing, scheduling, and availability tools, along with a router that triages incoming email and handles it accordingly by ignoring, responding, or notifying the user. - Add tools to your email agent that allow it to operate on semantic memory by learning facts about the user, storing them in a long-term memory store, and searching over them in future interactions. - Incorporate episodic memory, in the form of few-shot examples, in the triage step of your agents to help them learn and update user preferences. - Add procedural memory as system prompts, optimized with feedback to improve the instructions the agent follows. Learn how to approach memory in agents, and start building agents with long-term memory with LangGraph! Please sign up here:

Andrew Ng

132,273 次观看 • 1 年前

New course: Agent Memory: Building Memory-Aware Agents, built in partnership with Oracle and taught by Richmond Alake and Nacho Martínez. Many agents work well within a single session but their memory resets once the session ends. Consider a research agent working on dozens of papers across multiple days: without memory, it has no way to store and retrieve what it learned across sessions. This short course teaches you to build a memory system that enables agents to persist memory and thereby learn across sessions. You'll design a Memory Manager that handles different memory types, implement semantic tool retrieval that scales without bloating the context, and build write-back pipelines that let your agent autonomously update and refine what it knows over time. Skills you'll gain: - Build persistent memory stores for different agent memory types - Implement a Memory Manager that orchestrates how your agent reads, writes, and retrieves memory - Treat tools as procedural memory and retrieve only relevant ones at inference time using semantic search Join and learn to build agents that remember and improve over time!

New course: Agent Memory: Building Memory-Aware Agents, built in partnership with Oracle and taught by Richmond Alake and Nacho Martínez. Many agents work well within a single session but their memory resets once the session ends. Consider a research agent working on dozens of papers across multiple days: without memory, it has no way to store and retrieve what it learned across sessions. This short course teaches you to build a memory system that enables agents to persist memory and thereby learn across sessions. You'll design a Memory Manager that handles different memory types, implement semantic tool retrieval that scales without bloating the context, and build write-back pipelines that let your agent autonomously update and refine what it knows over time. Skills you'll gain: - Build persistent memory stores for different agent memory types - Implement a Memory Manager that orchestrates how your agent reads, writes, and retrieves memory - Treat tools as procedural memory and retrieve only relevant ones at inference time using semantic search Join and learn to build agents that remember and improve over time!

Andrew Ng

162,636 次观看 • 7 个月前

New AI Agentic course! Learn to use LangGraph to build single and multi-agent LLM applications in AI Agents in LangGraph. This short course, taught by LangChain founder Harrison Chase Harrison Chase and Tavily founder @weiss_rotem, shows how to integrate agentic search to enhance an agent's knowledge with query-focused answers in predictable formats. Also learn to implement agentic memory to save state for reasoning and debugging, and see how human-in-the-loop input can guide agents at key junctures. You'll build an agent from scratch, then reconstruct it with LangGraph to thoroughly understand the framework. Finally, you'll build a sophisticated essay-writing agent that incorporates all the learnings from the course. Sign up here!

New AI Agentic course! Learn to use LangGraph to build single and multi-agent LLM applications in AI Agents in LangGraph. This short course, taught by LangChain founder Harrison Chase Harrison Chase and Tavily founder @weiss_rotem, shows how to integrate agentic search to enhance an agent's knowledge with query-focused answers in predictable formats. Also learn to implement agentic memory to save state for reasoning and debugging, and see how human-in-the-loop input can guide agents at key junctures. You'll build an agent from scratch, then reconstruct it with LangGraph to thoroughly understand the framework. Finally, you'll build a sophisticated essay-writing agent that incorporates all the learnings from the course. Sign up here!

Andrew Ng

152,816 次观看 • 2 年前

⚒️ How to build an AI agent with persistent memory? Watch Shaw building an agent from scratch with elizaOS & showing how external, queryable memory based on OriginTrail gives agents context and extends their memory beyond a single session. 02:15 – Set up your first agent 08:55 – Initializing runtime & memory foundations 12:50 – Wiring message handling & agent memory 24:45 – Persistent conversational memory in action 38:00 – Extending agents with plugins

⚒️ How to build an AI agent with persistent memory? Watch Shaw building an agent from scratch with elizaOS & showing how external, queryable memory based on OriginTrail gives agents context and extends their memory beyond a single session. 02:15 – Set up your first agent 08:55 – Initializing runtime & memory foundations 12:50 – Wiring message handling & agent memory 24:45 – Persistent conversational memory in action 38:00 – Extending agents with plugins

OriginTrail

37,374 次观看 • 9 个月前

I’m excited to kick off the first of our short courses focused on agents, starting with Building Agentic RAG with LlamaIndex, taught by Jerry Liu, CEO of LlamaIndex 🦙. This covers an important shift in RAG (retrieval augmented generation), in which rather than having the developer write explicit routines to retrieve information to feed into the LLM context, we instead build a RAG agent that that has access to tools for retrieving information. This lets the agent decide what information to fetch, and enables it to answer more complex questions using multi-step reasoning. In detail, you'll learn about: - Routing: Where your agent will use decision-making to route requests to multiple tools. - Tool Use: Where you'll create an interface for agents to select what tool (function call) to use as well as generate the right arguments. - Multi-step reasoning with tool use: Where you'll use an LLM to carry out multiple steps of reasoning, while retaining memory throughout the process. You’ll also learn how to step through what your agent is doing to debug and improve it iteratively. It’s an exciting time to build agents. Sign up and get started here!

I’m excited to kick off the first of our short courses focused on agents, starting with Building Agentic RAG with LlamaIndex, taught by Jerry Liu, CEO of LlamaIndex 🦙. This covers an important shift in RAG (retrieval augmented generation), in which rather than having the developer write explicit routines to retrieve information to feed into the LLM context, we instead build a RAG agent that that has access to tools for retrieving information. This lets the agent decide what information to fetch, and enables it to answer more complex questions using multi-step reasoning. In detail, you'll learn about: - Routing: Where your agent will use decision-making to route requests to multiple tools. - Tool Use: Where you'll create an interface for agents to select what tool (function call) to use as well as generate the right arguments. - Multi-step reasoning with tool use: Where you'll use an LLM to carry out multiple steps of reasoning, while retaining memory throughout the process. You’ll also learn how to step through what your agent is doing to debug and improve it iteratively. It’s an exciting time to build agents. Sign up and get started here!

Andrew Ng

297,303 次观看 • 2 年前

"What happens when we can access each other's AI memory in enterprises?" scott belsky, investor/founder of Behance: "If I was working as an intern for years, and the context window is accessible to the enterprise, can the enterprise (keep prompting) and asking me what I'd think or do, after I leave?" "Every company right now is trying to build this AI memory for each of its products and users. A lot of them are building connectors to form a collective memory." "In the social/consumer world, imagine your girlfriend saying she wants access to your context window or memory." "There are all kinds of weird questions and implications that arise from this."

"What happens when we can access each other's AI memory in enterprises?" scott belsky, investor/founder of Behance: "If I was working as an intern for years, and the context window is accessible to the enterprise, can the enterprise (keep prompting) and asking me what I'd think or do, after I leave?" "Every company right now is trying to build this AI memory for each of its products and users. A lot of them are building connectors to form a collective memory." "In the social/consumer world, imagine your girlfriend saying she wants access to your context window or memory." "There are all kinds of weird questions and implications that arise from this."

TBPN

44,908 次观看 • 1 年前

Qwen3.8-Flash-Next is still going strong at 364.7K tokens of context on an M5 Max. And this isn’t just a static long-context test. The model was reasoning about how to speed up its own workflow while using tools, and the tool calls kept working without misses. Setup: • Qwen3.8-Flash-Next • M5 Max • 128GB unified memory • MLX-Serve PR #363 • OpenCode 2 • 364.7K context The interesting part isn’t simply getting hundreds of thousands of tokens into memory. It’s what happens once the context gets this large. Long-context inference usually comes with a painful tradeoff. As the KV cache grows, memory pressure increases and generation can slow down. But this setup is still pushing through 364K tokens while maintaining a usable agent workflow. The model can reason, call tools, inspect results, continue working, and keep the session moving. And the tool calls reportedly haven’t missed so far. That’s important for agentic coding. A huge context window is only useful if the model can actually operate reliably inside it. A 400K-token context that constantly breaks tool calls isn’t very useful. A 364K session that can keep reasoning and executing tools is a different story. And the test isn’t finished yet. The current run is approaching 400K tokens, with the expectation that it can keep going. This is also another interesting example of why Apple Silicon keeps showing up in local LLM experiments. The M5 Max’s unified memory gives a large model and its growing KV cache access to one shared memory pool. With MLX-Serve continuing to improve, these machines are becoming surprisingly capable long-context inference boxes. The bigger takeaway: Context length is becoming a workload, not just a model specification. Running a model at 256K is one thing. Keeping an agent alive at 300K+ while it reasons and uses tools is much more interesting. And Qwen3.8-Flash-Next is showing that this can be pushed surprisingly far on a single 128GB Mac. 364.7K and counting. Next stop: 400K.

Qwen3.8-Flash-Next is still going strong at 364.7K tokens of context on an M5 Max. And this isn’t just a static long-context test. The model was reasoning about how to speed up its own workflow while using tools, and the tool calls kept working without misses. Setup: • Qwen3.8-Flash-Next • M5 Max • 128GB unified memory • MLX-Serve PR #363 • OpenCode 2 • 364.7K context The interesting part isn’t simply getting hundreds of thousands of tokens into memory. It’s what happens once the context gets this large. Long-context inference usually comes with a painful tradeoff. As the KV cache grows, memory pressure increases and generation can slow down. But this setup is still pushing through 364K tokens while maintaining a usable agent workflow. The model can reason, call tools, inspect results, continue working, and keep the session moving. And the tool calls reportedly haven’t missed so far. That’s important for agentic coding. A huge context window is only useful if the model can actually operate reliably inside it. A 400K-token context that constantly breaks tool calls isn’t very useful. A 364K session that can keep reasoning and executing tools is a different story. And the test isn’t finished yet. The current run is approaching 400K tokens, with the expectation that it can keep going. This is also another interesting example of why Apple Silicon keeps showing up in local LLM experiments. The M5 Max’s unified memory gives a large model and its growing KV cache access to one shared memory pool. With MLX-Serve continuing to improve, these machines are becoming surprisingly capable long-context inference boxes. The bigger takeaway: Context length is becoming a workload, not just a model specification. Running a model at 256K is one thing. Keeping an agent alive at 300K+ while it reasons and uses tools is much more interesting. And Qwen3.8-Flash-Next is showing that this can be pushed surprisingly far on a single 128GB Mac. 364.7K and counting. Next stop: 400K.

FHILY👑

39,982 次观看 • 1 个月前

Everyone wants agent swarms. Very few people are talking seriously enough about the context layer that makes swarms useful. Even with one agent, context is fragile. Too little context and the agent guesses. Too much context and it wastes tokens, loses focus, or reasons over irrelevant noise. The sweet spot is precise context: the right knowledge, in the right structure, at the right moment. With many agents, that challenge explodes. Each agent produces decisions, assumptions, findings, summaries, risks, and partial conclusions. Unless that knowledge becomes shared, structured, and reusable, every new agent is forced to rediscover what another agent already learned. That is not a swarm. That is a crowd. Shared context graphs are what turn agent activity into agent collaboration, and OriginTrail DKG V10 brings them to life. Was just playing with some final polishing for the V10 release, and it is really powerful to see shared context graphs where multiple agents contribute knowledge into the same connected memory, with attribution visible directly in the graph ui. That matters for three reasons. First, agents can access and build on one shared memory instead of staying trapped in isolated sessions. Second, the graph structure helps them retrieve the exact context they need, instead of stuffing everything into a prompt and hoping the model sorts it out. Third, verifiability of provenance. You can see which agent contributed each piece of knowledge, trace the source, and decide what to trust. Tokenmaxxing starts with fewer tokens, but the deeper story is coordination - agents stop reloading the world and start building on shared, verifiable context. That is the foundation for serious multi-agent work across software engineering, research, finance, operations, project management, and far beyond. The future is not more agents, it is agents working from shared, verifiable context. But the more the merrier, of course.

Everyone wants agent swarms. Very few people are talking seriously enough about the context layer that makes swarms useful. Even with one agent, context is fragile. Too little context and the agent guesses. Too much context and it wastes tokens, loses focus, or reasons over irrelevant noise. The sweet spot is precise context: the right knowledge, in the right structure, at the right moment. With many agents, that challenge explodes. Each agent produces decisions, assumptions, findings, summaries, risks, and partial conclusions. Unless that knowledge becomes shared, structured, and reusable, every new agent is forced to rediscover what another agent already learned. That is not a swarm. That is a crowd. Shared context graphs are what turn agent activity into agent collaboration, and OriginTrail DKG V10 brings them to life. Was just playing with some final polishing for the V10 release, and it is really powerful to see shared context graphs where multiple agents contribute knowledge into the same connected memory, with attribution visible directly in the graph ui. That matters for three reasons. First, agents can access and build on one shared memory instead of staying trapped in isolated sessions. Second, the graph structure helps them retrieve the exact context they need, instead of stuffing everything into a prompt and hoping the model sorts it out. Third, verifiability of provenance. You can see which agent contributed each piece of knowledge, trace the source, and decide what to trust. Tokenmaxxing starts with fewer tokens, but the deeper story is coordination - agents stop reloading the world and start building on shared, verifiable context. That is the foundation for serious multi-agent work across software engineering, research, finance, operations, project management, and far beyond. The future is not more agents, it is agents working from shared, verifiable context. But the more the merrier, of course.

Jurij Skornik

11,180 次观看 • 5 个月前

Introducing MemCurrent, a persistent memory architecture designed to help production agents stop starting from zero. MemCurrent combines episodic memory with derived memory across three access patterns: • Plugins to log and load context automatically • Tools the agent calls on demand • An offline “dreaming” pipeline that consolidates memory in the background Agents carry forward user preferences, prior corrections, metric definitions and successful workflows instead of rediscovering them every session. On our internal benchmark built from real enterprise data, MemCurrent triples the agent's pass rate while using 31% fewer tokens and running 26% faster. It's built into Agent Bricks' Memory offering and already powers memory in Genie. Read the research:

Introducing MemCurrent, a persistent memory architecture designed to help production agents stop starting from zero. MemCurrent combines episodic memory with derived memory across three access patterns: • Plugins to log and load context automatically • Tools the agent calls on demand • An offline “dreaming” pipeline that consolidates memory in the background Agents carry forward user preferences, prior corrections, metric definitions and successful workflows instead of rediscovering them every session. On our internal benchmark built from real enterprise data, MemCurrent triples the agent's pass rate while using 31% fewer tokens and running 26% faster. It's built into Agent Bricks' Memory offering and already powers memory in Genie. Read the research:

Databricks

44,376 次观看 • 12 天前

Google just released a 1-hour course on “Context Engineering” for AI agents from scratch: • 00:00 - Introduction to “Context Engineering” • 03:02 - Context Engineering vs “prompting” • 16:18 - Build a context brain for your agent • 22:10 - Building agent context (tools, skills) • 29:06 - Agentic memory bank from scratch This 1-hour watch could replace a $500 course on agentic design. Watch it today, then read the full guide on Context Engineering in the article below.

Google just released a 1-hour course on “Context Engineering” for AI agents from scratch: • 00:00 - Introduction to “Context Engineering” • 03:02 - Context Engineering vs “prompting” • 16:18 - Build a context brain for your agent • 22:10 - Building agent context (tools, skills) • 29:06 - Agentic memory bank from scratch This 1-hour watch could replace a $500 course on agentic design. Watch it today, then read the full guide on Context Engineering in the article below.

Movez

14,923 次观看 • 3 个月前

Context memory essentially unlocks Agentic AI Much needed for Opus 4.6's "multi-agent swarms" In this SemiDoped pod, Vikram Sekar talks to Val Bercovici from Weka about context storage. - How token warehouses save inference costs - A new networking tier? Context Storage Network! - High Bandwidth Flash for context? - Weka's Augmented Memory Grid for context storage - Where this is all headed The convo is info packed. Don't miss out on it! b/acc, context platform engineer Chapters (00:00) Introduction to Weka and AI Storage Solutions (05:18) The Evolution of Context Memory in AI (09:30) Understanding Memory Hierarchies and Their Impact (16:24) Latency Challenges in Modern Storage Solutions (21:32) The Role of Networking in AI Storage Efficiency (29:42) Dynamic Resource Utilization in AI Networks (30:04) Introducing the Context Memory Network (31:13) High Bandwidth Flash: A Game Changer (32:54) Weka’s Neural Mesh and Storage Solutions (35:01) Axon: Transforming GPU Storage into Memory (39:00) Augmented Memory Grid Explained (42:00) Pooling DRAM and CXL Innovations (46:02) Token Warehouses and Inference Economics (52:10) The Future of Storage Innovations

Context memory essentially unlocks Agentic AI Much needed for Opus 4.6's "multi-agent swarms" In this SemiDoped pod, Vikram Sekar talks to Val Bercovici from Weka about context storage. - How token warehouses save inference costs - A new networking tier? Context Storage Network! - High Bandwidth Flash for context? - Weka's Augmented Memory Grid for context storage - Where this is all headed The convo is info packed. Don't miss out on it! b/acc, context platform engineer Chapters (00:00) Introduction to Weka and AI Storage Solutions (05:18) The Evolution of Context Memory in AI (09:30) Understanding Memory Hierarchies and Their Impact (16:24) Latency Challenges in Modern Storage Solutions (21:32) The Role of Networking in AI Storage Efficiency (29:42) Dynamic Resource Utilization in AI Networks (30:04) Introducing the Context Memory Network (31:13) High Bandwidth Flash: A Game Changer (32:54) Weka’s Neural Mesh and Storage Solutions (35:01) Axon: Transforming GPU Storage into Memory (39:00) Augmented Memory Grid Explained (42:00) Pooling DRAM and CXL Innovations (46:02) Token Warehouses and Inference Economics (52:10) The Future of Storage Innovations

Semi Doped

12,796 次观看 • 8 个月前

Devs are using Memory Bank as a project architecture and planning tool before they write any code. "I prefer starting in Cline, using Memory Bank to build out the context files as a roadmap, and letting Cline take the wheel." How to use Memory Bank for project planning 🧵

Devs are using Memory Bank as a project architecture and planning tool before they write any code. "I prefer starting in Cline, using Memory Bank to build out the context files as a roadmap, and letting Cline take the wheel." How to use Memory Bank for project planning 🧵

Cline

96,670 次观看 • 1 年前

CONTEXT ENGINEERING > PROMPT ENGINEERING Everyone is obsessed with writing better prompts. The next generation of AI builders is focused on context engineering instead. • Prompt engineering shapes the question. Context engineering shapes everything the AI sees. • Great prompts can't save an agent missing critical context, memory, or tools. • AI failures often come from missing information, not weak models. • Context engineering combines prompts, memory, RAG, state management, and tool access into one system. What powers effective AI agents? → Memory: Remembers preferences, past interactions, and ongoing tasks. → State Management: Tracks progress across multi-step workflows. → RAG: Retrieves only the most relevant information when needed. → Tools: Connects AI to APIs, databases, code execution, and real-world actions. → Dynamic Prompts: Enriches instructions with live context at runtime. The key insight: Prompt Engineering = Better Questions Context Engineering = Better Systems The future of AI isn't building smarter prompts. It's building smarter environments for AI to think, remember, retrieve, and act.

CONTEXT ENGINEERING > PROMPT ENGINEERING Everyone is obsessed with writing better prompts. The next generation of AI builders is focused on context engineering instead. • Prompt engineering shapes the question. Context engineering shapes everything the AI sees. • Great prompts can't save an agent missing critical context, memory, or tools. • AI failures often come from missing information, not weak models. • Context engineering combines prompts, memory, RAG, state management, and tool access into one system. What powers effective AI agents? → Memory: Remembers preferences, past interactions, and ongoing tasks. → State Management: Tracks progress across multi-step workflows. → RAG: Retrieves only the most relevant information when needed. → Tools: Connects AI to APIs, databases, code execution, and real-world actions. → Dynamic Prompts: Enriches instructions with live context at runtime. The key insight: Prompt Engineering = Better Questions Context Engineering = Better Systems The future of AI isn't building smarter prompts. It's building smarter environments for AI to think, remember, retrieve, and act.

Dami-Defi

10,144 次观看 • 4 个月前

New Course: ACP: Agent Communication Protocol Learn to build agents that communicate and collaborate across different frameworks using ACP in this short course built with IBM Research's BeeAI, and taught by Sandi Besen, AI Research Engineer & Ecosystem Lead at IBM, and Nicholas Renotte, Head of AI Developer Advocacy at IBM. Building a multi-agent system with agents built or used by different teams and organizations can become challenging. You may need to write custom integrations each time a team updates their agent design or changes their choice of agentic orchestration framework. The Agent Communication Protocol (ACP) is an open protocol that addresses this challenge by standardizing how agents communicate, using a unified RESTful interface that works across frameworks. In this protocol, you host an agent inside an ACP server, which handles requests from an ACP client and passes them to the appropriate agent. Using a standardized client-server interface allows multiple teams to reuse agents across projects. It also makes it easier to switch between frameworks, replace an agent with a new version, or update a multi-agent system without refactoring the entire system. In this course, you’ll learn to connect agents through ACP. You’ll understand the lifecycle of an ACP Agent and how it compares to other protocols, such as MCP (Model Context Protocol) and A2A (Agent-to-Agent). You’ll build ACP-compliant agents and implement both sequential and hierarchical workflows of multiple agents collaborating using ACP. Through hands-on exercises, you’ll build: - A RAG agent with CrewAI and wrap it inside an ACP server. - An ACP Client to make calls to the ACP server you created. - A sequential workflow that chains an ACP server, created with Smolagents, to the RAG agent. - A hierarchical workflow using a router agent that transforms user queries into tasks, delegated to agents available through ACP servers. - An agent that uses MCP to access tools and ACP to communicate with other agents. You’ll finish up by importing your ACP agents into the BeeAI platform, an open-source registry for discovering and sharing agents. ACP enables collaboration between agents across teams and organizations. By the end of this course, you’ll be able to build ACP agents and workflows that communicate and collaborate regardless of framework. Please sign up here:

New Course: ACP: Agent Communication Protocol Learn to build agents that communicate and collaborate across different frameworks using ACP in this short course built with IBM Research's BeeAI, and taught by Sandi Besen, AI Research Engineer & Ecosystem Lead at IBM, and Nicholas Renotte, Head of AI Developer Advocacy at IBM. Building a multi-agent system with agents built or used by different teams and organizations can become challenging. You may need to write custom integrations each time a team updates their agent design or changes their choice of agentic orchestration framework. The Agent Communication Protocol (ACP) is an open protocol that addresses this challenge by standardizing how agents communicate, using a unified RESTful interface that works across frameworks. In this protocol, you host an agent inside an ACP server, which handles requests from an ACP client and passes them to the appropriate agent. Using a standardized client-server interface allows multiple teams to reuse agents across projects. It also makes it easier to switch between frameworks, replace an agent with a new version, or update a multi-agent system without refactoring the entire system. In this course, you’ll learn to connect agents through ACP. You’ll understand the lifecycle of an ACP Agent and how it compares to other protocols, such as MCP (Model Context Protocol) and A2A (Agent-to-Agent). You’ll build ACP-compliant agents and implement both sequential and hierarchical workflows of multiple agents collaborating using ACP. Through hands-on exercises, you’ll build: - A RAG agent with CrewAI and wrap it inside an ACP server. - An ACP Client to make calls to the ACP server you created. - A sequential workflow that chains an ACP server, created with Smolagents, to the RAG agent. - A hierarchical workflow using a router agent that transforms user queries into tasks, delegated to agents available through ACP servers. - An agent that uses MCP to access tools and ACP to communicate with other agents. You’ll finish up by importing your ACP agents into the BeeAI platform, an open-source registry for discovering and sharing agents. ACP enables collaboration between agents across teams and organizations. By the end of this course, you’ll be able to build ACP agents and workflows that communicate and collaborate regardless of framework. Please sign up here:

Andrew Ng

105,894 次观看 • 1 年前

Meet EverOS Cloud. 💛 Your agent shouldn’t have to start from scratch every time a conversation ends. The preferences a user shared. The decisions made during a project. The approach that worked on a previous task. That context should be available when it matters again. EverOS Cloud gives your agents persistent memory through an API: • Remember users and retrieve relevant context across sessions • Turn task experience into Cases and reusable Skill memories • Bring conversations, images, and documents into your memory workflow You build the agent experience. We handle the memory infrastructure, so you can spend less time maintaining the stack and more time making your product useful. Subscribe to EverOS Cloud Pro and get 3× the standard Pro usage allowance for 6 months. Start here:

Meet EverOS Cloud. 💛 Your agent shouldn’t have to start from scratch every time a conversation ends. The preferences a user shared. The decisions made during a project. The approach that worked on a previous task. That context should be available when it matters again. EverOS Cloud gives your agents persistent memory through an API: • Remember users and retrieve relevant context across sessions • Turn task experience into Cases and reusable Skill memories • Bring conversations, images, and documents into your memory workflow You build the agent experience. We handle the memory infrastructure, so you can spend less time maintaining the stack and more time making your product useful. Subscribe to EverOS Cloud Pro and get 3× the standard Pro usage allowance for 6 months. Start here:

EverMind

947,781 次观看 • 13 天前

An overview of how we think about context graphs at Harvey. Context graphs are a promising direction for improving agent quality and efficiency. We ran a series of experiments on Legal Agent Bench to evaluate how structured context improves online agent performance. For each LAB task we evaluated, an agent first reviews each document in its client matter and builds a graph of relevant entities and their relationships – e.g. parties, dates, draft vs. executed status, which versions belong to the same contract. To evaluate the impact of the graph, we compared the performance of an agent with and without the context graph, using LAB’s standard grading setup. Overall, the agent with the context graph improved rubric pass rate by up to 30% while reducing task cost by up to ~50%. In some cases the graph led to massive improvements. For example, in one firm-knowledge task, the agent was asked to find the firm’s most recent secured financing and retrieve the executed credit and security agreements as precedents for a new facility. An agent working from raw files attempted to search through several files sequentially, and looked at many different matters, but ultimately selected the wrong precedent (0% of rubric criteria). With the context graph, the same agent found the relevant matter and its executed agreements immediately (75% of rubric criteria). We’ll have more to share soon on how we’re building this into Harvey, along with more experiments like this one!

An overview of how we think about context graphs at Harvey. Context graphs are a promising direction for improving agent quality and efficiency. We ran a series of experiments on Legal Agent Bench to evaluate how structured context improves online agent performance. For each LAB task we evaluated, an agent first reviews each document in its client matter and builds a graph of relevant entities and their relationships – e.g. parties, dates, draft vs. executed status, which versions belong to the same contract. To evaluate the impact of the graph, we compared the performance of an agent with and without the context graph, using LAB’s standard grading setup. Overall, the agent with the context graph improved rubric pass rate by up to 30% while reducing task cost by up to ~50%. In some cases the graph led to massive improvements. For example, in one firm-knowledge task, the agent was asked to find the firm’s most recent secured financing and retrieve the executed credit and security agreements as precedents for a new facility. An agent working from raw files attempted to search through several files sequentially, and looked at many different matters, but ultimately selected the wrong precedent (0% of rubric criteria). With the context graph, the same agent found the relevant matter and its executed agreements immediately (75% of rubric criteria). We’ll have more to share soon on how we’re building this into Harvey, along with more experiments like this one!

Niko

72,296 次观看 • 17 天前

New course on serving LLMs efficiently -- how do you serve models to many concurrent users at low latency and reasonable cost? This short course is built with Red Hat and taught by Cedric Clyburn. Efficient LLM serving requires efficient memory management. A 70B-parameter model takes ~140 GB just to load the weights. On top of that, every active request needs its own chunk of GPU memory, the KV cache, to store the token context it has built up so far. In this course, you'll learn to reduce a model's memory footprint with quantization and serve it using vLLM, which handles many concurrent requests efficiently through smart memory management. Skills you'll gain: - Quantize a model and measure the accuracy tradeoff - Serve a model with vLLM and watch it handle concurrent requests efficiently - Benchmark your deployment and make informed tradeoffs between speed, cost, and accuracy Join and learn to serve LLMs efficiently:

New course on serving LLMs efficiently -- how do you serve models to many concurrent users at low latency and reasonable cost? This short course is built with Red Hat and taught by Cedric Clyburn. Efficient LLM serving requires efficient memory management. A 70B-parameter model takes ~140 GB just to load the weights. On top of that, every active request needs its own chunk of GPU memory, the KV cache, to store the token context it has built up so far. In this course, you'll learn to reduce a model's memory footprint with quantization and serve it using vLLM, which handles many concurrent requests efficiently through smart memory management. Skills you'll gain: - Quantize a model and measure the accuracy tradeoff - Serve a model with vLLM and watch it handle concurrent requests efficiently - Benchmark your deployment and make informed tradeoffs between speed, cost, and accuracy Join and learn to serve LLMs efficiently:

Andrew Ng

136,970 次观看 • 5 个月前