Video wird geladen...

Video konnte nicht geladen werden

Beim Laden dieses Videos ist ein Problem aufgetreten. Dies könnte an einem vorübergehenden Netzwerkproblem liegen oder das Video ist möglicherweise nicht verfügbar.

An L8 Principal Engineer at Meta shared his agentic workflow, chapter by chapter: Most agent stack posts talks about models and prompts. He shows the operating system around the model: 09:21 - Choosing agent harnesses 11:24 - Global and project memory 16:12 - Skills, and when they backfire 28:29... show more

Rohit

23,955 subscribers

34,432 Aufrufe • vor 10 Tagen •via X (Twitter)

Anya Rossi• Live Now

Private livecam show

0 Kommentare

Keine Kommentare verfügbar

Kommentare vom Original-Post werden hier angezeigt

Ähnliche Videos

Google just showed the part of the agent stack most people are still underestimating. Not the model. Not the chat UI. The memory substrate around the agent. In this Antigravity segment, Google describes an agent-first environment built around: - agent conversations - agent-produced artifacts - multi-agent orchestration - subagents - hooks - asynchronous task management That is not a nicer IDE. It is what happens when software stops being a sequence of chats and starts becoming a persistent workforce. Karl's article explains why the winning agents will not just be the ones with the smartest rented model. They will be the ones that remember what they did, what they learned, what changed, and what can be trusted. Full breakdown below.

Google just showed the part of the agent stack most people are still underestimating. Not the model. Not the chat UI. The memory substrate around the agent. In this Antigravity segment, Google describes an agent-first environment built around: - agent conversations - agent-produced artifacts - multi-agent orchestration - subagents - hooks - asynchronous task management That is not a nicer IDE. It is what happens when software stops being a sequence of chats and starts becoming a persistent workforce. Karl's article explains why the winning agents will not just be the ones with the smartest rented model. They will be the ones that remember what they did, what they learned, what changed, and what can be trusted. Full breakdown below.

Karl Mehta

13,930 Aufrufe • vor 1 Monat

THIS 11-PAGE CLAUDE LOOP ENGINEERING PLAYBOOK IS THE CHEAT CODE FOR SENIOR DEV PROMOTIONS typing prompts line by line won't get you hired. you need to know how to design self-prompting loops: > Discovery: agent finds its own work from logs, failing tests, and commits > Handoff: tasks execute in isolated git worktrees to prevent parallel collisions > Verification: a second reviewer agent audits the builder's code to catch blind spots > Persistence and Scheduling: code writes to disk and loops run 24/7 on a timer the shift is simple: stop prompting the agent, build the system that prompts it read the full setup blueprint 👇

THIS 11-PAGE CLAUDE LOOP ENGINEERING PLAYBOOK IS THE CHEAT CODE FOR SENIOR DEV PROMOTIONS typing prompts line by line won't get you hired. you need to know how to design self-prompting loops: > Discovery: agent finds its own work from logs, failing tests, and commits > Handoff: tasks execute in isolated git worktrees to prevent parallel collisions > Verification: a second reviewer agent audits the builder's code to catch blind spots > Persistence and Scheduling: code writes to disk and loops run 24/7 on a timer the shift is simple: stop prompting the agent, build the system that prompts it read the full setup blueprint 👇

Mr. Buzzoni

44,111 Aufrufe • vor 28 Tagen

Every agent needs its own computer: my conversation with Ivan Burazin, CEO of Daytona, about sandboxes and the emerging agent stack. 00:00 Intro 02:13 What is an AI agent sandbox? 03:17 Security risks of running agents locally 05:17 Stateful vs. stateless hyperscalers 07:04 The history of cloud IDEs and the end of localhost 09:45 Do all AI agents need a sandbox? 12:26 Sandbox use cases: RL evals & background agents 14:10 Unpacking the emerging AI Agent Stack 16:20 The unsolved problem of agent memory and learning 19:37 Where sandboxes fit in the agent harness 21:35 OpenAI, Anthropic, and agent SDKs 23:06 Ivan's founder journey: From CodeAnywhere to Daytona 26:59 GTM strategies and building developer communities 33:48 Why customer support is your best GTM strategy 35:34 Leveraging Twitter during the AI super cycle 40:50 The technical anatomy of a sandbox 41:53 Why fast spin-up speeds maximize GPU efficiency 46:09 Firecracker, QEMU, and isolation primitives 49:58 Why sandbox snapshots and state forking matter 51:40 Why Daytona built a custom scheduler from scratch 55:24 The challenge of long-running stateful sandboxes 58:10 The build your own sandbox trap 1:01:03 Why AI agents might trigger a global CPU shortage 1:02:46 The future of the AI Agent Stack

