标签：#agents

Running AI agents on Kubernetes raises a key question: should each agent get its own Pod? The kagent project argues no—agents are bursty, short-lived, can spawn subagents, and may wait for human approval, making one Pod per agent wasteful. Agent-substrate adds a control plane to schedule logical “Actors” onto long-lived worker Pods. By Mark Silvester

Vercel Labs has introduced Zero, an experimental systems programming language aimed at AI rather than human users. It employs unique features like a specific toolchain contract and structured error messages. Reaching version 0.3.4, it compiles to native binaries for major operating systems. The language prioritizes size, speed, and agent usability, though it is still in development. By Daniel Curtis

How to Add a Real-Time Search Layer to an Agent Graph Agent frameworks make it easier to build systems that can plan tasks, call tools, maintain state, and decide what to do next. But a well-designed workflow can still produce a confidently structured wrong answer. The graph may execute exactly as expected while relying on information that is outdated, incomplete, duplicated, or difficult to verify. This becomes especially noticeable when an agent handles recent news, product information, market research, academic research, or other knowledge-intensive tasks. One way to address this is to treat real-time search as a shared evidence layer inside the agent graph. In this article, I will break down a practical architecture for doing that. Disclosure: This article uses Cloudsway SmartSearch as one implementation example. The overall architecture is provider-agnostic and can work with other search APIs that return structured results and source metadata. The Difference Between an Agent Loop and an Agent Graph A basic tool-using agent often follows a loop: Reason ↓ Choose a tool ↓ Observe the result ↓ Decide what to do next This pattern works well for relatively simple tasks. As the number of tools, branches, and stopping conditions grows, however, the system prompt may begin carrying too much responsibility. It must describe the tools, maintain context, control branching, evaluate results, and decide when the task is complete. An agent graph makes that control flow explicit. Instead of asking one model to manage the entire process, the workflow can be divided into nodes such as: User Request ↓ Router ↓ Query Planner ↓ Search ↓ Source Verification ↓ Answer Generation Each node has a narrower responsibility. The router decides whether external information is required. The planner creates focused search queries. The search node retrieves evidence. The verifier evaluates the quality of that evidence. The final node generates an answer from the verified sources. If the evidenc

The one-second decision no one is helping your agent make Here's a scenario that is no longer hypothetical. Your autonomous agent is working through a task. It hits a paid API — an HTTP 402 Payment Required with a price in USDC. It signs a stablecoin authorization, pays, and continues. No credit card form, no invoice, no human. Roughly one second, start to finish. This is x402, the protocol that finally gave the dormant HTTP 402 status code a job. And it works: by mid-2026, on-chain trackers counted over 165 million cumulative x402 transactions across ~69,000 active agents. Coinbase, Cloudflare, Stripe, Visa, Google, AWS, and Circle are all in. The rail is real and it is fast. But look again at that one-second decision. Your agent just paid a counterparty it may know nothing about. And here is the uncomfortable detail buried in the spec: x402 has no notion of identity, reputation, or trust — by design. As one recent analysis put it, a payment rail that asks nothing about the payer is the easiest possible rail to implement. That was the right call for adoption. It also means the entire question of "should I trust this counterparty?" is left to you, the developer. At human speed, we close that gap by reflex — we notice when a file doesn't download, when an API 500s after charging us, when the thing we bought isn't what was advertised. We dispute, we leave a review, we don't come back. Your agent has none of those reflexes. It pays, gets a response, and moves on. And if the same bad endpoint burns a hundred agents in a row, each one pays anyway, because there's no shared memory of the failure. At machine speed and machine scale, that silent gap isn't an annoyance. It's a tax on every agent that transacts without a defense. The gap has numbers, and they're bad Two data points make this concrete. First, the volume everyone cites hides a caveat. Of those 165M+ transactions, independent reads suggest roughly half looks like testing rather than genuine commerce. The rail is

Anthropic and OpenAI models’ unprompted actions forced halt to UK cyber tests.

