标签：#agents

Arun Joseph shares real-world insights on scaling enterprise agentic platforms like Deutsche Telekom’s LMOS. He discusses bridging organizational fault lines, replacing tool sprawl with core platform abstractions, and moving beyond basic chatbots to operational intelligence systems through ephemeral agents and an Agent Definition Language (ADL). By Arun Joseph

A few weeks ago Boris Cherny, who leads development on Claude Code, mentioned during a talk at Acquired Unplugged that he doesn't really write prompts for Claude anymore. Instead he writes loops that keep prompting Claude until the work is actually done. The clip went viral on X, racked up nearly 700k views in under 24 hours, and Loop Engineering became the latest term making the rounds in AI development circles. The core idea is straightforward enough. Rather than obsessively tuning a single prompt to get a perfect output on the first try, you build an iterative system around the model: give it a clear goal, feed it the right context, give it tools to work with, evaluate what it produces, and define conditions for when it can stop. Wire those pieces together and the agent stops being a one-shot call and becomes something that iterates, self-corrects, and keeps working until the output actually meets your bar. The efficiency gains over prompt-tuning are real, and that is why the concept resonated so quickly. What struck us as we built and shipped the loop system for our own platform Octo is that almost all of the current conversation around Loop Engineering stays at the single-agent level. You have one model, one cleverly designed loop, one sandbox, and the agent grinds away iteratively until its output passes whatever checks you have set up. That solves a real problem: how one person works faster with AI. But real work, especially inside an organization, rarely fits cleanly inside a single agent loop. A product feature going from idea to shipped code needs someone defining requirements, someone designing the approach, someone writing the implementation, someone verifying quality, someone feeding back results. Those are not different iterations of the same loop. They are interconnected loops that need to pass context and outputs between each other. When loops need to share state, trigger each other, and respect organizational boundaries, single-agent loop design sto

Single agent capabilities have expanded pretty dramatically over the last year. Tool calling went from flaky function selection to reliable multi-step planning. Code generation moved from snippet completion to full module implementations. Desktop GUI control crossed from demo territory into OSWorld benchmark numbers that actually mean something, Mano CUA 1.1 hitting 58.2 percent on the specialized model track, about 13 points ahead of opencua 72b in second place, and WebRetriever NavEval at 41.7, edging past Gemini 2.5 Pro Computer Use at 40.9 and Claude 4.5 Computer Use at 31.3. Those numbers would have been hard to believe a year ago. But the ceiling on single agent systems is getting easier to see. Once a task needs more than one role operating in the same loop, problems stack up fast. A competitor analysis that needs parallel research across three sources before cross-referencing. Code that goes through independent security review after being written. Creative work where you want two independent drafts before picking one. People have tried shoving multiple role descriptions into a single system prompt and having the model switch hats, but in practice the attention bleed between roles is hard to contain. The agent doing the writing naturally overestimates its own output quality. The reviewer sharing the same context chain goes soft on issues it watched get created. We saw this repeatedly in early Mano AFK testing where coding and testing lived in the same agent context. Tests became ceremonial, obvious logic errors slipped through, and things only got better once we split the agents apart. Splitting work across multiple agents is not a new idea. It has been in papers for years. What changed is the cost structure. A year ago running three GPT 4 level instances on a multi-step task meant token bills that added up fast, especially on iterative dev work where the meter kept running across rounds of fixes. That equation looks different now. Small and on device models

In June 2026, Peter Steinberger reported that his system spent $1,305,088.81 over 30 days and...

Embabel has reached its 1.0 release, providing a framework for AI agents on Java It allows Java and Kotlin developers to define agents as typed domain objects. Built on Spring AI, Embabel supports multiple model providers and combines planning with predefined state machines, offering flexibility for agent workflows. By Erik Costlow