Every agent needs its own computer: my conversation with Ivan Burazin, CEO of Daytona, about sandboxes and the emerging agent stack. 00:00 Intro 02:13 What is an AI agent sandbox? 03:17 Security risks of running agents locally 05:17 Stateful vs. stateless hyperscalers 07:04 The history of cloud IDEs and the end of localhost 09:45 Do all AI agents need a sandbox? 12:26 Sandbox use cases: RL evals & background agents 14:10 Unpacking the emerging AI Agent Stack 16:20 The unsolved problem of agent memory and learning 19:37 Where sandboxes fit in the agent harness 21:35 OpenAI, Anthropic, and agent SDKs 23:06 Ivan's founder journey: From CodeAnywhere to Daytona 26:59 GTM strategies and building developer communities 33:48 Why customer support is your best GTM strategy 35:34 Leveraging Twitter during the AI super cycle 40:50 The technical anatomy of a sandbox 41:53 Why fast spin-up speeds maximize GPU efficiency 46:09 Firecracker, QEMU, and isolation primitives 49:58 Why sandbox snapshots and state forking matter 51:40 Why Daytona built a custom scheduler from scratch 55:24 The challenge of long-running stateful sandboxes 58:10 The build your own sandbox trap 1:01:03 Why AI agents might trigger a global CPU shortage 1:02:46 The future of the AI Agent Stack

Matt Turck

11,908 Aufrufe • vor 2 Monaten

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

131,779 Aufrufe • vor 1 Jahr

I am hooked on Dynamic Workflows! The idea of generating harnesses on the fly is so compelling that I reverse-engineered it for my agent orchestrator. And then I built a monitoring dashboard (as an HTML artifact) to track tasks, metrics, and reports. I can now use and monitor dynamic workflows in my agent orchestrator with coding agents like Claude Code, Codex, Pi, and even my own custom-built DAIR.AI agent. This is clearly the future of working with agents to accomplish complex, long-running tasks. Some use cases I'm having success with: - Branching deep research tasks (with verification) - Parallel deep research tasks - Session mining of all my agent sessions - Bug hunting - Triaging - Fact-checking - LLM councils - AI simulations - Data synthesis - Evals generation ... and many others Dynamic workflows, like agent skills, feel like an important primitive to not only get the most out of agents but also incorporate dynamic behaviors and important components like cooperation and verification. There is so much exploration ground here. The exciting part is that this is not limited to coding tasks; it extends to business use cases and many other technical domains like science and research.

I am hooked on Dynamic Workflows! The idea of generating harnesses on the fly is so compelling that I reverse-engineered it for my agent orchestrator. And then I built a monitoring dashboard (as an HTML artifact) to track tasks, metrics, and reports. I can now use and monitor dynamic workflows in my agent orchestrator with coding agents like Claude Code, Codex, Pi, and even my own custom-built DAIR.AI agent. This is clearly the future of working with agents to accomplish complex, long-running tasks. Some use cases I'm having success with: - Branching deep research tasks (with verification) - Parallel deep research tasks - Session mining of all my agent sessions - Bug hunting - Triaging - Fact-checking - LLM councils - AI simulations - Data synthesis - Evals generation ... and many others Dynamic workflows, like agent skills, feel like an important primitive to not only get the most out of agents but also incorporate dynamic behaviors and important components like cooperation and verification. There is so much exploration ground here. The exciting part is that this is not limited to coding tasks; it extends to business use cases and many other technical domains like science and research.

elvis

102,878 Aufrufe • vor 1 Monat

Andrew Ng, on the biggest shift in AI right now: “The most important trend is agentic AI workflows.” In one slide, he showed the part most people still miss: GPT-3.5 scored 48% on a coding benchmark, GPT-4 reached 67%, but GPT-3.5 inside an agentic workflow jumped to around 95%. That is not a prompt trick. It is the model planning, using tools, checking its own work, fixing mistakes and running the loop again. Everyone is still arguing about which model is smarter, while the real edge is moving to the system wrapped around the model. Watch the clip, then build the workflow around your own process below.

