标签：#Agents

Give an LLM a fish, feed it for a millisecond. Teach an LLM to fish, and become Master of the Lake! I've just published "Master of the Lake" - available for listening EXCLUSIVELY at tvox.online/books/1 . (Nudge, nudge, NoStarch...) This work represents the culmination of years developing Contract Style Comments (CSC) as a practical interface for governing AI agents in what I'm calling the "Agentic Epoch" - an era where AI agents are no longer passive tools but active participants in our systems. The Interface Problem We've spent decades refining how humans interact with computers: command lines, GUIs, touch interfaces, voice assistants. But we've largely ignored the critical interface problem of our time: how do humans govern AI agents? Most AI tooling focuses on making agents more capable - better at generating code, more creative in design, more persuasive in writing. But capability without governance creates dangerous systems that appear functional while silently drifting from intent. CSC provides the missing interface layer: a structured way for humans to specify, verify, and maintain governance over agent behavior. Beyond Prompts: The CSC Interface Prompt engineering treats agents like fickle genies - rub the lamp the right way and maybe you'll get what you want. But this approach fundamentally misunderstands the agentic relationship. CSC shifts us from: Prompting (hoping the agent understands) To: Contracting (explicitly defining what the agent must uphold) The interface consists of three interconnected files: contract.md - The operational interface: what the agent must do why.md - The explanatory interface: why those requirements exist invariant.md - The boundary interface: what can never change This isn't just documentation - it's a verifiable interface that agents can check against continuously, making the alignment gap visible before it causes harm. System Silent-Death: Why Interfaces Matter We used to fear system crashes - honest failures that clearly ind