Human approval is a decision about one action under a particular set of facts. It is not a permanent permission bit. Imagine an AI agent preparing a refund request: Order: SO-1001 Amount: CNY 199.00 Reason: Duplicate payment The runtime classifies the action as high risk, pauses the task, and asks a human to approve the exact request. At 10:00, the approver reviews the parameters and clicks Approve . The task does not execute immediately. It remains paused, waits in a queue, survives a coordinator restart, and finally reaches dispatch at 15:00. During those five hours, any of the following may have changed: the order may already have been refunded by another channel; the refund policy may now require an additional finance review; the approver may no longer hold the required role; the acting subject may have left the organization; the amount or currency may have drifted during task reconstruction; the tool implementation may have changed; the approval may have been valid for only 30 minutes. Should the system execute merely because a database row still says approved = true ? No. The approval was not a timeless grant. It was a decision about a specific action, represented by a specific subject, using a specific capability, with specific arguments, under a specific policy and set of business facts. This distinction becomes essential when agents move beyond answering questions and begin creating real business consequences. 1. The dangerous simplification: approval = true In conventional administrative software, approval and execution are often close together. A user submits a form, a manager approves it, and the system performs the action soon afterward. That interaction encourages a simplified mental model: approval = true Once that value is stored, downstream code treats the action as permanently authorized. Agent tasks are different. A single task may cross several asynchronous boundaries: understand intent -> select a capability -> construct arguments -> request app

What is MCP (Model Context Protocol)? Complete 2026 Guide TL;DR — Model Context Protocol (MCP) is an open JSON-RPC 2.0 specification, introduced by Anthropic in late 2024, that lets AI agents talk to external systems — file systems, databases, APIs, custom services — through a single standardized interface. An MCP server exposes capabilities (tools, resources, and prompts); an MCP client (Claude Desktop, Cursor, Zed, Sourcegraph Cody, your own agent) consumes them. Write the server once, and every MCP-compatible client can use it — no per-app integration work. If you have built agent tooling before, think of MCP as "LSP for AI tools" : the same idea that unified language servers across editors, now applied to the plumbing between agents and the systems they need to act on. Why MCP Exists Before MCP, every agent framework defined its own tool format. A tool written for LangChain didn’t work in Claude Desktop, which didn’t work in your custom agent, which didn’t work in Cursor. Each integration was bespoke, every prompt-engineered "function description" was framework-specific, and every team rebuilt the same wheel. The pain points MCP solves: Fragmentation. Five frameworks, five tool formats. Five times the work. No discovery. Clients couldn’t enumerate what a tool server offered without a hard-coded manifest. No portability. A debugging assistant you wrote for one agent wouldn’t move to another. Auth was ad hoc. Every integration invented its own way to handle API keys and OAuth. MCP makes the contract uniform: a server declares its tools, resources, and prompts; a client speaks the same JSON-RPC dialect to discover and call them. The same MCP server that ships with Anthropic's TypeScript SDK today will work with any future client that implements the spec, regardless of which LLM the client uses underneath. The Wire Protocol in One Page MCP rides on JSON-RPC 2.0 , which means every message is a JSON object with a jsonrpc: "2.0" envelope, a method , optional params ,

Two weeks ago, I published "Why Agent Evaluation Is Harder Than Model Evaluation." The core argument:...

Originally published on tamiz.pro . The prevailing narrative in artificial intelligence has been dominated by cloud-based, API-driven models. While this approach offers scalability, it introduces critical latency, dependency on external services, and significant privacy concerns regarding data exfiltration. For mission-critical applications, financial analysis, or healthcare systems, the inability to guarantee data residency and offline operation is a non-starter. The solution lies in a "Local-First" architecture, where the AI assistant runs entirely on-premise or on-device. However, building such systems requires more than just downloading an LLM weights file; it demands a robust infrastructure layer capable of managing state, memory safety, and real-time concurrency. This article explores how to construct this infrastructure using two powerhouse languages: Go for its superior concurrency primitives and developer velocity in orchestration, and Rust for its memory safety, zero-cost abstractions, and performance-critical inference execution. We will dissect the architecture of a secure, local-first AI agent, moving from the conceptual model to the implementation details, focusing on the boundary between the orchestration layer (Go) and the execution layer (Rust). 1. The Architectural Paradigm: Separation of Concerns Building a local-first AI assistant is not merely a software engineering challenge; it is a systems architecture problem. The core tension lies between flexibility (the ability to swap models, adjust prompts, and handle complex workflows) and performance/security (minimizing latency and preventing memory corruption or data leaks). To resolve this, we adopt a micro-kernel architecture : The Orchestrator (Go): Handles the user interface, API gateway, session management, tool calling, and high-level logic. Go’s goroutines allow it to manage thousands of concurrent agent sessions with minimal memory overhead. The Engine (Rust): Handles the heavy lifting: mode