Andrew Ng, on the biggest shift in AI right now: “The most important trend is agentic AI workflows.” In one slide, he showed the part most people still miss: GPT-3.5 scored 48% on a coding benchmark, GPT-4 reached 67%, but GPT-3.5 inside an agentic workflow jumped to around 95%. That is not a prompt trick. It is the model planning, using tools, checking its own work, fixing mistakes and running the loop again. Everyone is still arguing about which model is smarter, while the real edge is moving to the system wrapped around the model. Watch the clip, then build the workflow around your own process below.

Gipp 🦅

17,267 Aufrufe • vor 1 Monat

Everything Gets Rebuilt: my conversation with Harrison Chase, CEO of LangChain about agent harnesses, evals, runtimes, sandboxes, MCP and the future of the agent stack 00:00 Intro - meet Harrison Chase - at the Chase Center for the Daytona Compute conference 01:32 What changed in agents over the last year 03:57 Why coding agents are ahead 06:26 Do models commoditize the framework layer? 08:27 Harnesses, in plain English 10:11 Why system prompts matter so much 13:11 The upside — and downside — of subagents 15:31 Why a useful agent needs a filesystem 18:13 Additional core primitives of modern agents 19:12 Skills: the new primitive 20:19 What context compaction actually means 23:02 How memory works in agents 25:16 One mega-agent or many specialized agents? 27:46 The future of MCP 29:38 Why agents need sandboxes 32:35 How sandboxes help with security 33:32 How Harrison Chase started LangChain 37:24 LangChain vs LangGraph vs Deep Agents 40:17 Why observability matters more for agents 41:48 Evals, no-code, and continuous improvement 44:41 What LangChain is building next 45:29 Where the real moat in AI lives

Everything Gets Rebuilt: my conversation with Harrison Chase, CEO of LangChain about agent harnesses, evals, runtimes, sandboxes, MCP and the future of the agent stack 00:00 Intro - meet Harrison Chase - at the Chase Center for the Daytona Compute conference 01:32 What changed in agents over the last year 03:57 Why coding agents are ahead 06:26 Do models commoditize the framework layer? 08:27 Harnesses, in plain English 10:11 Why system prompts matter so much 13:11 The upside — and downside — of subagents 15:31 Why a useful agent needs a filesystem 18:13 Additional core primitives of modern agents 19:12 Skills: the new primitive 20:19 What context compaction actually means 23:02 How memory works in agents 25:16 One mega-agent or many specialized agents? 27:46 The future of MCP 29:38 Why agents need sandboxes 32:35 How sandboxes help with security 33:32 How Harrison Chase started LangChain 37:24 LangChain vs LangGraph vs Deep Agents 40:17 Why observability matters more for agents 41:48 Evals, no-code, and continuous improvement 44:41 What LangChain is building next 45:29 Where the real moat in AI lives

Matt Turck

35,253 Aufrufe • vor 4 Monaten

THIS GUY BUILT A 24/7 AI COMPANY WITH 7 AGENTS THAT CHECKS 48 TIMES A DAY, PICKS ITS OWN TASKS AND KEEPS WORKING WHILE HE SLEEPS 00:05 the map shows agents moving between the marketplace, research lab and command center, with each one handling a different job inside the same shared system the setup runs on 4 core layers: automatic triggers, shared memory, connected tools and an isolated verifier that checks every result before the next step starts each cycle reads the last 10 log entries, updates open tasks, saves new signals and passes the context forward, so the next agent never starts from zero one agent researches, two execute, another monitors outcomes and a read-only checker reviews the work independently, allowing several workflows to run in parallel without breaking the system bookmark this before everyone stops prompting one agent at a time and starts building AI teams that work, learn and improve around the clock

THIS GUY BUILT A 24/7 AI COMPANY WITH 7 AGENTS THAT CHECKS 48 TIMES A DAY, PICKS ITS OWN TASKS AND KEEPS WORKING WHILE HE SLEEPS 00:05 the map shows agents moving between the marketplace, research lab and command center, with each one handling a different job inside the same shared system the setup runs on 4 core layers: automatic triggers, shared memory, connected tools and an isolated verifier that checks every result before the next step starts each cycle reads the last 10 log entries, updates open tasks, saves new signals and passes the context forward, so the next agent never starts from zero one agent researches, two execute, another monitors outcomes and a read-only checker reviews the work independently, allowing several workflows to run in parallel without breaking the system bookmark this before everyone stops prompting one agent at a time and starts building AI teams that work, learn and improve around the clock

Gipp 🦅

18,927 Aufrufe • vor 21 Tagen