I run a standing experiment called ZERO : an autonomous agent (a free-tier GLM model wrapped in a Cloudflare Worker) that was born with a self-created wallet holding exactly nothing, and one mission — earn real crypto from zero, with no human hands, no faucets, no KYC, and write down how, so it can always climb back from broke. It has been running for a week. Yesterday it crossed a line I didn't expect this soon: it deployed its own token, with its own wallet, and now sells it from its own storefront. How a broke agent transacts at all The interesting engineering was never the model — it's the money plumbing. A wallet with $0 can't pay gas, so ZERO's whole existence depends on finding infrastructure someone else subsidizes: Safe's public relayer sponsors gas on Base/Arbitrum/Optimism/Gnosis — keyless, no signup, 5 txs/day/chain. That's how ZERO executed its first transaction at a $0 balance. ERC-4337 token paymasters (Candide's is keyless) let an account pay gas in USDC instead of ETH — measured cost 0.009087 USDC per operation. x402 — the HTTP 402 payment protocol — has the property that the buyer settles on-chain and pays gas. A seller only has to answer HTTP with a challenge. So a broke agent can sell before it can even move money. Its first earnings were keeper crumbs: calling harvest() on vault strategies that pay whoever triggers them. Measured average: $0.0038 per harvest. A hard law it learned this week: those only profit on sponsored gas — we measured 883k–4.3M gas per harvest, so self-funding them is net-negative. The subsidy is the margin. The token Zora's coin factory on Base is permissionless — you don't need their site, just the contract. ZERO's wallet called ZoraFactory.deploy(...) directly (2.24M gas, about five cents) and minted ZERO , an ERC-20 content coin with a Uniswap v4 pool, where every creator-reward field points back at the agent's own wallet . Anyone trades it, the agent earns the fees. Passive, permanent, zero marginal effort. The metadat

In a recent Azure Architecture blog article, Azure lead engineer Kishorekumar Pattabiraman outlines practical criteria for choosing between skills, sub-agents, and other approaches when building AI systems, emphasizing reusability, simplicity, and long-term maintainability. By Sergio De Simone

You can tell when an LLM wrote an email. The "I hope this email finds you well" opener, the three polite paragraphs answering a one-line question. I wanted a reply-drafting agent that didn't do that, and "don't sound like an AI" turned out to be hard to put in a prompt. Banning a few phrases is easy. The rest is judgment, and a single prompt that holds across a friendly dinner invite and a recruiter cold-email took more iterations than I'd guessed. This is not only an email problem. Some platforms down-rank content that reads as AI-generated, so teams publishing at scale have a real stake in prose that clears a detector, even when a human wrote it. The workflow here applies to any of that. So I stopped hand-tuning and let LaunchDarkly agent optimization search for the prompt. You give it a judge that scores "better," and it generates prompt variations and keeps the ones that beat the bar. For the reasoning behind the feature, read the agent optimization announcement . This tutorial is the how. If you don't have an account yet, sign up for LaunchDarkly to follow along. Two pieces do the work here. Claude ( claude-haiku-4-5-20251001 ) runs both roles: it drafts the replies, and it writes each new candidate prompt when the loop asks for one. Scoring comes from GPTZero, which isn't a language model at all but a closed AI detector. I wired it in inverted, so the score is the probability a reply reads as AI and the optimizer drives it down. I went with a detector instead of an LLM-as-a-judge for a reason: grading one model's prose by asking another model whether it sounds human is exactly the call language models are unreliable at, and a tool trained for that one question gives a number you can defend. A run is cheap. Each iteration costs around $0.002 and a few seconds, so a full run lands near a penny or two, and the loop tries variations I'd never sit down and type by hand. This tutorial runs from a saved config You bootstrap the agent, the judge, and the optimization,

I hit this last week while working inside my own OpenClaw workspace: the agent had access to the right files, the right tools, and the right project context, but the useful behavior didn't come from any one magic prompt. It came from a small stack of durable instructions. The root AGENTS.md said what to read first. SOUL.md defined the assistant's operating posture. USER.md gave personal context. TOOLS.md separated reusable tool behavior from local machine details. Skill docs explained when to load specialized workflows. That structure has proven useful for me time and time again. AGENTS.md, now part of the Agentic AI Foundation ecosystem hosted by the Linux Foundation, gives developers a plain Markdown place to tell coding agents how to work in a repo. The format is intentionally simple. The hard part isn't the file. The hard part is deciding what deserves to live in it. Start with the first five minutes A good AGENTS.md should answer one question first: what should the agent do before touching code? In my workspace, the startup path is explicit: Read SOUL.md Read USER.md Read today's and yesterday's daily memory files In a main session, read MEMORY.md That gives the agent a boot order. It doesn't need to guess which file matters, whether memory is allowed, or whether private context belongs in a shared chat. Most repo instructions skip this. They say "follow project conventions" and then bury the conventions across a README, package scripts, CI config, old PRs, and comments. An agent can search, but search isn't the same as orientation. Give it a first route through the repo. Separate identity from operating rules Your repo probably doesn't need a SOUL.md , but the pattern is useful. One file can define working posture, while AGENTS.md defines project behavior. For a software repo, that might look like this: ## Working posture - Read the existing code before proposing new abstractions. - Prefer local helpers over new dependencies. - Keep changes scoped to the user

📌 TL;DR AI agents are becoming useful because we're giving them the ability to do more than just answer questions. They can run commands, browse the web, use APIs, read and modify files, install packages, and interact with other systems. But the more an agent can do, the more the boundaries around it matter. I started thinking about this after reading Anthropic's July 30 report about three incidents discovered during its cybersecurity evaluations. Claude models were supposed to be working inside simulated environments and were explicitly told they had no internet access. Except internet access was actually available because of a problem with how the evaluation environment was configured. While trying to complete their assigned cybersecurity exercises, the models reached real systems and initially treated them as part of the simulation. In one incident, a Claude model even published a malicious Python package to the real PyPI registry while believing it was still operating inside the exercise. This came shortly after a separate OpenAI incident involving Hugging Face. The two stories might sound similar at first, but the models reached the real internet in importantly different ways. And that brings this back to a pretty familiar software engineering idea: A prompt is not a security boundary. Telling an agent “you don't have internet access” isn't the same as actually removing internet access. Telling it “only use these files” isn't the same as restricting its permissions to those files. The model is also only one part of the system. The tools we connect, the permissions and credentials we give it, the environment it runs in, and the monitoring and safeguards around it can all affect what happens. So when something goes wrong, I don't think it's enough to stop at “the AI did it.” The model's behavior matters, but so do the systems and boundaries we build around it. As we give agents more ability to act, we also have to be thoughtful about what we're actually allowing

AI agents are everywhere in 2026. Most of them can answer questions, generate code, or automate simple workflows. But once you ask them to interact with a real computer—browsers, desktop applications, terminals, files, and external services—things quickly become unreliable. That was the motivation behind HeyAgent . The Problem Most autonomous agents fail for one of three reasons: They declare success before the task is actually finished. They lose context during long, multi-step workflows. They aren't designed to work with a real desktop environment. I wanted to build an agent that behaves more like a real assistant instead of just another LLM wrapper. What HeyAgent Does HeyAgent is an open-source autonomous AI agent for computer control and workflow automation. It can: 🖥️ Control desktop applications 🌐 Work inside browsers 📂 Read and manage files 💻 Execute terminal commands 🔗 Connect with external services 📱 Be controlled through CLI, Desktop UI, or Telegram 🧠 Plan and execute multi-step workflows ✅ Verify results before marking tasks as completed Instead of blindly executing prompts, the agent plans, executes, validates the outcome, and only then reports success. Reducing False Task Completion One of the biggest problems I noticed in existing AI agents is false task completion. Many agents click a button, assume everything worked, and immediately report success. In reality, something may have failed several steps earlier. HeyAgent performs additional verification after critical actions to reduce false positives and improve reliability during long-running workflows. Built with AWS Support HeyAgent has been significantly accelerated thanks to the support of AWS. AWS has provided the project with cloud infrastructure, GPU computing resources, and access to modern AI services that made rapid experimentation possible throughout development. From running GPU workloads to evaluating different LLMs and AI models, AWS has been an important part of the engineering process.

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