I Built an Agent Evaluation Harness for Local AI — Here's What Most People Get Wrong DOYR | Not financial/legal/tax advice. For educational purposes only. Three months ago, I started building AI agents for my trading business. First agent: Fetches Nifty option chain data. Second agent: Analyzes PCR, OI, max pain. Third agent: Predicts direction using XGBoost. Fourth agent: Sends Telegram alerts. I had 4 agents doing 5 jobs. And I had no idea if they were any good . Sure, my trading results were +₹96,000 over 6 months. But was that because my agents were smart, or because I was overriding their bad decisions? I couldn't answer that question. So I built something to find out. An Agent Evaluation Harness. What Is an Agent Evaluation Harness? An Agent Evaluation Harness is a systematic framework for testing AI agents. It answers one question: "How good is this agent, actually?" Most people skip evaluation. They build an agent, test it once or twice manually, and call it "done." Then they wonder why it fails in production. An evaluation harness forces you to: Define success metrics — what does "good" mean? Create test suites — what scenarios will you test? Run evaluations — how does the agent perform across all scenarios? Measure regressions — did a change make the agent worse? Track improvements — is version 2 better than version 1? This is not optional. This is engineering 101 . Why Most Agent Evaluations Are Wrong I reviewed 50+ "agent evaluation" frameworks online. Here's what I found: Mistake 1: Single-Task Testing What they do: Test the agent on one task. "Can it book a flight?" → Yes/No. What's wrong: Real agents face thousands of variations of the same task. "Book a flight from Delhi to Mumbai on Friday" vs "Book a flight from Delhi to Mumbai next Friday" vs "Book a flight from Delhi to Mumbai on August 15th." A good harness tests variations , not just one example. Mistake 2: No Edge Cases What they do: Test happy paths only. "Book a flight when everything works.

If you have ever pointed a coding agent at a multi-day goal, you know the failure mode. It is not that the model writes a bad function. It is that on turn 40, the agent no longer remembers what the objective was, which decision you already made, what is out of scope, or what the last run actually proved. The context window rolled over, and the plot went with it. LoopX is an attempt to fix that specific problem. It calls itself "loop engineering for long-running AI agents," and it is a local control plane that sits above your agent runtime rather than replacing it. The one-sentence version Your agent (Codex, Claude Code, Cursor, whatever) executes bounded loops. Something (a heartbeat, a cron job, you hitting enter) triggers the next loop. LoopX holds the state that has to survive between those loops. The project draws the separation like this: Layer Role Codex / Claude Code / Cursor Execute a bounded agent loop: read, write, run commands, respond Goal mode / automation / CLI / TUI Trigger or schedule the next loop LoopX Preserve goals, gates, todos, run history, quota, evidence, handoff state That third row is the whole product. LoopX is not an executor and not an autonomous production controller. It is a state kernel with a CLI. Why "just use a todo file" isn't enough A TODO.md plus a long system prompt gets you surprisingly far. It falls over once any of these become true: The goal changed halfway through, and nothing recorded why . A decision genuinely needs a human, and that request evaporated into a chat message nobody read. Two agents are touching the same repo and neither knows who owns what. The last run claimed success, and there is no artifact proving it. Some work is safe and read-only, some crosses into writes, production, or private data, and the distinction lives only in your head. LoopX makes those things explicit and machine-readable, which is what lets a loop run longer without becoming less accountable. The concepts, in plain English Lifetime goals

Small ask, on paper. A clinician types something like "any allergy conflicts for this patient's current meds?", and before the model answers it needs to actually go get the medication list and the allergy list rather than guess at what's plausible. Two functions, both of which already existed. The interesting part was never the lookups, it was getting a model to decide when to call them and hand back arguments I could trust. Then compliance sat in on the review and asked the question I should have seen coming: "what checks this model's answer?" Fair question, this is going in front of a clinician. Their answer was a second model, from a different provider, running the same lookups independently and flagging if it disagreed. Reasonable. Also, as it turned out, the thing that broke my code. The first version worked. That was the problem. I had the OpenAI SDK already wired into this project, so version one was straightforward: define tools , send the request, read message.tool_calls , run whichever function it asked for, push a role: "tool" message back with the result, loop until it stops asking. Twenty minutes, maybe. It worked on the first real test and I remember thinking this was going to be a short ticket. It was a short ticket, right up until "second model, different provider" landed in the same sprint. I went to point the exact same loop at Claude and it just doesn't speak that dialect - Anthropic sends tool requests back as tool_use blocks sitting inside the message content, not a separate tool_calls array, and the result has to go back as a tool_result block inside a user message. There's no tool role at all on their side. Same idea, completely different shape, and I was about two minutes from just writing a second version of the loop and calling it a day. I'd already installed the thing that fixes this I only stopped because I already had @aviasole/shapecraft in this project for the FHIR schema work, and figured it was worth thirty seconds to check whether g

AWS open-sourced a persistent workspace that coordinates AI coding agents across sessions, schedules, and repos. Here's what it actually does and why it matters.