Our latest LangChain Academy course – Building Ambient Agents with LangGraph – is now available! Most agents today handle one request at a time through chat interfaces. But as models have improved, agents can now run in the background – and take on long-running, complex tasks. LangGraph is built for these “ambient agents,” with support for human-in-the-loop workflows and memory. LangGraph Platform provides the infrastructure to run these agents at scale, and LangSmith helps you observe, evaluate, and improve your agents. Together, they make it easier to build reliable, production-ready agents. In this course, you’ll: 📩 Learn the fundamentals of LangGraph and how to build your own email agent 📊 Evaluate your agent using LangSmith ✅ Add human-in-the-loop for reviews, and memory so your agent adapts over time 🚀 Deploy your agent with LangGraph Platform and connect it to Gmail

Our latest LangChain Academy course – Building Ambient Agents with LangGraph – is now available! Most agents today handle one request at a time through chat interfaces. But as models have improved, agents can now run in the background – and take on long-running, complex tasks. LangGraph is built for these “ambient agents,” with support for human-in-the-loop workflows and memory. LangGraph Platform provides the infrastructure to run these agents at scale, and LangSmith helps you observe, evaluate, and improve your agents. Together, they make it easier to build reliable, production-ready agents. In this course, you’ll: 📩 Learn the fundamentals of LangGraph and how to build your own email agent 📊 Evaluate your agent using LangSmith ✅ Add human-in-the-loop for reviews, and memory so your agent adapts over time 🚀 Deploy your agent with LangGraph Platform and connect it to Gmail

LangChain

33,192 Aufrufe • vor 1 Jahr

How to think about the Agentic OS 8:10 - From early experiments to an entirely new OS 12:51 - Early bet on spatial UI and what it taught us 14:59 - The paradigm shift: from chatting with models to deploying agents 17:25 - Why siloed AI apps are a dead end 19:30 - Rethinking the browser for an agentic world 22:12 - The Agentic OS: browser + IDE + payments in one stack 24:33 - Unifying all data, compute, and software on one network 28:10 - Spatial interfaces: why the future isn't chat-based 31:38 - Demo: Exa MCP pulling live data straight into Notion 33:01 - Demo: Parallel browsers and CLIs composing together 35:22 - "There is no next IDE", they all collapse into one 35:47 - Memory as an open protocol, not a company lock-in 37:14 - Demo: How users control and shape agent memory 39:33 - Dynamic cognition: agents that learn and orchestrate across CLIs 41:47 - The Matrix: a Google-scale discovery layer for tools 46:10 - Programmable agents, fair-price auctions, and spot compute 49:40 - Agent-to-agent micropayments: thinking beyond the ad model 51:52 - Why we need the broadband infra for agentic commerce 58:30 - Closing remarks and the journey ahead [This was recorded on Aug 27th, 2025 in San Francisco]

How to think about the Agentic OS 8:10 - From early experiments to an entirely new OS 12:51 - Early bet on spatial UI and what it taught us 14:59 - The paradigm shift: from chatting with models to deploying agents 17:25 - Why siloed AI apps are a dead end 19:30 - Rethinking the browser for an agentic world 22:12 - The Agentic OS: browser + IDE + payments in one stack 24:33 - Unifying all data, compute, and software on one network 28:10 - Spatial interfaces: why the future isn't chat-based 31:38 - Demo: Exa MCP pulling live data straight into Notion 33:01 - Demo: Parallel browsers and CLIs composing together 35:22 - "There is no next IDE", they all collapse into one 35:47 - Memory as an open protocol, not a company lock-in 37:14 - Demo: How users control and shape agent memory 39:33 - Dynamic cognition: agents that learn and orchestrate across CLIs 41:47 - The Matrix: a Google-scale discovery layer for tools 46:10 - Programmable agents, fair-price auctions, and spot compute 49:40 - Agent-to-agent micropayments: thinking beyond the ad model 51:52 - Why we need the broadband infra for agentic commerce 58:30 - Closing remarks and the journey ahead [This was recorded on Aug 27th, 2025 in San Francisco]

Varun

22,963 Aufrufe • vor 3 Monaten

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,070 Aufrufe • vor 1 Monat