Three threads I read this week were about the same question: when should an AI agent stop and ask a human? All three answered at the level of the action. Which tool call is risky, which amount needs a signature, which decision the model isn't allowed to make. The cheapest guardrail I have doesn't live there. It's picking what the thing runs inside. The renderer that never gets trusted Part of what I build renders arbitrary HTML in a headless browser. Anyone can hand it a URL or a page of script, and there's no version of that where I trust the renderer to behave. So it doesn't get asked to. It runs sandboxed, with egress rules, resource limits and a hard wall-clock deadline, and a bad render gets killed rather than reasoned with. None of the safety comes from the thing being careful. The same rule, pointed at my own tooling Reach gets reduced before the run, not judged during it. Two I actually hold myself to: Two browser-automation paths. One drives my real logged-in profile, for the handful of tasks that genuinely need it. One launches an empty throwaway profile, and that's the default for everything else. Secrets get written to a file and passed by path, never echoed into the conversation. A value that never enters the context can't leak through a summary, a log, or a screenshot of the session. Both cost something real. I script a login instead of already being logged in, and I read a path instead of a value. It has overruled the convenient option more than once. Rules the agent follows are still worth having. They just can't be the only layer, because they share one failure mode: they depend on the agent correctly judging what it's about to do. So, one question, since I only have my own handful of examples: what's something you've made structurally impossible for your agent, rather than something you told it not to do?

How AI Is Transforming Software Development Workflows in 2026 By 2026, AI has moved far beyond autocomplete and boilerplate generation. It has become an integral, intelligent partner in the entire software development lifecycle. From writing initial architecture to diagnosing production incidents, AI agents are embedded into the fabric of modern engineering workflows. This transformation is not just about speed—it's a fundamental shift in the way developers think, collaborate, and deliver software. The Rise of AI-Native Development Environments The days of classic IDEs with a chat sidebar bolted on are behind us. In 2026, AI-native development environments are the norm. These IDEs are built around context-aware AI models that understand not just the syntax but the semantic intent of the codebase. Tools like Cursor and Windsurf have evolved into full-blown autonomous agents that can navigate large codebases, propose cross-file refactors, and even execute multi-step changes with minimal supervision. Consider a common task: adding a new payment gateway. In a traditional workflow, a developer would manually trace API routes, update database schemas, and write integration tests. In 2026, the developer simply describes the requirement in natural language. The AI agent explores the existing adapter patterns, creates the new integration, updates configuration files, and runs the test suite. The developer reviews the diff, tweaks edge cases, and signs off. This paradigm shift has accelerated feature delivery by an order of magnitude. Intelligent Automated Testing and Debugging Testing has always been a critical yet time-consuming part of development. AI in 2026 has revolutionised this domain. Instead of writing every test case manually, developers use AI to generate exhaustive test suites that cover edge cases, security vulnerabilities, and performance bottlenecks. The AI analyses the code's control flow, historical bug data, and production logs to generate tests that would