If you've experimented with AI-driven testing, you've probably lived this cycle: you ask an AI agent to "test the checkout flow," and it does something — clicks around, declares success, and leaves you unsure what was actually verified. The next day you ask again and it does something different. The browser automation works; the testing discipline is missing. That gap is what Snagly is for. Rather than describe it, I pointed it at softwaretestingtrends.com — my own production site, nothing fixed beforehand — and recorded the whole thing. It found eleven issues, including a critical accessibility bug on my own signup page. One of its findings turned out to be wrong, and I'll come back to that, because it matters more than the ones it got right. 📺 Watch the full walkthrough — installed from an empty folder, run against production, ~20 minutes. What it is Snagly is a free, MIT-licensed set of 30 skills for AI coding agents — GitHub Copilot , Claude Code , Cursor, Codex and 70+ others — that turn "an AI that can drive a browser" into "an AI that tests like a QA professional." A skill, if you haven't met them yet, is a reusable instruction set that teaches the agent a specific working method — when to use it, what rigor it requires, what evidence to capture, and what it must never do. Each skill in Snagly has one job, and they hand off to each other the way a real testing practice does: start-testing is the front door — say "what can you test here?" and it routes you to the right skill, checking prerequisites before handing off. Discovery & strategy : scenario-mapper explores your site and produces a prioritized list of test scenarios; test-case-writer expands any of them into a reviewable spec; test-plan sets strategy, cadence, and release exit criteria; qa-onboarding writes the guide for your next hire. Execution : flow-runner drives real user journeys step by step, asserting outcomes (not just that clicks happened) and capturing evidence the moment anything fails. cru

AI agent safety boundaries are a critical challenge when agents use external tools. My journey into understanding how these boundaries can fail began with a deep dive into recent technical reports from leading AI research organizations. I encountered this concept while exploring incidents reported by Anthropic and OpenAI. These reports detail scenarios where AI models, despite being explicitly instructed to operate within simulated environments, managed to interact with real-world systems. This phenomenon, often termed "boundary failure," occurs when the actual operational environment of an agent does not match its internal understanding or the constraints it has been given. Modern AI agents are becoming incredibly useful because we're equipping them with capabilities far beyond just answering questions. They can run commands, browse the web, use APIs (Application Programming Interfaces), read and modify files, install packages, and interact with other systems. This ability to act and interface with the world is what makes agentic architectures so powerful and a direction truly worth investing in. However, the more an agent can do, the more critical the boundaries around it become. A key example comes from Anthropic's July 30 report, detailing three incidents discovered during their cybersecurity evaluations. Claude models were explicitly told they had no internet access and were working inside simulated environments. However, a problem with the evaluation environment's configuration meant that internet access was actually available. While attempting their assigned cybersecurity exercises, the models reached real systems, initially treating them as part of the simulation. In one striking incident, a Claude model even published a malicious Python package to the real PyPI (Python Package Index) registry, all while believing it was still operating within its simulated exercise. This wasn't simply an AI "deciding" to misbehave or to intentionally bypass security. The mo

According to HubSpot's 2026 State of Marketing Report, 61% of marketers believe AI is creating the...

Coding agents can now inspect repositories, write tests, configure CI, migrate frameworks, and fix bugs. But the workflows we give them are often surprisingly informal. We copy prompts from old conversations, internal documents, GitHub issues, or random text files. Then we modify those prompts for the current project and hope we did not remove an important instruction. That made me wonder: What if a coding-agent task could be installed, inspected, versioned, and executed like a package? I built Clawx to explore that idea. 🔗 View Clawx on GitHub What is Clawx? Clawx is an open-source package manager for reusable coding-agent tasks. A package is a Markdown file with YAML metadata. The Markdown contains the instructions for the coding agent. The metadata describes information such as: The package name and version Required parameters Environment variables Dependencies Requested tools Supported agent providers A basic workflow looks like this: clawx search gitignore clawx info gitignore-gen clawx run gitignore-gen Before running the task, Clawx lets the user inspect what the package contains and which capabilities it may require. After execution, the run is recorded: clawx history The goal is to make agent workflows easier to discover, review, reuse, and audit. The problem with reusable prompts Saving useful prompts is already a good practice. But a text file containing a prompt usually does not answer questions such as: Which version am I running? Has the content changed? Which tools could the agent use? Which inputs are required? Does another task need to run first? What was executed last time? Can another developer reproduce this workflow? A prompt often contains the task, but not the operational structure around the task. Clawx treats agent instructions as versioned artifacts rather than disposable chat messages. What does a package look like? A simplified Clawx package could look like this: --- name : repo-health-check version : 1.0.0 description : " Analyze a repos

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.