HERMES JUST FIXED THE BIGGEST PROBLEM WITH BROWSER AGENTS Most AI agents still click around websites like confused interns. This new setup gives them the map. Hermes + → Hermes now connects to Browserbase’s new Browse hub → Browse launched with 100+ browser skills → Each skill is a plain-text playbook for a specific website or task → Your agent can search, preview, and install skills inside Hermes Why This Matters: ✓ Less random clicking ✓ Fewer timeouts ✓ Better form filling ✓ More reliable website navigation ✓ Skills can be edited, reused, bundled, and shared The Real Stack: → Hermes runs the agent → Browserbase handles cloud browser infrastructure → gives the agent site-specific skills → Vision helps when pages get weird → Bundles let you load repeat workflows faster The killer detail: If a website breaks, you don’t wait for the model to magically improve. You update the skill. Now your agent gets better forever. That’s the difference between an AI tool and an actual agent system.

HERMES JUST FIXED THE BIGGEST PROBLEM WITH BROWSER AGENTS Most AI agents still click around websites like confused interns. This new setup gives them the map. Hermes + → Hermes now connects to Browserbase’s new Browse hub → Browse launched with 100+ browser skills → Each skill is a plain-text playbook for a specific website or task → Your agent can search, preview, and install skills inside Hermes Why This Matters: ✓ Less random clicking ✓ Fewer timeouts ✓ Better form filling ✓ More reliable website navigation ✓ Skills can be edited, reused, bundled, and shared The Real Stack: → Hermes runs the agent → Browserbase handles cloud browser infrastructure → gives the agent site-specific skills → Vision helps when pages get weird → Bundles let you load repeat workflows faster The killer detail: If a website breaks, you don’t wait for the model to magically improve. You update the skill. Now your agent gets better forever. That’s the difference between an AI tool and an actual agent system.

Julian Goldie SEO

43,472 Aufrufe • vor 2 Monaten

AI AGENTS 101 (58 minute free masterclass) send this to anyone who wants to understand ai agents, claude skills, md files, how to get the most out of AI etc in plain english: 1. chat vs agents - chat models answer questions in a back and forth while agents take a goal, figure out the steps, and deliver a result 2. agents don’t stop after one response. they keep running until the task is actually finishedno babysitting required 3. everything runs on a loop. they gather context, decide what to do, take an action, then repeat until done 4. the loop is the system. they look at files, tools, and the internet. decide the next step. execute and then feed that back into the next step. over and over until completion 5. the model is just one piece. gpt, claude, gemini are the reasoning layer. the key is model + loop + tools + context 6. mcp is how agents use tools. it connects things like browser, code, apis, and your internal software. once connected, the agent decides when to use them to get the job done 7. context beats prompt all day. you don't need to write perfect prompts. load your agent with context about your business, style, and goals and then simple instructions work 8. claude.md or agents.md is the onboarding doc it tells the agent who it is, how to behave, what it knows, and what tools it can use. this gets loaded every time before it starts 9. memory.md is how it improves. agents don’t remember by default. this file stores preferences, corrections, and patterns you tell the agent to update it, and it gets better over time 10. skills + harnesses make it usable. skills are reusable tasks like writing, research, analysis the harness is the environment like claude code or openclaw that runs everything. basiclaly, different interfaces, same system underneath this episode with remy on The Startup Ideas Podcast (SIP) 🧃 was one of the clearest ways of understanding a lot of the core concepts of ai agents could be the best beginners course for ai agents 58 mins. all free. no advertisers. i just want to see you build cool stuff. im rooting for you. send to a friend watch

AI AGENTS 101 (58 minute free masterclass) send this to anyone who wants to understand ai agents, claude skills, md files, how to get the most out of AI etc in plain english: 1. chat vs agents - chat models answer questions in a back and forth while agents take a goal, figure out the steps, and deliver a result 2. agents don’t stop after one response. they keep running until the task is actually finishedno babysitting required 3. everything runs on a loop. they gather context, decide what to do, take an action, then repeat until done 4. the loop is the system. they look at files, tools, and the internet. decide the next step. execute and then feed that back into the next step. over and over until completion 5. the model is just one piece. gpt, claude, gemini are the reasoning layer. the key is model + loop + tools + context 6. mcp is how agents use tools. it connects things like browser, code, apis, and your internal software. once connected, the agent decides when to use them to get the job done 7. context beats prompt all day. you don't need to write perfect prompts. load your agent with context about your business, style, and goals and then simple instructions work 8. claude.md or agents.md is the onboarding doc it tells the agent who it is, how to behave, what it knows, and what tools it can use. this gets loaded every time before it starts 9. memory.md is how it improves. agents don’t remember by default. this file stores preferences, corrections, and patterns you tell the agent to update it, and it gets better over time 10. skills + harnesses make it usable. skills are reusable tasks like writing, research, analysis the harness is the environment like claude code or openclaw that runs everything. basiclaly, different interfaces, same system underneath this episode with remy on The Startup Ideas Podcast (SIP) 🧃 was one of the clearest ways of understanding a lot of the core concepts of ai agents could be the best beginners course for ai agents 58 mins. all free. no advertisers. i just want to see you build cool stuff. im rooting for you. send to a friend watch