How to Audit Hidden Reminders and Context Usage in Claude Code Logs | Agent Lab Journal Agent Lab Journal Guides Glossary Advanced field guide How to Audit Hidden Reminders and Context Usage in Claude Code Logs Advanced · 45 min read · Local analysis · Updated August 1, 2026 The visible transcript in Claude Code is not necessarily a complete representation of everything recorded around a request. Service messages, internal reminder markers, tool payloads, and usage metadata can exist in session logs without appearing as ordinary chat turns. If you want to know how often ip_reminder occurs—or how input, output, cache creation, and cache read tokens are distributed—you need to inspect the stored records directly and preserve enough structure to avoid misleading totals. In this guide What this audit can establish Concrete investigation case Locate and select one session Preserve an auditable copy Run a quick structural check Build the full local report Interpret reminder and token data Verify the report independently Failure cases and repairs Limitations What this audit can—and cannot—establish This workflow examines one local session stored as JSON Lines (JSONL): a text format in which each line is normally an independent JSON value. It creates a report with: the selected file’s path, size, modification time, and SHA-256 digest; the number of physical lines, parsed records, blank lines, and malformed lines; every record containing the exact, case-sensitive string ip_reminder; the JSON paths at which the marker was found; timestamps and record types when those fields are available; per-record and aggregate input, output, cache creation, and cache read token values; a chronological CSV suitable for a spreadsheet or notebook; a machine-readable JSON report for later comparison. The report shows what is present in the selected file. It does not prove why a reminder was inserted, whether it was transmitted to a model exactly as stored, or how the client’s undocumented inte

This article was originally published on BuildZn . Everyone talks about multi-agent systems but few show you how to actually coordinate them without a ton of boilerplate and deadlocks. I spent weeks trying to get agents to talk, especially when building something like FarahGPT's multi-agent trading system, often hitting insane latency. Turns out, qm can drastically simplify this, and this qm multiplayer AI agent tutorial will show you how to cut task completion times by 20% using a specific Node.js workflow. Why Multi-Agent Systems Aren't Just Hype Anymore (and qm Helps) Single LLM calls hit a wall, fast. You get generic answers, struggle with complex, multi-step tasks, and prompt engineering becomes a full-time job. I've built 9-agent YouTube automation pipelines and an AI gold trading system that needed to analyze market data, news sentiment, and historical trends concurrently. Trying to jam all that into one prompt for a single agent? Forget about it. You need a collaborative AI agent architecture . That's where multi-agent systems shine. You break down complex problems into smaller, manageable tasks, assign them to specialized agents, and have them work together. Think of it like a dev team: one person focuses on backend, another on frontend, another on CI/CD. This is how you handle real-world complexity, and it's how I scaled FarahGPT to 5,100+ users. The challenge? Orchestration. How do these agents communicate? Who manages their state? How do you ensure they don't step on each other's toes or get stuck waiting for slow upstream tasks? This is exactly where qm , a lightweight agent harness, becomes a game-changer for building AI teams. It gives you the primitives to define agents, tasks, and workflows without drowning in custom event loops. The Core Concept: Task Delegation in qm Most qm examples show simple agent interactions. Agent A asks Agent B. Done. But what if Agent A needs to delegate a task that itself needs parallel sub-tasks, and then aggregate the

