🤖 Agents
LLM agents that plan, call tools, and act in loops. LangGraph, CrewAI, AutoGen, custom orchestration, multi-agent systems, agent reliability.
The workflow
flowchart LR
A[User goal] --> B[Planner LLM<br/>breaks goal into steps]
B --> C{Tool needed?}
C -->|Yes| D[Tool call<br/>search, code, API]
C -->|No| E[Reasoning step]
D --> F[Observe<br/>tool result]
F --> G{Goal complete?}
E --> G
G -->|No| B
G -->|Yes| H[Final answer<br/>+ trace]
The plan-act-observe loop every modern agent runs. The hard part is reliability across hundreds of iterations.
Key takeaways
Videos (175)
Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic
Stop building bespoke agents per domain — package expertise as portable, file-based 'skills' on top of a universal code-executing agent.
How We Build Effective Agents: Barry Zhang, Anthropic
Use agents only when tasks are ambiguous, valuable, and reversible, keep the architecture minimal, and debug by stepping inside the model's context.
Why Agentic Systems Need Ontologies — Frank Coyle, UC Berkeley
Give agents explicit domain relationships and inference rules to complement probabilistic reasoning.
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
Reliable agents come from applying classic software engineering modularity to small LLM components, not from giving a single agent more tokens and tools.
Harnesses in AI: A Deep Dive — Tejas Kumar, IBM
Reliable agents depend on the runtime, controls, and verification around the model.
Field Guide to Fable — Thariq Shihipar, Anthropic
Revisit tools, prompts, and assumptions as model capabilities grow, and expose the unknowns in your specifications.
How I deleted 95% of my agent skills and got better results — Nick Nisi, WorkOS
Use enforced workflow gates and concrete evidence instead of relying on large instruction sets and agent assurances.
State of the Claw — Peter Steinberger
Open Claw's hyper-growth has made it the largest target for AI-generated security reports, forcing the project to rebuild around hardening and a healthier maintainer bus factor.
Building AI Agents that actually automate Knowledge Work - Jerry Liu, LlamaIndex
Real knowledge-work automation needs a document toolbox (parse, extract, index, manipulate) — not just RAG retrieval.
Architecting Agent Memory: Principles, Patterns, and Best Practices — Richmond Alake, MongoDB
Treat agent memory as a first-class architectural concern with multiple memory types, retrieval pipelines, and forgetting mechanisms — not as 'stuff everything into the context window'.
Building Multimodal AI Agents From Scratch — Apoorva Joshi, MongoDB
Multimodal agents are built by combining LLM reasoning with perception, tools, and persistent memory — but use them only when simpler workflows can't handle the task.
Reinforcement Learning for Agents - Will Brown, ML Researcher at Morgan Stanley
Reinforcement learning, not just bigger models, is the missing piece to take agents from 70%-pipelines to reliable long-horizon autonomous systems.
Claude Agent SDK [Full Workshop] — Thariq Shihipar, Anthropic
Reuse Claude Code's harness (bash + file system + container) instead of building your own agent loop from scratch — most agent tasks become tractable when the model can write code.
Anthropic's CCA Exam as a Field-Guide for Agentic Engineering — Frank Coyle, UC Berkeley
Learn agent engineering through realistic scenarios and failure patterns, especially explicit loop control and tool execution.
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
Agents that work for hours need coordinated context management, planning, and verification alongside stronger models.
The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory
Long-running multi-agent coding works only with adversarial validation contracts and serial-by-default execution plus structured handoffs — not by parallelizing more agents.
The Future Is Domain-Specific Agents - Justin Schroeder, StandardAgents
Domain-specific agents need reusable operational structure and deep integration beyond distributing tools to a general-purpose model.
How to Train Your Agent: Building Reliable Agents with RL — Kyle Corbitt, OpenPipe
Always prompt your way to a working agent first; reach for RL only when prompting plateaus, and design rewards carefully to avoid hacks.
3 ingredients for building reliable enterprise agents - Harrison Chase, LangChain/LangGraph
Reliable enterprise agents come from picking high-value tasks, mixing workflows with agents, and using observability to shrink uncertainty rather than chasing pure autonomy.
Rise of the AI Architect — Clay Bavor, Cofounder, Sierra w/ Alessio Fanelli
Customer-facing AI agents are emerging as the new branded channel after website/app, requiring a new hybrid CX-engineering-brand role to operate them well.
Why (Senior) Engineers Struggle to Build AI Agents — Philipp Schmid, Google DeepMind
Design agents for contextual decision-making, recovery, measurable outcomes, and clearly documented tools.
The Agent Development Life Cycle — Zack Reneau-Wedeen, Sierra
Treat every customer-facing agent as a product with a real engineering lifecycle and dedicated agent engineers, not a one-shot prompt.
Creating Agents that Co-Create — Karina Nguyen, OpenAI
Each scaling paradigm shift opens new product UX patterns; the next frontier is agents that actively co-create with humans rather than just respond.
AgentCraft: Putting the Orc in Orchestration — Ido Salomon
To scale beyond 1-2 parallel agents, treat orchestration like an RTS game: visualize the file system, batch approvals, and offload planning/review rather than per-step babysitting.
Paperclip: Open Source Human Control Plane for AI Labor — Dotta Bippa
Paperclip operationalizes 'zero-human companies' by giving every part of the app an agentic surface inside an org-chart abstraction with built-in QA/approval roles.
Scaling Agents for Gen AI Products - Anju Kambadur, Bloomberg Head of AI Engineering
Finance-grade agents require semi-autonomous architectures with mandatory guardrails and tool APIs as rigorously documented as numerical libraries.
Using agents to build an agent company: Joao Moura
CrewAI is using its own multi-agent platform to run marketing, sales qualification and docs at scale, and is doubling down on code-executing, trainable crews.
Rethinking how we Scaffold AI Agents - Rahul Sengottuvelu, Ramp
Stop scaffolding around weak models; build agent systems where LLMs orchestrate and you scale by throwing more compute (parallel sampling + verifiers) at the problem.
Proactive Agents – Kath Korevec, Google Labs
The next devex shift is from reactive command-line agents to proactive collaborators that observe workflows, anticipate, and stay aligned via human-in-the-loop refinement.
From Chaos to Choreography: Multi-Agent Orchestration Patterns That Actually Work — Sandipan Bhaumik
Treat multi-agent AI as distributed systems engineering and pick choreography vs. orchestration based on workflow complexity and autonomy needs.
Personal, Local, Private AI Agents: Soumith Chintala
Personal agents must be local and context-rich (a home Mac Mini is the practical substrate today) because the right private context matters more than raw model intelligence.
Katelyn Lesse – Evolving Claude APIs for Agents, Anthropic
Anthropic is shipping memory + context-editing + sandboxed code execution as primitives so developers don't build agent harness infra themselves.
Lets Build An Agent from Scratch
An agent emerges once an LLM can read/write its own todo list and decide when to stop — frameworks just wrap these primitives.
Trust, but Verify: Knowledge Agents for Finance Workflows - Mike Conover
Financial knowledge agents need verticalized scaffolding, multi-pass self-verification, and human-in-the-loop nudges—chat alone won't do trust-but-verify work.
Why We Killed Our Multi-Agent Pipeline — Subbiah Sethuraman and Abhilash Asokan, ZS Associates
Use deterministic code for signal detection and preserve end-to-end reasoning instead of fragmenting a tightly coupled analysis across agents.
OpenAI + @Temporalio : Building Durable, Production Ready Agents - Cornelia Davis, Temporal
Combining OpenAI's Agents SDK with Temporal turns agentic loops into durable, crash-tolerant workflows without the developer hand-coding retry, timeout and resume logic.
Ralph Loops: Build Dumb AI Loops That Ship — Chris Parsons, Cherrypick
A dumb-but-persistent agent loop ('Ralph') beats complex orchestration for getting real work shipped, in code and beyond.
Why the Best AI Agents Are Built Without Frameworks (Primitives over Frameworks) — Ahmad Awais, CHAI
Build agents from a small set of cloud-scaled primitives (memory, parser, chunker, threads, tools) rather than monolithic AI frameworks.
Memory Harnesses for Long-Running Research Agents — Stefania Druga, Sakana.ai
Evaluate how memories are ranked and used, and add durable memory where task history exceeds the context window.
How we solved Context Management in Agents — Sally-Ann Delucia
The right context strategy lets agents remember what they need and forget what they don't — context management is a product problem, not just a token-limit problem.
The New Application Layer - Malte Ubl, CTO Vercel
Agents unlock a much larger market of automatable software, and the highest-leverage archetypes are simple research-compression and information-surfacing, not autonomous heroics.
Agents vs Workflows: Why Not Both? — Sam Bhagwat, Mastra.ai
Build with both agents and workflows using readable fluent APIs — don't make your team learn graph theory for production agentic systems.
Building Intelligent Research Agents with Manus - Ivan Leo, Manus AI (now Meta Superintelligence)
Manus is positioned as a general-purpose agent you embed anywhere — its new API plus browser-operator let you ship complex research workflows from a single prompt.
Full Workshop: Build Your Own Deep Research Agents - Louis-François Bouchard, Paul Iusztin, Samridhi
Most 'agent' use cases are really workflows — start simple, climb the autonomy slider only when you must, and engineer the research/writing loop deliberately.
Hard Won Lessons from Building Effective AI Coding Agents – Nik Pash, Cline
In 2025, the leverage in coding agents has shifted from harness cleverness to building RL environments with outcome-only verifiers that train the next model generation.
Agents need more than a chat - Jacob Lauritzen, CTO Legora
Long-horizon vertical agents need verifiability proxies, task decomposition, guardrails, and continuous human steering — chat is the wrong interaction model.
The Web Browser Is All You Need - Paul Klein IV, Browserbase
Every AI agent needs a browser tool because the 'unsexy internet' will never expose first-party APIs.
Claude for Long-Horizon Tasks — Lance Martin, Anthropic
Long-running agents need durable sessions, replaceable execution environments, and independent outcome verification.
Build an AI Research Agent: Apoorva Joshi
Use agents only when the task truly needs multi-step reasoning, tools and memory — and pick ReAct or Reflection patterns to keep the planning loop tractable.
Effective agent design patterns in production — Laurie Voss, LlamaIndex
Build agents around LLMs' real strength — compressing messy text into structure — and lean on frameworks like LlamaIndex to skip boilerplate.
How Deep Research Works - Mukund Sridhar & Aarush Selvan, Google DeepMind
Deep Research trades latency for comprehensiveness via an editable plan, iterative grounded planning, and robust state management over a noisy web environment.
Building Applications with AI Agents — Michael Albada, Microsoft
Build agentic systems incrementally up the agency ladder, minimize tool surface area, and keep deterministic business rules out of the model.
Why Agent Engineering — swyx
Agent engineering is emerging as its own discipline at the intersection of MLE and software engineering, driven by cheaper intelligence, better tools, and clear PMF in coding/support.
Context Graphs for Explainable, Decision-Aware AI Agents — Andreas Kollegger & Zaid Zaim, Neo4j
Autonomous agents need explicit decision context and memory to handle situations that were never fully specified in their instructions.
From Stateless Nightmares to Durable Agents — Samuel Colvin, Pydantic
Long-running agents need durable execution — wrap LLM and tool calls as Temporal activities so crashes don't restart deep-research-style workflows.
Active Graph Agent Runtime (BabyAGI 4) — Yohei Nakajima, Untapped Capital
Making the event log the agent’s source of truth enables auditable execution and controlled self-modification.
Containing Agent Chaos — Solomon Hykes, Dagger
Coding agents need first-class containerized environments — sandboxes for execution aren't enough; the agent itself needs to develop inside the container.
Patrick Dougherty: How to Build AI Agents that Actually Work
Build agents around reasoning and small retrieval tools, then iterate obsessively on the agent-computer interface (tool names, schemas, response formats) per model.
Memory Masterclass: Make Your AI Agents Remember What They Do! — Mark Bain, AIUS
Graph-structured memory preserving causal relationships, not just embeddings, is the missing primitive for trustworthy agentic recall and reasoning.
Demand-Driven Context: A Methodology for Coherent Knowledge Bases Through Agent Failure
Stop monolithic retrieval layers; decompose institutional knowledge into demand-driven context blocks discovered from real agent failures.
A Piece of Pi: Embedding The OpenClaw Coding Agent In Your Product — Matthias Luebken, Tavon
Coding agents become product primitives when you reuse their tool-loop + shell runtime with thin extension APIs for UI and session events.
How to build Enterprise Aware Agents - Chau Tran, Glean
Stop choosing between workflows and agents—train agents on your golden workflows and let agents mine new workflows from real user usage.
Tell the Robot What You Want — Sandhya Subramani, AWS
An agent layer can turn existing robot policies into flexible natural-language workflows while keeping action selection separate from motor execution.
I Gave an AI Agent the Keys to My Life (Here's What Happened) — Radek Sienkiewicz (@velvetshark-com)
A personal AI agent becomes life-changing not from a big-bang install but from incremental layering of channels, automations and a connected knowledge base.
Don't Build Slop (4 Levels of AI Agent Maturity) - Ara Khan, Cline
Advance agent infrastructure according to product needs while keeping execution understandable, minimal, and easy to test.
Computer-use models will agentify the web, not APIs — Dhruv Batra, Yutori
Agents must work with the web’s existing visual interfaces rather than assume comprehensive API coverage.
Keynote: Why people think "agent" is a buzzword but it isn't
Agents aren't a buzzword — they're just hard because step failure compounds; the unlock is models with stronger planning plus better tools and memory.
Agents on the Canvas in tldraw — Steve Ruiz, tldraw
Putting agents directly on a shared canvas with visible state turns AI from a sidebar assistant into a multi-agent collaborator on spatial work.
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
Memory/statefulness — not bigger models or more tools — is the binding constraint preventing agents from becoming actually useful in production.
How to Build Planning Agents without losing control - Yogendra Miraje, Factset
Insert a natural-language blueprint step between user intent and planner to keep enterprise planning agents controllable, debuggable, and tractable.
Tribal Dungeons of Global Shipping: AI Agents at Global Scale — Dmitry Buykin, Maersk
Reliable enterprise agents emerge from continuously refining executable operational knowledge and bounded workflows with domain experts.
Skill Issue: How We Used AI to Make Agents Actually Good at Supabase — Pedro Rodrigues, Supabase
Skills (markdown + scripts with progressive disclosure) outperform stuffing tools into MCP contexts for teaching agents how to work inside a product like Supabase.
Code Mode: Let the Code do the Talking - Sunil Pai, Cloudflare
Drop JSON tool calls for code generation against a typed runtime — vastly fewer tokens, faster execution, and emergent state-machine inhabitation.
Why More Context Makes Your Agent Dumber and What to Do About It — Nupur Sharma, Qodo
Improve agent reliability by selecting relevant context and bounding exploration rather than simply expanding the context window.
Architecting and Testing Controllable Agents: Lance Martin
Use LangGraph to encode the parts of an agent's control flow you want fixed while letting the LLM steer the parts that need flexibility.
Building durable Agents with Workflow DevKit & AI SDK - Peter Wielander, Vercel
Wrap long-running agents in a workflow library to get durability, retries, observability and human approval without manual queue plumbing.
Build Systems, Not Code - Angie Jones, Agentic AI Foundation
Building reliable agents requires familiar engineering disciplines applied to workflows, context, tools, and persistent state.
The 3 Pillars of Autonomy – Michele Catasta, Replit
For non-technical users, autonomy means offloading every technical decision — anchored by verification and context, not just long runtimes.
Beyond the Harness: A Journey Towards Adaptative Engineering - Rajiv Chandegra, Annicha Labs
Match orchestration to the problem's stability, and consider adaptive structures when predefined workflows cannot accommodate real-world change.
Introducing Strands Agents, an Open Source AI Agents SDK — Suman Debnath, AWS
Strands treats agent building as just-model-plus-tools, leveraging MCP and LLM reasoning rather than hand-written scaffolding.
Useful General Intelligence — Danielle Perszyk, Amazon AGI
Amazon's bet is reliable browser-based agents (NovaAct) that augment humans rather than replace them — automation has to lead to augmentation, not echo-chamber lock-in.
Agents' next frontier: agent-to-agent and network effects — Jean-Denis Greze, Town
Agent network effects depend on getting useful information across trust boundaries through acceptable privacy tradeoffs.
Multi Agent AI and Network Knowledge Graphs for Change — Ola Mabadeje, Cisco
Network change management is a natural fit for multi-agent systems backed by a graph-shaped digital twin of the network.
Case Study + Deep Dive: Telemedicine Support Agents with LangGraph/MCP - Dan Mason
For regulated healthcare agents, pair LangGraph's visual orchestration with hybrid human-in-the-loop and MCP tools so doctors stay in control.
Identity for AI Agents - Patrick Riley & Carlos Galan, Auth0
Production agents need a dedicated identity layer—async user approval, token vaulting, and fine-grained authorization—not just API keys in environment variables.
From coding to Knowledge work agents — Karan Vaidya, Composio
Knowledge work agents need shared context, action history, and verification infrastructure to become trustworthy.
The Devops Engineer Who Never Sleeps — Diamond Bishop, Datadog
Build vertical, evaluation-first devops agents that augment runbooks rather than generalist assistants, and make their reasoning visible for trust.
Automating Large Scale Refactors with Parallel Agents - Robert Brennan, OpenHands
Parallel agent orchestration in cloud sandboxes is unlocking automated remediation of tech debt at a scale impossible for single-agent or human workflows.
Hacking Subagents Into Codex CLI — Brian John, Betterup
You can bolt Claude-Code-style subagents onto Codex CLI with a wrapper-script + file-handoff pattern, but tuning the sandbox permissions is the real engineering challenge.
How Lovable self-improves every hour — Benjamin Verbeek, Lovable
Learn from resolved user friction and reuse generalized solutions before other users encounter the same failure.
The Agentic Commerce Stack — Ahnaf Prio, Best Buy
Reliable agentic shopping requires structured merchant integrations and clearly separated discovery, commerce, and payment responsibilities.
How Google DeepMind Runs Agents at Scale — KP Sawhney & Ian Ballantyne, Google DeepMind
Scaling agents requires a reusable harness plus disciplined management of skills, context, and inference resources.
How I automate my own job at Hugging Face using agents — Niels Rogge, Hugging Face
Automate a known workflow with simple scheduled LLM steps, adding autonomy where varied follow-up work demands it.
Every Harness Will Become A Claw — Sam Bhagwat, Mastra
The next evolution of agent harnesses combines durable execution with proactive triggers and learning from experience.
The Agentic AI Engineer - Benedikt Sanftl, Mutagent
Automating the agent-development feedback loop requires explicit specifications, meaningful evals, and production-grounded diagnosis.
Building Agents at Cloud Scale — Antje Barth, AWS
Cloud-scale agents are enabled by model-driven SDKs like Strands plus retrieval over tool catalogs to dodge context-window limits.
Skills are new features: Building Skill-Centric Harness — Yogendra Miraje, FactSet
Treat skills as evaluated, model-dependent product features and build the harness that reliably discovers and executes them.
Agents for Everything Else — swyx
Agents are leaving the IDE — running a real $9M business with 9 people via coding agents proves they can take over ops work too.
UX Design Principles for Semi Autonomous Multi Agent Systems — Victor Dibia, Microsoft
For agents that act in stateful environments, design the UX around streaming plan visibility and a mix of deterministic tools and autonomous exploration.
The Log Is The Agent - Ishaan Sehgal, Omnara
Make the event log primary so agent identity survives worker failures and runtime changes.
Make your own event-sourced agent harness using stream processors — Jonas Templestein, Iterate
Event-sourced, URL-addressable agents with composable plugins offer a more debuggable and extensible alternative to monolithic agent harnesses.
Building Agents (the hard parts!) - Rita Kozlov, Cloudflare
Build agents as four loosely-coupled components (client/AI/workflows/tools) and use durable, stateful compute primitives like Cloudflare Durable Objects to back them.
Give Your Agent a Computer — Nico Albanese, Vercel
Production agents need their own sandboxed computer — Vercel Sandbox + AI Gateway makes that an OIDC-authenticated primitive.
Agents Building Agents - Alfonso Graziano, Nearform
Coding agents can improve other agents through repeated changes measured against explicit evaluation targets.
Computer-Use 2.0: Agents Just Got Multi-Cursor — Francesco Bonacci, Cua
Better computer-use interfaces help, but trustworthy progress depends on reproducible tasks and robust evaluators.
Building Multi agent Systems with Finite State Machines
Pair LLMs with finite state machines + actors to get governable, auditable agentic systems that compensate for LLM unpredictability.
Teaching Coding Agents to do Spreadsheets - Nuno Campos, Witan Labs
Spreadsheet agents improve when persistent code execution and calculation or visual feedback replace fragmented tool calls.
This video was edited with AI agent. But how?
Code-generating agents plus a browser-renderable JS video library make programmatic video editing feasible end-to-end.
What the Best Agents Share — Mardu Swanepoel, Flinn AI
Strong agents combine constrained modes, visible execution, personalization, and undo controls to support collaboration.
Viktor: AI Coworker That Lives in Slack — Fryderyk Wiatrowski
Building a company-level AI coworker in Slack hinges on permissioned multi-user memory and collapsing Slack's many interaction modes into a coherent agent context.
The Age of the Agent: Flo Crivello
Single AI assistants like Lindy are stepping stones; the real unlock is multi-agent societies that build their own integrations and tools.
The Demo I Wish I'd Had: OpenAI's Agents SDK... serverless! - Brook Riggio
A production-friendly agent stack today is Next.js + Vercel + Inngest + OpenAI Agents SDK Python, glued by serverless functions and event-driven orchestration.
How to Improve Your Agents: Academic Lit Review
Agent progress maps onto self-driving-style autonomy levels — most production agents sit at L2/L3, with multi-task L4 emerging.
Stop AI Agent Hallucinations: 5 Techniques + Production Patterns - Elizabeth Fuentes, AWS
Reduce hallucination opportunities with selective context, verifiable computation, and enforcement outside the prompt.
Continual Learning for AI Agents: From Failures to Durable Improvements - Soheil Feizi, RELAI
Turn failures into replayable learning environments before deciding which agent layer to change.
Emergence Launch: AI Agents and the future enterprise: Dr. Satya Nitta
Emergence is pitching orchestration plus self-improving web agents as the substrate for autonomous enterprise workflow automation.
Building Agents with Amazon Nova Act and MCP - Du'An Lightfoot, Amazon (Full Workshop)
AWS's Strands + Nova Act + MCP combo lets developers build browser-control agents in tens of lines, with Q CLI as the default productivity surface.
Building Reliable Agentic Systems: Eno Reyes
Reliable agentic systems borrow robotics-style state filtering, MPC replanning, consensus sampling, and unapologetic hardcoded plan criteria.
Cohere: Building enterprise LLM agents that work (Shaan Desai)
Enterprise agents that actually work come from disciplined tool-spec engineering, conservative multi-agent design, and step-level evaluation—not framework choice.
Your Finance Agent's Bottleneck Is You — Ramana Siddanth Emani, Auditoria AI
Improve the development harness continuously so production failures become faster, repeatable repair workflows.
How agents will unlock the $500B promise of AI - Donald Hruska, Retool
The agent itself is easy in 100 lines of code; productionizing security, observability, connectors and compliance is why most enterprises will buy a managed agent platform.
Every Solo Agent Builder Eventually Reinvents a Worse Version of CI/CD - Sumaiya Shrabony
An agent output is ready only when blocking boundary checks pass, not when it looks complete.
From Signal to PR: Anatomy of a Self-Improving Agent — Jason Lopatecki, Arize
Connect production telemetry to agent investigations so humans start with evidence and proposed changes instead of a cold debugging session.
Events are the Wrong Abstraction for Your AI Agents - Mason Egger, Temporal.io
Putting events at the center of agent architectures hides the real workflow logic; durable-execution engines model business intent more honestly.
The Unbearable Lightness of Agent Optimization — Alberto Romero, Jointly
Single-axis context engineering hits a ceiling; multi-dimensional meta-controllers that pick the right tool per task profile beat uniform pipelines on both quality and cost.
Your Support Team Should Ship Code – Lisa Orr, Zapier
Zapier's Scout agent turns the support team into shippers of integration fixes by orchestrating diagnosis and codegen MCP tools end-to-end inside their existing Jira/GitLab workflow.
The Missing Layer After Launch - Raphael Kalandadze, Wandero AI
Treat post-launch monitoring and repair as a product capability that must itself be calibrated and evaluated.
Always-on agents run production without the on-call tax — Justin Smith, Resolve AI
Production agents need continuously maintained operational context to handle both incidents and routine maintenance.
Agents are Robots Too: What Self-Driving Taught Me About Building Agents — Jesse Hu, Abundant
Treat coding/browser agents as digital robots — invest in closed-loop sensing, sampling rates, and an offline simulation/eval stack, not just better models.
Breaking the Chain: Agent Continuations for Resumable AI Workflows - Greg Benson
Agent continuations let you snapshot, persist and resume in-flight agent state across hosts so HITL approval and long-running workflows survive process restarts.
From Blind Spots to Merged PRs: Continuous Agentic Performance Optimization - May Walter, Hud
Make performance work actionable by pairing production-grounded investigation with measured evidence that a proposed fix helps.
Agents in Production: How OpenGov Built and Scaled OG Assist - Gabe De Mesa, OpenGov
A shared agent platform scales across products when domain tools, runtime control, contracts, and feedback are designed together.
Hyperspace More Nodes Is All You Need: Nicolas Schlaepfer
A decentralized peer network plus a fine-tuned planning DAG model can give power users an editable agentic workflow over diverse open models.
Ship it! Building Production Ready Agents — Mike Chambers, AWS
Bedrock Agents productionizes the five components of an agent (model, prompt, loop, history, tools) without managing GPU infra.
Agentic Workflows on Vertex AI: Rukma Sen
Agents on Vertex AI are model+tools+orchestration with explicit responsibility for safety, privacy, and clear gen-vs-fact UX as wearables make AI ambient.
Bounded Autonomy: Between Free Will and Determinism — Angus J. McLean, Oliver
Bound agent autonomy with deliberate context and workflow constraints tied to the actual business task.
Stop Using RAG as Memory — Daniel Chalef, Zep
Model agent memory after your business domain using a typed knowledge graph instead of dumping facts into a vector store.
Beyond Conversation: Why Documents Transform Natural Language into Code - Filip Kozera
Move from chat to documents-as-specs to repeatable background agents triggered by emails/meetings — human role becomes Tinder-style swipe-approve.
What Does Done Even Mean? Agents and Paperclip's Liveness Model - Dotta, Paperclip
Treat agent completion as a structured, evidence-backed contract rather than a status checkbox.
The Agentic Web and the Bazaar Era of AI - Ramesh Raskar, MIT Media Lab
An interoperable agent web needs shared discovery and trust infrastructure in addition to individual agent runtimes.
The Future of Work: Toran Bruce Richards, Silen Naihin et al
AutoGPT is doubling down on open-source, benchmark-driven, safety-conscious generalist agents — with code agents as the priority milestone toward AGI.
Morgan Stanley's ALPHALAB: Multi-Agent Research Across Optimization Domains — Brendan Rappazzo
Automated research needs a harness that connects hypotheses, trustworthy evaluations, compute access, and reusable domain context.
Perception Agents — Antje Barth, Amazon AGI Lab
Reliable computer-use agents need a continuous perception-and-feedback loop grounded in the same interface the user sees.
Autonomous Agents for Scientific Tasks - Sina Shahandeh, Radicait
Explicit problem decomposition can help autonomous research agents generate ideas beyond incremental code optimization.
Effective AI Agents Need Data Flywheels, Not The Next Biggest LLM – Sylendran Arunagiri, NVIDIA
Sustained agent quality comes from a closed-loop data flywheel that uses production traces and feedback to fine-tune, not from bigger base models.
The Factory That Dreams: 39 AI Agents, No Framework - Rushabh Doshi, Machinecraft
A useful company agent system can emerge from organized institutional memory, narrow specialists, and persistent human corrections.
Using RL Agent to Detect and Remediate ETL Pipeline Failures - Anna Marie Benzon
Use learning for bounded remediation choices while keeping operational authority and escalation rules outside the learned policy.
Browser Agents Don't Need Better Models. They Need Better Eyes. - Kushan Raj, ARK
Compact whole-page observations and precise action feedback can improve browser agents without requiring stronger models.
From Copilot to Colleague: Trustworthy Agents for High-Stakes - Joel Hron, CTO Thomson Reuters
For high-stakes domains, agentic AI requires expert-driven evals, tunable agency dials, and exposing legacy systems as agent tools.
Building Code First AI Agents with Azure AI Agent Service — Cedric Vidal, Microsoft
Azure AI Agent Service moves agent state, tools, and data integrations to the cloud, trading flexibility for a much simpler stateful dev model.
Bringing agents onto the world wide web — Paul Klein IV, Browserbase
Build and measure a domain-specific browser harness to turn existing model capability into reliable web automation.
Agents Need Receipts, Not More Tool Calls - Armanas Povilionis, Alithea Bio
Cross-organization scientific automation needs signed provenance and transaction records alongside tool access.
Stateful environments for vertical agents — Josh Purtell, Synth Labs
Wrap vertical-agent workspaces in resetable stateful environments to enable model swaps, multi-agent, rollbacks, and tree search out of the box.
From Systems of Record to Systems of Context — Omri Bruchim & Tomer Ast, monday.com
Useful workplace assistants need continuously maintained relationships and priorities, beyond access to raw records.
The 100-Tool Agent Is a Trap - Sohail Shaikh & Ankush Rastogi, Prosodica
Retrieve a small relevant tool set on demand instead of making every request carry the full catalog.
Claude plays Minecraft!
Minecraft is a great agent playground; Amazon Bedrock Agents with Return-of-Control let you wire LLM tool use into Mineflayer for emergent in-world behavior.
What If Your Chip Design Team Moved Like a Single Body? — Abduallah Mohamed, AIDAChip
Shared constraints, institutional knowledge, and approved change propagation can make specialized agents useful across an entire chip-design organization.
Real AI Agents Need Planning, Not Just Prompting - Yuval Belfer
ReAct agents can't see the forest for the trees — explicit pre-execution planning (form- or code-based) is what makes complex agents reliable.
Agents Need Feature Flags - Sachin Gupta
Treat agent behavior as deployable software with targeted rollouts and runtime controls that can promptly limit or stop actions.
Don't Let the LLM Drive - Ornella Bahidika & Joel Allou, Microsoft
Reliable multi-step agents need application-controlled state and validation around narrowly scoped model calls.
Beyond APIs: How AI Web Agents Are Automating the "Long Tail" of Knowledge Work
Browser-side AI web agents like Retriever automate the long tail of knowledge work where APIs don't exist — multi-tab scraping + dynamic third-party tool calls.
Building Reliable Support Agents Using the Effect Typescript Library - Michael Fester
Effect brings functional-programming rigor to TypeScript so LLM agents get retries, fallbacks, observability and type-safe dependency injection without rolling your own infra.
Local Agentic Theory For Mobile Games — Shafik Quoraishee & Joanne Song, The New York Times
Useful mobile game agents must fit local memory and frame-time budgets while preserving offline and privacy benefits.
Respect The Process - Andrew Dumit, Watershed Technology Inc.
When several answers may be defensible, agent verification must examine the process and lineage of consequential changes.
Which Jobs Can Be Replaced Today: Fryderyk Wiatrowski and Peter Albert
Replace the reactive layer of any job first via a trigger aggregator + browser actions; advance through prompt → cog-arch → FT → RL only as needed.
Wearing the Agent: From Group Chats to Glasses — Sai Krishna Rallabandi
Group and wearable agents must manage who receives information and enforce action boundaries across a shared, evolving context.
Can Oncology Workflows Run Without Human Touch? - Anant Shankhdhar, Risa Labs
No-touch healthcare administration requires corroborated evidence and deterministic gates that identify which cases can safely bypass review.
Grounded Reasoning Systems for Cloud Architecture - Iman Makaremi
Cloud-architecture AI needs grounded multi-agent reasoning over both text requirements and graph topology, not just IaC generation.
Healthcare’s Agent Bytecode: X12 as the Harness for AI Agents — Vasant Kearney, Onlay
Structured X12 transactions can anchor flexible healthcare agents in enforceable contracts throughout long insurance workflows.
The missing pieces of workflow automation — Shirsha Chaudhuri, Thomson Reuters Labs
Enterprise agentic workflow automation is bottlenecked by legacy connectors, reliability metrics, standardization, and human-agent collaborative UX — not by model capability.
The Current State of Browser Agents - Jerry Wu and Wyatt Marshall
Browser agents are now feasible for read tasks and creeping into write tasks, but evaluation is hard and the underlying browser infrastructure can swing performance as much as the model.
Machines of Buying and Selling Grace - Adam Behrens, New Generation
Agentic commerce needs intent-level rails — unified product APIs, delegated payment auth, and dynamic merchant interfaces — not just bots clicking buy buttons on legacy sites.
Stop Guessing: Build Robust AI with Layered CoT
Adding a verification step after each reasoning hop converts brittle Chain-of-Thought into a self-correcting, auditable pipeline suitable for multi-agent systems.
Medic for Apache Spark - First Aid for Failing Jobs - Drasko Profirovic, Pinterest
Reliable infrastructure diagnostics comes from reproducible evaluations, curated evidence, and specialized agents that keep the main investigation context manageable.
Ionic Launch: Opening the economy to AI agents
Agents need agent-native commerce infrastructure (rich SKU data + single-step transactions) and a merchant-paid monetization model to scale beyond consumer subscriptions.