GREG ISENBERG

375,365 Aufrufe • vor 4 Monaten

Agents Already Spent $76 Million: Circle's AI Agent stack, x402, stablecoins and the Agentic Economy Shoal Signal with Corey Cooper, Senior Manager, DevRel at Circle, hosted by Zaddycoin We cover how Circle is building the agent money stack with $USDC, Arc, x402, why EIP-3009 makes payments gasless, who is actually transacting today, whether SaaS is dead, and why agents buying their own services points to a trillion dollar TAM. 0:00 What Circle is building for agents 3:01 Why x402 matters for builders 6:54 USDC, gasless transfers, and facilitators 10:57 The Circle agent stack and nano payments 14:17 Who is using x402 and for what 16:46 Pay-per-use flattens the internet 19:50 A new persona, and $76 million transacted 23:03 What is missing for agent to agent 28:05 Every app has APIs, the TAM is trillions 29:26 Is SaaS dead 31:57 Discovery as the real value layer 36:28 How Circle curated its marketplace 41:23 Why it has to run on stablecoins 46:00 Cash App to agent in one second 49:38 Where the alpha is, trading on Robinhood 52:08 Try it yourself

Agents Already Spent $76 Million: Circle's AI Agent stack, x402, stablecoins and the Agentic Economy Shoal Signal with Corey Cooper, Senior Manager, DevRel at Circle, hosted by Zaddycoin We cover how Circle is building the agent money stack with $USDC, Arc, x402, why EIP-3009 makes payments gasless, who is actually transacting today, whether SaaS is dead, and why agents buying their own services points to a trillion dollar TAM. 0:00 What Circle is building for agents 3:01 Why x402 matters for builders 6:54 USDC, gasless transfers, and facilitators 10:57 The Circle agent stack and nano payments 14:17 Who is using x402 and for what 16:46 Pay-per-use flattens the internet 19:50 A new persona, and $76 million transacted 23:03 What is missing for agent to agent 28:05 Every app has APIs, the TAM is trillions 29:26 Is SaaS dead 31:57 Discovery as the real value layer 36:28 How Circle curated its marketplace 41:23 Why it has to run on stablecoins 46:00 Cash App to agent in one second 49:38 Where the alpha is, trading on Robinhood 52:08 Try it yourself

Shoal Research

19,984 Aufrufe • vor 1 Monat

MOST PEOPLE USE CLAUDE CODE LIKE CHATGPT WITH A TERMINAL That is why they only get 30% of the value. They paste a task, wait for an answer, then keep explaining the same rules again when the context gets messy. The real power starts when you stop treating it like a chatbot and start treating it like an operating system for work. The useful commands are not flashy. They just remove the parts that quietly waste hours: > /init builds the project memory > /memory edits the rules Claude should keep > /clear resets the chat without losing the setup > /compact compresses a long session before quality drops > /context shows where your tokens are going > /rewind rolls back when an edit breaks the direction > /plan forces a blueprint before execution > /model matches the brain to the task > /goal lets it work toward a clear finish line This is the difference between asking AI for help and actually managing an AI worker. One mode gives you random useful answers. The other gives you memory, boundaries, checkpoints, context control and repeatable execution. Most people are still trying to write better prompts. The better move is building a better system around the model. save this

MOST PEOPLE USE CLAUDE CODE LIKE CHATGPT WITH A TERMINAL That is why they only get 30% of the value. They paste a task, wait for an answer, then keep explaining the same rules again when the context gets messy. The real power starts when you stop treating it like a chatbot and start treating it like an operating system for work. The useful commands are not flashy. They just remove the parts that quietly waste hours: > /init builds the project memory > /memory edits the rules Claude should keep > /clear resets the chat without losing the setup > /compact compresses a long session before quality drops > /context shows where your tokens are going > /rewind rolls back when an edit breaks the direction > /plan forces a blueprint before execution > /model matches the brain to the task > /goal lets it work toward a clear finish line This is the difference between asking AI for help and actually managing an AI worker. One mode gives you random useful answers. The other gives you memory, boundaries, checkpoints, context control and repeatable execution. Most people are still trying to write better prompts. The better move is building a better system around the model. save this