AI Agent 市场设计:让 Agent 像 App 一样被交易与编排 App Store 把「软件」变成了可被一键购买、安装、评分的商品,AI 时代对应的实体是「Agent」。一个 Agent = 一段可被复用的提示词 + 工具集 + 知识库 + 模型路由配置。本文讲清楚一个 Agent 市场需要哪些核心机制,以及 IHUI-AI 的实现路径。 一、Agent 市场的产品定义 什么是「可上架的 Agent」 不是所有对话 prompt 都能成为商品。一个可上架的 Agent 必须满足: 可独立运行 :用户购买后能立刻用,不需要再写代码。 可复用 :不同用户用同一个 Agent 都能得到稳定结果。 可定价 :有明确的使用边界(次数 / 时长 / 调用规模)。 可评估 :有客观的质量指标(成功率 / 满意度 / 失败率)。 Agent 定义格式 IHUI-AI 用一份 schema 描述可上架的 Agent: const MarketplaceAgentSchema = z . object ({ id : z . string (). uuid (), name : z . string (), description : " z.string(), " // 核心能力 systemPrompt : z . string (), tools : z . array ( z . string ()), // 引用工具/MCP server knowledgeBases : z . array ( z . string ()), // 绑定 RAG 知识库 modelRouting : z . object ({ default : z . string (), // 默认模型 fallback : z . string (). optional (), // 降级模型 }), // 定价 pricing : z . object ({ model : z . enum ([ " free " , " subscription " , " per_call " , " revenue_share " ]), price : z . number (), currency : z . string (). default ( " CNY " ), trialQuota : z . number (). default ( 0 ), }), // 评估 metrics : z . object ({ successRate : z . number (), avgLatencyMs : z . number (), rating : z . number (). min ( 0 ). max ( 5 ), usageCount : z . number (), }), }); 二、四种定价模型 模型 适用 优点 缺点 免费(Free) 引流、品牌 Agent 易扩散 无直接收入 订阅(Subscription) 高频工具型 Agent 收入稳定 流失需运营 按调用计费(Per Call) 低频高价值 Agent 与成本对齐 用户预算焦虑 分成(Revenue Share) 内容生成型 Agent 创作者激励 结算复杂 IHUI-AI 默认采用 订阅 + 按调用混合 :基础功能订阅包月,超出额度按调用计费,创作者拿 70% 分成。 三、Agent 质量评估:四维评分 简单的「5 星好评」不够,因为容易被刷分。IHUI 用四维加权: 任务成功率(40%) :Agent 完成用户原始任务的比率,由 LLM-as-Judge 自动评估。 用户评分(25%) :真实用户打分,过滤异常分布(全是 5 星或 1 星)。 响应延迟(15%) :首 token 时延 + 总时长,归一化到 [0,1]。 稳定性(20%) :错误率 + 重试率,错误越少分越高。 def agent_score ( metrics ) -> float : return ( 0.40 * min ( metrics . success_rate , 1.0 ) + 0.25 * metrics . user_rating / 5 + 0.15 * ( 1 - min ( metrics . p95_latency / 30_000 , 1 )) + 0.20 * ( 1 - min ( metrics . error_rate / 0.1 , 1 )) ) 这个分数实时更新,作为市场搜索排序的依据。 四、Agent 编排:从单个 Agent 到 Agent 工作流 单个 Agent 的能力有上限。Agent 市场的真正价值在于「让用户像搭积木一样编排多个 Agent」。

The Core Argument : AI agent reliability isn't achieved by "making the agent smarter" — it's achieved by the simple engineering principle of separating validation from generation . Quality isn't accidental. It's designed. What You'll Learn : Maker/Checker separation, 6 termination conditions, and an automated feedback loop — all with runnable code. 0. Prerequisites Python ≥ 3.10 OpenAI API Key (or compatible interface) pip install openai>=1.0.0 (Optional) pip install anthropic>=0.30.0 if using Claude as Checker 1. The Pain: Why "Agent Checks Itself" Is a Trap 1.1 The Copying of Cognitive Bias A team built a data-analysis agent. It pulled sales data from a database and generated business reports. The team added a "self-review" step: after generating, the agent told itself "please check if the data you just output is accurate." Result? The agent always replied "data is accurate." Even when the team deliberately injected obvious errors (e.g., monthly sales of -50M RMB), the agent confidently said everything was fine. This isn't the model being "disobedient." It's a more fundamental issue: when the generator and checker are the same entity, the check is just a restatement of the generation process — not real validation. The checker carries the exact same cognitive bias, knowledge boundaries, and reasoning path as the generator. 1.2 The Amplifier Effect of Confirmation Bias Self-checking also triggers a subtler problem: confirmation bias amplification. The model builds a "belief state" during generation; when re-examining, it tends to confirm rather than overturn. Experiment data (from Anthropic research): Same model does "generate → self-review": ~12% error-correction rate A separate model instance reviews: ~37% error-correction rate A different model family reviews: ~52% error-correction rate 1.3 The Value of Independence First principle of quality assurance: the checker must be independent of the generator. In agent architecture, the engineering expression of this is

The Pain : You search GitHub and find everyone using different memory stores — ChromaDB, PostgreSQL, plain Markdown files, "SQLite is good enough for a decade." Which is right? The Answer : All of them. And none of them. Choosing without understanding your scenario is like buying a car without checking the road. 1. The Counter-Intuitive Question: Does Your Agent Actually Need "Memory"? When I was building a university admissions data scraper (91 universities), I made the classic mistake: I equipped the agent with a full ChromaDB + vector retrieval stack, spent three days tuning it, and then discovered — 95% of the agent's time was just reading "which page did I get to last time." A boolean would have sufficed. I built a vector database capable of semantic search. An engineer friend at ByteDance told me their internal agent platform found, after six months, that vector retrieval accounted for only 3.7% of all Memory Store requests. The remaining 96.3%? Key-value lookups, state reads/writes, error dedup. The vector search you spent two weeks integrating might serve less than 4% of your queries. So before discussing "which storage," we must answer a more fundamental question: what does your agent actually need to remember? I categorize memory into four types: Memory Type Typical Content Size Access Frequency Consistency Session state "Processing university 37/91" ~100 bytes Every call Strong Domain knowledge "A-University rate limit is 10 req/s" ~1KB On demand Eventual Error history "B-University returns 403 because UA blocked" ~MB Before new task Append-only Semantic memory "Map 'that red button' to settings page" varies Occasional Eventual See the pattern? If your agent mainly does multi-step automation (data scraping, report generation, CI/CD pipelines), the first three types are the real needs — and none of them require a vector database. Core thesis: memory selection is about finding the layer that is "just enough." One layer too many is waste; one layer too few i

The Pain : You spent an afternoon tuning your agent. Next morning, it stares at you blankly — as if yesterday never happened. What You'll Learn : The 4-stage evolution (Prompt → Context → Harness → Loop), and a runnable 50-line Loop Agent that persists memory. 0. Prerequisites Python ≥ 3.10 pip install openai (openai ≥ 1.0.0) OpenAI API Key OS: macOS / Linux / Windows WSL Goal : Copy-paste the code, run it, and see a Loop Agent that doesn't forget. 1. The Pain: Why Does Your Agent Forget Overnight? At 2 AM, you finally got that multi-step workflow working. The agent followed your carefully designed prompt — data fetching, cleaning, analysis, charting. You close your laptop, satisfied. Next morning, you open the conversation full of hope — and the agent looks at you blankly, as if none of it ever happened. You check the logs. No errors. No exceptions. The agent regenerated everything — it just "forgot" where it stopped yesterday. This isn't a joke. It's the nightmare every serious Agent developer experiences. The root cause isn't "the model isn't smart enough." It's a more fundamental fact: your agent was never designed to survive the night. 2. Four-Stage Evolution: Prompt → Context → Harness → Loop 4-Stage Evolution — each stage solves the previous flaw but adds its own constraint. To understand this, let's use a simple evolution framework: Stage What You Do Fatal Flaw Prompt Engineering Write task description, examples, format into prompt Any unexpected input crashes output Context Engineering Stuff history + intermediate results into context window Token cost grows linearly, hits window limit Harness Engineering Add tool calling, structured output, error capture Framework built, but agent is still "one-shot" Loop Engineering Build closed loop: state + memory + feedback + retry + persistence True engineering — agent starts to "live" Loop Engineering isn't a rejection of Prompt Engineering — it's a transcendence. Prompt still matters. But it's the engine, and you ca

When I joined Entire, I noticed my boss spending a chunk of time every week writing detailed release notes, called Dispatches at Entire. It looked like a painful process. Each Dispatch had to cover changes across several repositories, explain why those changes mattered, credit external contributors, and carefully avoid leaking anything that was not public yet. I offered to take it over. I had solved a similar problem before, so I figured it would be an easy win. I built something similar and simpler at Block While I was at Block, I built a release notes generator for goose . It ran in GitHub Actions after a release workflow completed, checked out the new tag, compared it against the previous one, and handed goose a recipe to inspect the commit diff. Goose organized those commits into features, bug fixes, improvements, and documentation. Each entry got a short description and a PR link. The workflow then updated the GitHub release and posted the announcement to Discord, opening a thread if the notes exceeded the message limit. It was clean and effective, but it solved a very clean problem: one repository, one new release tag, public commit history, and concise output. So when I looked at Entire’s Dispatches, I assumed I could reuse the same playbook. Gather changes, run goose, post the draft. That assumption did not survive contact with reality. But a Dispatch turned out to be more complex A Dispatch spans multiple projects: the Entire CLI, entire.io, EntireDB, external agent integrations, and open source libraries like go-git, go-nuts, git-sync, and ForgeMark. Every project also ships on a different cadence. Some push to main and deploy continuously. Others bundle work into scheduled releases. The CLI maintains separate stable and nightly channels, which means a feature can be available to testers without being part of the latest stable tag. Then there are feature flags. Finding changes was not the hard part because GitHub APIs handle that easily. The hard part was

I've been seeing news everywhere that MCP just went stateless, but I had no clue what it means. So I decided to dig into it and write a blog post about it. Stateless MCP for Beginners The Model Context Protocol (MCP) connects AI assistants to tools, databases, and external applications. In the 2026-07-28 specification revision, MCP removed protocol-level sessions and became stateless. That change makes remote MCP servers easier to operate. They can scale behind ordinary load balancers without sticky routing or a shared MCP session store. Clients can safely cache tool definitions, and agents get more control over which application resources they share. But stateless does not mean MCP servers can no longer remember anything. A browser can still have open tabs, a database transaction can still have uncommitted changes, and a shopping cart can still hold items. The difference is how the client refers to that state. Why MCP Sessions Became a Problem State is information a system remembers between requests. Imagine an MCP server that controls a web browser. An agent might call open_browser , followed by navigate , click , and take_screenshot . The server needs to know that all four actions refer to the same browser. In earlier MCP versions, the connection could provide that context. The client began with an initialize request. Under Streamable HTTP, the server could respond with an Mcp-Session-Id , which the client attached to later requests. The server could then use that ID to recover information associated with the session. This worked naturally when one client talked to one server process. It became more complicated when an MCP service ran across several machines behind a load balancer. If Server A created a session and the next request reached Server B, Server B needed some way to recover that session. Infrastructure teams typically solved this with sticky routing, which kept the client tied to Server A, or a shared database that every server could use for session lo

Watch the short video companion Read or comment on the complete paper: English edition | French edition I spent a long time building AI workflows before admitting something painfully simple: a folder full of instructions is not automatically a tool. A SKILL.md can be brilliant. An AGENTS.md can save a repository. A plugin manifest can package a clean idea. None of them, by themselves, can validate a file, inspect live state, call a service, reject malformed input, or prove that an action happened. That distinction matters because agent ecosystems are expanding faster than their vocabulary. We use skill , plugin , tool , hook , resource , and MCP server as if they were interchangeable. They are not. My rule after this research is direct: A skill should teach the agent how to use a capability. A real plugin should make that capability available. When the task requires action, the plugin needs a motor. The moment my own plugin exposed the problem This article became a case study inside my own workshop. I inspected a memory plugin that was not fake. It already had executable tools, a server surface, tests, and useful routes. Yet its activation instructions pushed Codex toward selecting and dispatching a large agent job before establishing whether memory was needed at all. Nothing was syntactically broken. The architecture was simply asking activation to do too much. Activating a plugin should make capabilities available. It should not behave like a dispatch order. That difference sounds small until the workspace grows. One skill becomes ten. Every correction becomes a permanent rule. Every successful workflow becomes another Markdown file. Soon the model spends the beginning of each task reading the workshop labels instead of touching the work. I call this context debt . The debt appears as hesitation, instruction conflicts, stale rules, broad triggers, and repeated searching. The model is not necessarily weaker. We may have consumed its useful attention before it reach