<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>AgentEngineering.org</title>
    <link>https://agentengineering.org/</link>
    <description>Practical AI agent engineering for builders, operators, and technical decision-makers.</description>
    <language>en-us</language>
    
        <item>
          <title>How to Review an AI Agent Demo Without Getting Fooled</title>
          <link>https://agentengineering.org/articles/how-to-review-an-ai-agent-demo-without-getting-fooled/</link>
          <guid>https://agentengineering.org/articles/how-to-review-an-ai-agent-demo-without-getting-fooled/</guid>
          <pubDate>Tue, 05 May 2026 10:00:00 GMT</pubDate>
          <description>A 30-minute AI agent demo can prove or disprove production readiness if you know what to test live, what to ask the builder, and what to refuse to accept as proof. The D.E.M.O. lens gives you four tells.</description>
        </item>
      
        <item>
          <title>Introduction to AI Agents: What They Are, How They Work, and When to Use Them</title>
          <link>https://agentengineering.org/articles/introduction-to-ai-agents/</link>
          <guid>https://agentengineering.org/articles/introduction-to-ai-agents/</guid>
          <pubDate>Thu, 23 Apr 2026 12:30:00 GMT</pubDate>
          <description>AI agents are goal-directed software systems that can use models, tools, context, and control loops to work through tasks across multiple steps. This beginner guide explains the idea without the hype.</description>
        </item>
      
        <item>
          <title>Structured Outputs Are Doing More Work Than Most Teams Realize</title>
          <link>https://agentengineering.org/articles/structured-outputs-are-doing-more-work-than-most-teams-realize/</link>
          <guid>https://agentengineering.org/articles/structured-outputs-are-doing-more-work-than-most-teams-realize/</guid>
          <pubDate>Sat, 18 Apr 2026 10:45:00 GMT</pubDate>
          <description>Structured outputs are not just a formatting upgrade. In real agent systems, they help define typed boundaries around tools, routing, approvals, workflows, and downstream state.</description>
        </item>
      
        <item>
          <title>Tool Integration Patterns for Real Agent Systems</title>
          <link>https://agentengineering.org/articles/tool-integration-patterns-for-real-agent-systems/</link>
          <guid>https://agentengineering.org/articles/tool-integration-patterns-for-real-agent-systems/</guid>
          <pubDate>Fri, 17 Apr 2026 18:30:00 GMT</pubDate>
          <description>Tool integration is a durable agent design problem about boundaries, trust, and execution control. MCP matters, but it is one interface pattern inside a much larger tool story.</description>
        </item>
      
        <item>
          <title>AI Agent Frameworks</title>
          <link>https://agentengineering.org/articles/ai-agent-frameworks/</link>
          <guid>https://agentengineering.org/articles/ai-agent-frameworks/</guid>
          <pubDate>Fri, 17 Apr 2026 16:30:00 GMT</pubDate>
          <description>Most framework comparisons are weaker than they look because they compare tools that live at different layers of the stack. The real decision is not just which framework is popular. It is which control surface your team actually needs.</description>
        </item>
      
        <item>
          <title>The Most Common Ways Agents Fail Silently</title>
          <link>https://agentengineering.org/articles/the-most-common-ways-agents-fail-silently/</link>
          <guid>https://agentengineering.org/articles/the-most-common-ways-agents-fail-silently/</guid>
          <pubDate>Fri, 17 Apr 2026 15:30:00 GMT</pubDate>
          <description>The most dangerous agent failures are often not dramatic incidents. They are quieter losses of trust: acceptable-looking outputs hiding weaker trajectories, more rescue, noisier grounding, and rising pressure on the system&apos;s real operating limits.</description>
        </item>
      
        <item>
          <title>Traces as Test Data: Using Production Runs to Improve Agent Quality</title>
          <link>https://agentengineering.org/articles/traces-as-test-data-using-production-runs-to-improve-agent-quality/</link>
          <guid>https://agentengineering.org/articles/traces-as-test-data-using-production-runs-to-improve-agent-quality/</guid>
          <pubDate>Fri, 17 Apr 2026 12:45:00 GMT</pubDate>
          <description>Production traces are not just for debugging. The best ones become future quality protection: regression fixtures, scenario cases, and stronger offline evals. The trick is knowing which traces deserve promotion.</description>
        </item>
      
        <item>
          <title>Online Evals vs Offline Evals</title>
          <link>https://agentengineering.org/articles/online-evals-vs-offline-evals/</link>
          <guid>https://agentengineering.org/articles/online-evals-vs-offline-evals/</guid>
          <pubDate>Tue, 14 Apr 2026 15:30:00 GMT</pubDate>
          <description>Offline evals decide whether a change deserves release. Online evals judge how the live system is actually behaving under real traffic. Production agent teams need both, and they need them for different reasons.</description>
        </item>
      
        <item>
          <title>Drift, Degradation, and Slow Failure in Long-Lived Agent Systems</title>
          <link>https://agentengineering.org/articles/drift-degradation-and-slow-failure-in-long-lived-agent-systems/</link>
          <guid>https://agentengineering.org/articles/drift-degradation-and-slow-failure-in-long-lived-agent-systems/</guid>
          <pubDate>Tue, 14 Apr 2026 14:00:00 GMT</pubDate>
          <description>Many agent systems do not fail all at once. They become less trustworthy gradually: shakier trajectories, rising rescue load, weaker recoveries, and more pressure on the operating envelope long before the output fully collapses.</description>
        </item>
      
        <item>
          <title>What Is Agent Engineering?</title>
          <link>https://agentengineering.org/articles/what-is-agent-engineering/</link>
          <guid>https://agentengineering.org/articles/what-is-agent-engineering/</guid>
          <pubDate>Mon, 13 Apr 2026 20:00:00 GMT</pubDate>
          <description>Agent engineering is the discipline of designing, building, evaluating, and operating goal-directed AI systems that can reason over state, use tools, and act inside real workflows under explicit control.</description>
        </item>
      
        <item>
          <title>AgentOps Is the Missing Layer Between an AI Demo and a Real Product</title>
          <link>https://agentengineering.org/articles/agentops-is-the-missing-layer-between-an-ai-demo-and-a-real-product/</link>
          <guid>https://agentengineering.org/articles/agentops-is-the-missing-layer-between-an-ai-demo-and-a-real-product/</guid>
          <pubDate>Mon, 13 Apr 2026 19:20:00 GMT</pubDate>
          <description>Your AI demo is not your product. AgentOps is the layer that turns agent capability into something reliable, observable, governable, and worth trusting in the real world.</description>
        </item>
      
        <item>
          <title>How Good Agent Memory Actually Works in Production</title>
          <link>https://agentengineering.org/articles/how-good-agent-memory-actually-works-in-production/</link>
          <guid>https://agentengineering.org/articles/how-good-agent-memory-actually-works-in-production/</guid>
          <pubDate>Mon, 13 Apr 2026 17:15:00 GMT</pubDate>
          <description>Good agent memory is not one vector store plus chat history. It is a governed system for deciding what gets scoped, promoted, compressed, pinned, and retrieved.</description>
        </item>
      
        <item>
          <title>Agent Memory Is Growing Up - Why Agents Are Starting to Remember How, Not Just What</title>
          <link>https://agentengineering.org/articles/agent-memory-is-growing-up/</link>
          <guid>https://agentengineering.org/articles/agent-memory-is-growing-up/</guid>
          <pubDate>Mon, 13 Apr 2026 14:00:00 GMT</pubDate>
          <description>Agent memory is changing fast. The next wave of agents will not just remember facts. They will remember workflows, compress experience, and get better at solving the next problem.</description>
        </item>
      
        <item>
          <title>Reliability Reviews for Agents</title>
          <link>https://agentengineering.org/articles/reliability-reviews-for-agents/</link>
          <guid>https://agentengineering.org/articles/reliability-reviews-for-agents/</guid>
          <pubDate>Mon, 06 Apr 2026 11:00:00 GMT</pubDate>
          <description>Regression tests protect the next release. Reliability reviews ask a broader question: is this live agent system still trustworthy enough to keep operating as designed?</description>
        </item>
      
        <item>
          <title>Regression Testing for Agents</title>
          <link>https://agentengineering.org/articles/regression-testing-for-agents/</link>
          <guid>https://agentengineering.org/articles/regression-testing-for-agents/</guid>
          <pubDate>Mon, 06 Apr 2026 10:15:00 GMT</pubDate>
          <description>Regression testing is the release-gate discipline that checks whether an agent got worse after a change. For agent systems, that means testing not only outputs, but also trajectories, side effects, and operating envelopes.</description>
        </item>
      
        <item>
          <title>AgentOps: Running Agents in Production</title>
          <link>https://agentengineering.org/articles/agentops-running-agents-in-production/</link>
          <guid>https://agentengineering.org/articles/agentops-running-agents-in-production/</guid>
          <pubDate>Wed, 25 Mar 2026 14:30:00 GMT</pubDate>
          <description>AgentOps is the operating discipline for live agent systems. It turns traces, evaluations, guardrails, and human controls into an ongoing practice for running autonomous systems safely and reliably.</description>
        </item>
      
        <item>
          <title>Tracing and Observability for Agent Systems</title>
          <link>https://agentengineering.org/articles/tracing-and-observability-for-agent-systems/</link>
          <guid>https://agentengineering.org/articles/tracing-and-observability-for-agent-systems/</guid>
          <pubDate>Mon, 23 Mar 2026 15:30:00 GMT</pubDate>
          <description>Tracing captures what happened inside a run. Observability is the broader operating discipline that makes agent behavior legible enough to debug, evaluate, and trust in production.</description>
        </item>
      
        <item>
          <title>OpenAI Codex as a Coding-Agent Platform</title>
          <link>https://agentengineering.org/articles/openai-codex/</link>
          <guid>https://agentengineering.org/articles/openai-codex/</guid>
          <pubDate>Mon, 23 Mar 2026 09:00:00 GMT</pubDate>
          <description>OpenAI Codex is easy to mistake for just a CLI or coding product. The more useful way to understand it is as a local-first coding-agent runtime built around a shared harness.</description>
        </item>
      
        <item>
          <title>Evaluating Agent Trajectories, Not Just Outputs</title>
          <link>https://agentengineering.org/articles/evaluating-agent-trajectories-not-just-outputs/</link>
          <guid>https://agentengineering.org/articles/evaluating-agent-trajectories-not-just-outputs/</guid>
          <pubDate>Sun, 22 Mar 2026 12:15:00 GMT</pubDate>
          <description>A correct final answer does not prove that an agent behaved well. Agent evaluation has to judge the run itself: the sequence, tool use, recovery behavior, and policy fit that produced the answer.</description>
        </item>
      
        <item>
          <title>Human-in-the-Loop Control Design</title>
          <link>https://agentengineering.org/articles/human-in-the-loop-control-design/</link>
          <guid>https://agentengineering.org/articles/human-in-the-loop-control-design/</guid>
          <pubDate>Fri, 20 Mar 2026 20:15:00 GMT</pubDate>
          <description>Human-in-the-loop design is not about adding vague oversight. It is about deciding where human judgment should sit in an agent system and what type of checkpoint belongs there.</description>
        </item>
      
        <item>
          <title>Supervisor, Router, and Planner-Executor Patterns</title>
          <link>https://agentengineering.org/articles/supervisor-router-and-planner-executor-patterns/</link>
          <guid>https://agentengineering.org/articles/supervisor-router-and-planner-executor-patterns/</guid>
          <pubDate>Thu, 19 Mar 2026 15:30:00 GMT</pubDate>
          <description>Routers dispatch, planners break work into a roadmap, and supervisors retain control across the run. The right orchestration pattern depends on where authority should live.</description>
        </item>
      
        <item>
          <title>Structured Outputs, Guardrails, and Execution Boundaries</title>
          <link>https://agentengineering.org/articles/structured-outputs-guardrails-and-execution-boundaries/</link>
          <guid>https://agentengineering.org/articles/structured-outputs-guardrails-and-execution-boundaries/</guid>
          <pubDate>Thu, 19 Mar 2026 07:30:00 GMT</pubDate>
          <description>Structured outputs constrain shape, guardrails constrain policy, and execution boundaries constrain power. Safe agent systems need all three.</description>
        </item>
      
        <item>
          <title>When to Use a Workflow Instead of an Agent</title>
          <link>https://agentengineering.org/articles/when-to-use-a-workflow-instead-of-an-agent/</link>
          <guid>https://agentengineering.org/articles/when-to-use-a-workflow-instead-of-an-agent/</guid>
          <pubDate>Wed, 18 Mar 2026 20:55:00 GMT</pubDate>
          <description>Use a workflow when the valid path can be defined in advance, predictability matters more than flexibility, and the task does not need runtime path-finding.</description>
        </item>
      
        <item>
          <title>ReAct and the Basic Reasoning Loop</title>
          <link>https://agentengineering.org/articles/react-and-the-basic-reasoning-loop/</link>
          <guid>https://agentengineering.org/articles/react-and-the-basic-reasoning-loop/</guid>
          <pubDate>Wed, 18 Mar 2026 20:30:00 GMT</pubDate>
          <description>ReAct is a reasoning pattern where an agent thinks about the next move, takes an action, inspects the observation, and repeats. It is useful when the next step depends on what the last step discovered.</description>
        </item>
      
        <item>
          <title>Goals, Constraints, and Success Conditions</title>
          <link>https://agentengineering.org/articles/goals-constraints-and-success-conditions/</link>
          <guid>https://agentengineering.org/articles/goals-constraints-and-success-conditions/</guid>
          <pubDate>Wed, 18 Mar 2026 18:00:00 GMT</pubDate>
          <description>Goals tell an agent what outcome to pursue. Constraints define the boundaries on how it may pursue that outcome. Success conditions define what evidence lets the run stop. Real agents need all three.</description>
        </item>
      
        <item>
          <title>The Autonomy Spectrum: From Stateless Calls to Goal-Directed Systems</title>
          <link>https://agentengineering.org/articles/the-autonomy-spectrum-from-stateless-calls-to-goal-directed-systems/</link>
          <guid>https://agentengineering.org/articles/the-autonomy-spectrum-from-stateless-calls-to-goal-directed-systems/</guid>
          <pubDate>Tue, 17 Mar 2026 18:00:00 GMT</pubDate>
          <description>Autonomy is not a binary property that suddenly appears when a system uses tools or takes multiple steps. It is a spectrum shaped by who chooses goals, path, actions, and recovery behavior at runtime.</description>
        </item>
      
        <item>
          <title>Context Engineering: The New Core Skill</title>
          <link>https://agentengineering.org/articles/context-engineering-the-new-core-skill/</link>
          <guid>https://agentengineering.org/articles/context-engineering-the-new-core-skill/</guid>
          <pubDate>Sun, 15 Mar 2026 18:00:00 GMT</pubDate>
          <description>Context engineering is not a replacement for prompt engineering. It is a specialization inside prompt engineering focused on constructing the dynamic, system-heavy parts of the final prompt payload.</description>
        </item>
      
        <item>
          <title>Short-Term Context, Retrieval, and Long-Term Memory</title>
          <link>https://agentengineering.org/articles/short-term-context-retrieval-and-long-term-memory/</link>
          <guid>https://agentengineering.org/articles/short-term-context-retrieval-and-long-term-memory/</guid>
          <pubDate>Sun, 15 Mar 2026 17:00:00 GMT</pubDate>
          <description>Agents do not just need more context. They need clean separation between what the model sees now, what the system can fetch now, and what the system should still know later.</description>
        </item>
      
        <item>
          <title>Memory: Why Agents Need More Than Context Windows</title>
          <link>https://agentengineering.org/articles/memory-why-agents-need-more-than-context-windows/</link>
          <guid>https://agentengineering.org/articles/memory-why-agents-need-more-than-context-windows/</guid>
          <pubDate>Sun, 15 Mar 2026 15:00:00 GMT</pubDate>
          <description>A context window determines what a model can see right now. Memory determines what an agent can preserve across time. Reliable agent systems need more than long prompts. They need continuity.</description>
        </item>
      
        <item>
          <title>What Stripe&apos;s Minions Reveal About Production Coding Agents</title>
          <link>https://agentengineering.org/articles/what-stripes-minions-reveal-about-production-coding-agents/</link>
          <guid>https://agentengineering.org/articles/what-stripes-minions-reveal-about-production-coding-agents/</guid>
          <pubDate>Fri, 13 Mar 2026 12:00:00 GMT</pubDate>
          <description>Stripe&apos;s Minions matter because they show what coding agents look like when they are treated as delegated workers inside a real engineering system. This case study extracts the reusable architecture patterns and compares Stripe&apos;s model with Devin and Claude Code.</description>
        </item>
      
        <item>
          <title>Tool Use: How Agents Take Action</title>
          <link>https://agentengineering.org/articles/tool-use-how-agents-take-action/</link>
          <guid>https://agentengineering.org/articles/tool-use-how-agents-take-action/</guid>
          <pubDate>Thu, 12 Mar 2026 18:00:00 GMT</pubDate>
          <description>Tool use is how an agent leaves pure text generation and interacts with external systems. Reliable tool use depends on more than choosing a function name. It depends on arguments, execution control, permissions, and verification.</description>
        </item>
      
        <item>
          <title>Planning and Task Decomposition</title>
          <link>https://agentengineering.org/articles/planning-and-task-decomposition/</link>
          <guid>https://agentengineering.org/articles/planning-and-task-decomposition/</guid>
          <pubDate>Thu, 12 Mar 2026 16:00:00 GMT</pubDate>
          <description>Planning chooses the path toward a goal. Task decomposition turns that path into executable, verifiable subtasks. In agent systems, the quality of that breakdown often determines whether the run succeeds.</description>
        </item>
      
        <item>
          <title>The Sense-Think-Act Loop</title>
          <link>https://agentengineering.org/articles/the-sense-think-act-loop/</link>
          <guid>https://agentengineering.org/articles/the-sense-think-act-loop/</guid>
          <pubDate>Thu, 12 Mar 2026 13:00:00 GMT</pubDate>
          <description>The sense-think-act loop is the runtime pattern that makes an AI agent agentic. It turns goals and changing state into repeated bounded actions instead of one-shot responses.</description>
        </item>
      
        <item>
          <title>LLMs, Workflows, and Agents: What Actually Changes?</title>
          <link>https://agentengineering.org/articles/llms-workflows-and-agents-what-actually-changes/</link>
          <guid>https://agentengineering.org/articles/llms-workflows-and-agents-what-actually-changes/</guid>
          <pubDate>Wed, 11 Mar 2026 15:00:00 GMT</pubDate>
          <description>The real shift from LLM to workflow to agent is not a buzzword change. It is a change in who owns the task, the execution path, and the next-step decisions.</description>
        </item>
      
        <item>
          <title>Agentic Loops - What Are They and When to Use Them</title>
          <link>https://agentengineering.org/articles/agentic-loops-what-are-they-and-when-to-use-them/</link>
          <guid>https://agentengineering.org/articles/agentic-loops-what-are-they-and-when-to-use-them/</guid>
          <pubDate>Wed, 11 Mar 2026 09:00:00 GMT</pubDate>
          <description>Agentic loops are bounded feedback loops that can inspect state, choose the next action at runtime, learn from feedback, and continue toward a goal inside clear boundaries.</description>
        </item>
      
        <item>
          <title>What Is an AI Agent?</title>
          <link>https://agentengineering.org/articles/what-is-an-ai-agent/</link>
          <guid>https://agentengineering.org/articles/what-is-an-ai-agent/</guid>
          <pubDate>Tue, 10 Mar 2026 15:00:00 GMT</pubDate>
          <description>An AI agent is a goal-directed system that can observe state, decide what to do next, use tools, and act across multiple steps. Here is the clean first-principles definition, plus how agents differ from LLMs and workflows.</description>
        </item>
      
        <item>
          <title>Why Agent Engineering Is Becoming Its Own Discipline</title>
          <link>https://agentengineering.org/articles/why-agent-engineering-is-becoming-its-own-discipline/</link>
          <guid>https://agentengineering.org/articles/why-agent-engineering-is-becoming-its-own-discipline/</guid>
          <pubDate>Tue, 10 Mar 2026 09:00:00 GMT</pubDate>
          <description>Agent engineering is emerging because the hard problem is no longer a single prompt. It is designing closed-loop systems that can reason, retrieve context, use tools, stay governable, and hold up in production.</description>
        </item>
      
  </channel>
</rss>