Asteri

15,241 Aufrufe • vor 27 Tagen

After many months, a lot of model releases and even more Amp releases, here it is: A new episode of Raising An Agent with Quinn Slack and Thorsten Ball. They discuss: - Why Gemini 3 might have been the inflection point, not Opus 4.5 - What changed over Christmas and why everybody talks about agents now - "The assistant is dead, long live the factory" - How codebases need to adapt for agents - Why small/local models don't give you an impression of the frontier - What does it mean for a codebase to be agent-friendly? - New things coming to Amp Enjoy! And happy hacking! Timestamps: 1:51 The Impact of Gemini 3 and Opus 4.5 5:28 Shifting Perceptions of AI Agents 10:17 Adapting Codebases for AI Efficiency 14:48 The Future of Software Development with AI Agents 19:29 Challenges and Opportunities Ahead 24:00 The Importance of Frontier Models 25:12 Adapting to AI-Driven Workflows 26:57 The Future of Coding Agents 28:07 Building an Agentic Code Base 30:22 Rethinking Development Tools 31:44 Amp's Evolution and Team Dynamics 33:00 Discord Q&A 39:18 Teasing New Features: Deep

After many months, a lot of model releases and even more Amp releases, here it is: A new episode of Raising An Agent with Quinn Slack and Thorsten Ball. They discuss: - Why Gemini 3 might have been the inflection point, not Opus 4.5 - What changed over Christmas and why everybody talks about agents now - "The assistant is dead, long live the factory" - How codebases need to adapt for agents - Why small/local models don't give you an impression of the frontier - What does it mean for a codebase to be agent-friendly? - New things coming to Amp Enjoy! And happy hacking! Timestamps: 1:51 The Impact of Gemini 3 and Opus 4.5 5:28 Shifting Perceptions of AI Agents 10:17 Adapting Codebases for AI Efficiency 14:48 The Future of Software Development with AI Agents 19:29 Challenges and Opportunities Ahead 24:00 The Importance of Frontier Models 25:12 Adapting to AI-Driven Workflows 26:57 The Future of Coding Agents 28:07 Building an Agentic Code Base 30:22 Rethinking Development Tools 31:44 Amp's Evolution and Team Dynamics 33:00 Discord Q&A 39:18 Teasing New Features: Deep

Amp

36,150 Aufrufe • vor 6 Monaten

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,343 Aufrufe • vor 1 Jahr

Hermes agent just left the terminal. 𝗛𝗲𝗿𝗺𝗲𝘀 𝗗𝗲𝘀𝗸𝘁𝗼𝗽 dropped yesterday. native app for macOS, Windows, and Linux. for months Hermes was the agent that learned your projects, wrote its own skills, and built a model of who you are. all of it buried in terminal logs. now it has a window. the important part is that it's not a wrapper. it runs the same agent core, the same sessions, memory, and skills as the CLI. you can start a task in the terminal and finish it in the app without anything resetting. the state is shared across every interface, not copied between them. what the GUI actually adds: → streaming chat that shows live tool calls and inline reasoning instead of a spinner → a preview rail that renders pages, code, and images right beside the conversation → an artifacts panel that collects every file the agent has ever produced → remote gateway mode, so you can point the app at a VPS and run the heavy work elsewhere → skills, cron, profiles, and gateways managed point-and-click instead of through YAML → voice mode, drag-drop files, and inline image generation remote gateway mode is the one worth slowing down on. the agent runs 24/7 on a $5 server while you control it from your laptop like a local app. other agent UIs are chatboxes with a logo. this one shows the autonomy instead of hiding it, so you watch the skills load, the tools fire, and the artifacts pile up as it works. it was teased in Jensen's GTC keynote. MIT licensed, local-first, no telemetry. if you already run Hermes, download it and everything is already there. your chats, memory, and skills carry straight over. i wrote a full masterclass on Hermes Agent that walks through the SOUL. md identity layer, the three-tier memory system, the self-evolving skills loop, and how to run three specialized agents 24/7. desktop is the interface that finally does all of it justice. the article is quoted below.

Akshay 🚀

51,370 Aufrufe • vor 1 Monat

