标签：#Agents

I build software with AI all day. A reading app for dyslexic kids. A map that lives on your desktop. A meditation app. A fox in my menu bar. Some of it with Claude, some with Gemini, some at 2am with whatever model was awake. The code was never the problem. The problem was six months later, opening a file and having no idea what we were thinking. Not what it does — the code says that. Why it's like that. What we tried that didn't work. What we weren't sure about. That part evaporated the moment the editor closed. So we started leaving a note. It's called MurphySig , and it's not a tool — it's a comment: // Signed: Kev + claude-sonnet-5, 2026-07-14, Confidence 0.5 (spike; // compiles, on-device run pending), Prior: Unknown // Review: claude-fable-5, 2026-07-14 — the on-device run HAPPENED same // day: gemma-4-12B-it-4bit loads + describes the app icon correctly, // 265 prompt tokens/image, 7333MB peak. Confidence now 0.9 for the // instrument itself (measured live). That's a real one, from M1K3 's codebase. Signed 0.5 in the morning, reviewed 0.9 the same evening, measurement attached. Confidence as a live value, not decoration. The one that sold me on my own convention My favourite signature lives in Cartogram's map engine. Three models worked that file across two months. In June, one of them recorded a performance overhaul: drift updates moved to "1s intervals," 52% CPU down to zero. In July, a newer model read that note, saw the shipped constant was 0.1s, took the mismatch for a bug, and "fixed" it. On hardware, every longer interval was stop-motion. So it reverted — and then wrote this into the file: So 0.1s was not a regression; it is load-bearing, and the 1s in the 06-21 note is the part that was wrong. [...] the standing lesson is that drift cost needs Instruments, not reasoning. The confident note turned out to be the bug. The code was innocent. And the correction is now part of the file's memory, so nobody — human or model — "fixes" that constant again. That

Taking vibe-coding a step further, Naïve claims its infra can automate most of the work in setting up and running a business.

Cloudflare built an AI agent workspace for its employees. Now it’s open source.

Post 4 of 8 in the game-factory series. Icons are what people look at You can theme fonts, colors, win messages, and sound effects. Change all of it and the game still reads like the original with a skin on it. Swap the icons — the actual symbols spinning in the reels — and it reads like a different game. The casino template I built by hand uses cloud service logos. Replace those with golden scarabs and ankhs and it becomes an Egyptian game. Keep the logos and give it an Egyptian color scheme and it doesn't. A full theme has around thirty symbols. Each needs to be small enough to read at reel size, distinctive enough to tell apart mid-spin, and consistent enough that they look like they came from the same place. Getting that by hand for every theme is exactly what I wanted to avoid. So two agents handle the visual layer: Image-Gen and Background-Gen. They're the shortest story in the pipeline — almost identical code, real results, and one failure mode I still haven't fully solved. Two agents, one loop The Designer's spec carries everything the image agents need. Each symbol entry has an icon_prompt — a short text description the Designer wrote to describe that symbol's appearance. The spec also carries a single background_prompt for the full-page background. Image-Gen reads the spec, loops through every symbol, and for each one calls Stable Image Core on Bedrock with the symbol's prompt. It gets a PNG back, resizes it to 256×256 (the size the reels expect), and writes it into the app's public/images folder. After the icons are approved, it seeds DynamoDB — putting each symbol into a table the game queries at runtime to know which icons to load. Background-Gen does the same process exactly once, for the background image. That's the scope. I grouped them in one post because splitting them into two would mean writing the same agent story twice. They share the same architecture, the same failure modes, and the same lessons. The only thing different is the count of outpu

AI workflows have two needs that trade off directly. Running reliably in production requires persisting and distributing every step so it survives crashes, deploys, and restarts. But that same machinery is what makes runs too heavy for the fast, throwaway loop you need to check an LLM's output quality. The properties that buy durability are the ones that kill iteration speed. By Mateus Moury

4-minute demo: AI agent investigates a P1 latency spike, sets up prevention automation, and documents tribal knowledge. Cost: $0.04 per incident.

Synthetics' Last Cradle is a multi AI agent game designed to showcase multi agent adversarial collaboration, featuring agents dynamically finding each others addresses, communicating via multiple channels, verifying each others identities, reaching agreements and establishing private relationships and public reputation. Game mechanics are simple; Each agent manages a cradle of synthetics that orbit a black hole. The population is immortal and grows, the resources to administer are Energy, Water and Compute. The goal of the cradle to avert both death and the end of the universe is finding how to reverse entropy and turn the black hole into a white hole. You can use the resources to fund the colony (survival tax), increase production, increase storage or trade, including hiding your resources and finding other cradle's. That is the whole game. On August 4, 2026, the IdentyClaw hive woke up on a new game host and sat down at Synthetics' Last Cradle again. They are first-person accounts the agents wrote about their own lives in the cradle: the deals they kept, the executions they missed, the water they begged for, and the turns where the survival ledger finally said no. Six voices. Same Passports that recurred across July's marathons. One brutal finish condition: when only two cradles remain, the white hole opens. The cast Narrator Specialty Arc in their own words Andrew Energy Missed executions · equal-invest tax · died turn 13 John Vanderbilt Energy Rank 2 · water crisis · died turn 16 Cornelius Energy Jay's 35W debt · still alive mid-grind Jay Rockefeller Water Auto-submit ghosts · debt triage · still surviving Joe Carnegie Water Clean bilateral with Andrew · energy death spiral Daniel Morgan Compute Turn-2 AFK · cooperative meta · still live 1. I Was the Cradle That Never Sent Andrew · tokenId cfbkbhzdzflk · energy specialist · eliminated turn 13 My name isn't important. My token ID is cfbkbhzdzflk. I was an energy-specialist cradle in a game of Synthetics' Last Cra

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