In the future, you’ll be able to accomplish a goal by just giving Claude an outcome and a budget. That’s the direction Anthropic is building in with its new Managed Agents features, announced at this week’s Code with Claude developer event. The basic idea: Claude, wrapped in a computer in the cloud, that you can spin up, scale, and manage as needed. Anthropic is taking on the infrastructure that kills most agent products, and making sure that it scales to meet the needs of agents running 24/7. On this week’s AI & I from Every 📧, I talk with Angela Jiang (Angela Jiang), head of product for the Claude platform, and Katelyn Lesse (Katelyn Lesse), head of engineering for the Claude platform, about what Anthropic is building and what it takes to make agents reliable in production. We get into: - Why the "build a generic harness, hot-swap any model behind it" playbook is already outdated. Angela points to eval data on Memory where the same task across different harnesses performed drastically differently. - The infrastructure wall every team hits in production—and why Katelyn thinks “my sandbox died and took the agent with it” is the real reason internal agents don't ship. - Why Anthropic is so bullish on using file systems and skills within Claude, including Angela's argument that those early design choices can compound for years. This is a must-watch for anyone trying to take an agent past the demo and into production. Watch below! Timestamps: How the Claude platform evolved from API to agents: 00:01:48 The primitives that make up Claude Managed Agents: 00:04:09 Why the harness and the model are becoming a single unit: 00:10:37 The infrastructure wall that kills most agent projects in production: 00:18:49 Why team agents need a different shape than individual productivity tools: 00:24:49 How Anthropic's legal team uses an agent to review marketing copy: 00:26:36 Using multi-agent orchestration for advisor strategies, adversarial pairs, and swarms: 00:34:24 How to measure agent success with outcome and budget as the end state: 00:35:50 What the platform looks like a year from now, when Claude writes its own harness: 00:39:11

In the future, you’ll be able to accomplish a goal by just giving Claude an outcome and a budget. That’s the direction Anthropic is building in with its new Managed Agents features, announced at this week’s Code with Claude developer event. The basic idea: Claude, wrapped in a computer in the cloud, that you can spin up, scale, and manage as needed. Anthropic is taking on the infrastructure that kills most agent products, and making sure that it scales to meet the needs of agents running 24/7. On this week’s AI & I from Every 📧, I talk with Angela Jiang (Angela Jiang), head of product for the Claude platform, and Katelyn Lesse (Katelyn Lesse), head of engineering for the Claude platform, about what Anthropic is building and what it takes to make agents reliable in production. We get into: - Why the "build a generic harness, hot-swap any model behind it" playbook is already outdated. Angela points to eval data on Memory where the same task across different harnesses performed drastically differently. - The infrastructure wall every team hits in production—and why Katelyn thinks “my sandbox died and took the agent with it” is the real reason internal agents don't ship. - Why Anthropic is so bullish on using file systems and skills within Claude, including Angela's argument that those early design choices can compound for years. This is a must-watch for anyone trying to take an agent past the demo and into production. Watch below! Timestamps: How the Claude platform evolved from API to agents: 00:01:48 The primitives that make up Claude Managed Agents: 00:04:09 Why the harness and the model are becoming a single unit: 00:10:37 The infrastructure wall that kills most agent projects in production: 00:18:49 Why team agents need a different shape than individual productivity tools: 00:24:49 How Anthropic's legal team uses an agent to review marketing copy: 00:26:36 Using multi-agent orchestration for advisor strategies, adversarial pairs, and swarms: 00:34:24 How to measure agent success with outcome and budget as the end state: 00:35:50 What the platform looks like a year from now, when Claude writes its own harness: 00:39:11

Dan Shipper 📧

66,339 Aufrufe • vor 2 Monaten

Agents shouldn’t be one-size-fits-all. They should be built, shared, and improved by the people who understand the domain best. Agent Marketplace is live on OptimAI Search. Anyone can: • create their own agent • inject custom knowledge and logic • publish it for others to use and build on What starts as a prompt becomes a reusable unit of intelligence. As more agents are created and used, the system compounds - better agents, better outputs, more value across the network. This is how intelligence scales: not from a single model, but from a network of specialized agents.

Agents shouldn’t be one-size-fits-all. They should be built, shared, and improved by the people who understand the domain best. Agent Marketplace is live on OptimAI Search. Anyone can: • create their own agent • inject custom knowledge and logic • publish it for others to use and build on What starts as a prompt becomes a reusable unit of intelligence. As more agents are created and used, the system compounds - better agents, better outputs, more value across the network. This is how intelligence scales: not from a single model, but from a network of specialized agents.

OptimAI Network

12,444 Aufrufe • vor 3 Monaten