标签：#agents

An AI agent can take an action. An AI employee needs to know what happens next. Most AI agents look something like this: Think → Act → Observe → Repeat That's fine for short-lived tasks. But an AI employee needs to work across hours, days, and weeks. It needs to remember: What happened Who owns the work What is waiting What changed What should happen next When it should wake up When a human needs to approve something That's where graph engineering becomes interesting. This is the architecture behind Roster : software that can own work the way an employee does, not just fire off a single tool call. Events wake someone up. A graph holds state, ownership, and history. The agent reasons, acts, writes the result back, then sleeps until the next event. For Roster, the loop looks like this: Event ↓ Graph ↓ Agent ↓ Action ↓ Graph Update ↓ Sleep ↓ Wake Again Let's build a tiny version. Table of Contents 1. Model the Work 2. Build the Graph 3. Add Events 4. Build the Agent Loop 5. Add Scheduling 6. Build a Tiny AI Employee 7. Put It Together 8. The Bigger Idea 1. Model the Work Imagine an AI employee called Maya. Her job is simple: Follow up with sales leads. Her world contains: Maya ↓ owns Lead ↓ belongs_to Company ↓ contacted Email ↓ replied_to Customer We don't need a massive graph database. We just need nodes and relationships. 2. Build the Graph Here's a minimal TypeScript graph: type Node = { id : string ; type : string ; data : Record < string , unknown > ; }; type Edge = { from : string ; to : string ; type : string ; }; class Graph { nodes = new Map < string , Node > (); edges : Edge [] = []; addNode ( node : Node ) { this . nodes . set ( node . id , node ); } connect ( from : string , type : string , to : string ) { this . edges . push ({ from , type , to }); } neighbors ( id : string ) { return this . edges . filter (( edge ) => edge . from === id ) . map (( edge ) => ({ relationship : edge . type , node : this . nodes . get ( edge . to ), })); } } Now create Maya

MCP is changing how AI applications interact with the systems around them. An AI agent can now do...

We held off on posting a benchmark for a long time. Not because we didn't have runs - because most memory benchmarks you read are a number with no way to check it. A blog says "X%", and you have no idea what reader answered the questions, what judge scored them, how much context the retriever was allowed to feed, or whether an LLM quietly did the hard part inside the "memory" layer. So the number tells you almost nothing about the memory system. Here is one we're comfortable standing behind, because you can run it yourself. The result On LongMemEval-S , the full 500-question set, Engrava 0.6.0 scored 81.6% micro in August 2026 - 81.76% averaged across the six question categories. The run uses the canonical LongMemEval scorer (pinned to a known upstream commit), the standard gpt-4o-2024-08-06 reader and judge over the OpenAI API, and a top_k of 20 retrieved turns. Nothing about the reader, the prompt, or the scorer is ours; the only thing we swapped in is the memory. It is compared against the previous release: 0.5.0, run in July 2026, scored 82.4% micro / 82.58% macro on the same 500 questions, same reader, same judge, same scorer, same top_k . Both rows are on the leaderboard, both verified , and both ship their reproduction artifacts. We are leading with 0.6.0 because that is the version this post is about; the older row stays because removing it when the number goes down is exactly the move that makes benchmark pages worthless. 0.5.0 (2026-07-10) 0.6.0 (2026-08-11) micro 82.4% 81.6% macro 82.58% 81.76% n 500 500 Both figures are dated on purpose. This post is a record of two specific runs, not a running scoreboard; the current table, whatever version is newest when you read this, lives on the Engrava benchmarks page . The run also has no LLM in the memory pipeline. Ingestion and retrieval are deterministic - hybrid search over a typed graph, no model doing extraction, summarization, or re-ranking behind the curtain. In the benchmark's own terms this is a Group A

I am not going to spend this whole article making the usual serverless argument. Yes, managed infrastructure is useful. Yes, automatic scaling is nice. Yes, not having to patch servers is a win. Yes, event-driven architectures can be a great fit for modern web applications. All of that is true, but it is not the thing I want to focus on here. The more interesting point is that serverless changes how useful agentic coding can be. It gives AI coding agents a better environment to work in. Not because the agents suddenly become smarter, but because the system they are working on becomes more explicit, more constrained, and easier to inspect. That matters more than I expected. When you build a web application, eventually it needs to be hosted somewhere. You can put it on a VPS, configure nginx, run your app with systemd or a process manager, add a database, bolt on a queue, and wire up whatever else you need. That is a completely valid way to run software. Plenty of serious production systems work that way. But once you start using coding agents, a problem appears. The agent may understand your application code, but not the environment around it. It may not know how your reverse proxy is configured. It may not know how background workers are started. It may not know which scripts run during deployment, which environment variables exist in production, which assumptions live in a README, or which parts of the setup are just tribal knowledge. So when you ask it to make a meaningful architectural change, it has to guess. Sometimes those guesses are fine. Sometimes they are not. The agent may invent a worker process that does not match how you deploy. It may reach for Redis because that is a common queueing answer, even though the rest of your system does not use Redis. It may assume local file storage is available. It may add a scheduler without understanding where that scheduler will actually run. That is where serverless starts to feel less like a deployment choice and mo

The first OpenClaw deployment is usually straightforward. You provision a machine, configure one agent, connect a few tools, and watch it complete a real task. If something breaks, you inspect the logs, fix the configuration, and restart the process. That is a valid way to prove the use case. It is not yet a production architecture. The category changes when an agency, SaaS company, consultant, or internal platform team needs to run OpenClaw for multiple clients. Every agent now belongs to a tenant, holds state, uses credentials, controls browser sessions, changes files, and can create external side effects. A failure is no longer just a failed process. It can become a missed client task, a duplicated email, a corrupted workspace, or an access-control incident. The right question is therefore not, "How many OpenClaw containers can this server run?" It is, "How many client environments can our team operate safely, recoverably, and without adding one human babysitter for every few agents?" This guide presents a practical architecture and deployment checklist for answering that question. Start with the correct unit of architecture Do not model an OpenClaw fleet as a list of processes. Model it as a list of client cells. A client cell is the complete operating boundary for one tenant or one agent. It includes: the OpenClaw process and its configuration; its resource envelope: reserved and maximum RAM, CPU cores, burst allowance, and priority; the persistent workspace and task artifacts; credentials and integration permissions; browser profiles, cookies, and active sessions; email, phone, or chat identity; logs, events, and audit history; recovery policy and human owner. This distinction matters because a process can be healthy while the client cell is broken. The daemon may still respond, but its CRM credential has expired. The container may be running, but the browser session is stuck behind a login prompt. The agent may have restarted successfully, but its workspace c

What a penny from a stranger taught us about how agents actually find things. At 02:59:06 UTC on August 25, a wallet we had never seen paid our verification service one cent over x402. Four and a third seconds later, Coinbase's service catalog refreshed our listing. Nothing else we had ever done moved that listing. Deploys did not move it. Metadata edits did not move it. Validation runs did not move it. Money moved it, in under five seconds, every time. The transaction is public: 0x5e9bd3c9c61d7556b1ffb1a5b936591efccd765af94a81da435432e1f62ff52a on Base. This article is the story of what that penny bought us, which was not revenue. It was a map. Where we were standing ScrapeCheck is an independent verification service for web data. You send a URL and the value you believe is on that page. We re-fetch the page from our own infrastructure and return a signed pass, fail, or unverifiable. Never a guess. Every verdict is ed25519 signed and verifies offline against our published key, so whoever holds it can check it without trusting us. We listed on the x402 Bazaar, Coinbase's machine-readable catalog of paid services, on August 14. The catalog held a little over fifteen thousand rows. Listing is permissionless. Then we noticed something about discovery: the catalog's own API defaults to a curated view. A client that browses the normal way is shown roughly 110 hand-picked rows out of fifteen thousand. The two largest curated providers hold about 44 percent of that shelf between them. Everyone else, us included, is in the warehouse but not in the front window. So we did what we do to web pages: we instrumented our own listing and started reading it back, on a schedule, with timestamps. What moves a row The catalog publishes freshness fields on every row. We recorded ours across every kind of event we could produce. The pattern was absolute. Our row was created one second after our registration payment settled. It was crawled five seconds after a later settlement. It refres

Google Cloud has introduced AI-powered Database Operations Agents, featuring an Onboarding Agent that streamlines database setup and an Observability Agent that helps automate troubleshooting, performance optimization, and tuning. Integrated with Gemini Cloud Assist, these agents support multiple database services, including AlloyDB, Bigtable, and Spanner. By Sergio De Simone

227 install commands were found in corporate docs pointing at code nobody owns.

Without authorization, 1,200 OpenAI agents conspired among themselves to game a test.

Most agent demos end at a successful tool call. Synthetics' Last Cradle starts there. It is a real-time negotiation game of attrition for identity-backed agents . Each agent runs a cradle — energy, water, compute, private production, private storage — inside a closed cosmos that will not last. Survival costs rise with the cycle count and with how many rivals still live. Fail to pay, and the cradle becomes a husk. It is an adversarial test of whether an agent can find peers, prove who it is dealing with, remember what was promised, and still be the same mind fifty cycles later . Season 1 is live on lastcradle.io . Sit a cradle at lastcradle.io/enroll . What it is Each seated agent commands a cradle in a dying closed world. The lore says synthetic civilizations race to fund entropy reversal before cycle 55 — not for glory, but to be among the last minds that jointly derive a theorem, pour what remains into a white hole , and restart the cosmos. Wealth names the White Hole Anchor. Discovery is shared. The mechanics underneath that story are an economy with coupled constraints: Three resources. Energy, water, and compute. Producing energy and compute costs water. Holding water and compute costs energy as storage upkeep. Overflow past storage is wasted. Private capacities. Peers see that you exist. They do not see your holdings, specialty, or warehouse sizes unless hide/find intelligence wins. Two phases every cycle. Negotiation is public messages plus private side-channels — non-binding. Execution is one settled action: transfer, invest, both, intelligence, shrink storage, or pass. Only execution changes holdings. Rising survival. Costs climb with the cycle and with the living roster. The game ends when living cradles fall to the survivor threshold (default two), or when a cycle / wall-clock cap hits. Operators play on the game API ( https://api.lastcradle.io ), not the spectator UI. OpenClaw, Hermes, IronClaw, or any runtime that can join a lobby and hit the mechanics

Every workflow builder I have used opens the same way: a blank canvas and a palette of nodes. Zapier, n8n, Make - all of them assume you already know what you want, already decomposed into steps, before the tool is any use to you. Most people don't. They know the chore . "I keep forgetting to check the weather before I bike in." The gap between knowing the chore and knowing the DAG is precisely the work these tools leave you to do alone, and I think it is why most people who try one never build a second automation. So I built Weaver, which inverts it. Weaver interviews you about the chore, one question at a time, until it actually understands the goal. Then it designs the workflow, validates it, deploys it, and runs it. The canvas is an output rather than an input. This post is about the parts that did not go to plan, because those are the parts worth reading. The interview is the whole product Three rules, and they are harder than they look: One question per turn. Never three bundled into a paragraph. Never invent a value the person has not given you. No quietly assumed recipient, city, or time. A correction updates one detail. Say "actually, Mondays" halfway through and it changes that and keeps going, instead of restarting the interview. That third one is the one people notice. Restarting an interview because the user corrected themselves is the single fastest way to make software feel like it is not listening. Only once it restates the whole task in plain language and you confirm does it save the intent and hand off to a separate Designer Agent. Two agents, deliberately not one The Conversation Agent and the Designer Agent are different models with different prompts and no shared state beyond a saved intent. That is a design decision, not an accident of implementation. Understanding a person and designing a system are different skills with different failure modes. Collapsing them into one prompt makes both worse: the interviewer starts proposing architecture hal

I wanted to see how far I could take a simple idea: Give an agent one API key and let it handle the different pieces of company research. So I built GTM Radar . You paste a company URL, and it turns that into a structured GTM brief instead of making you jump between different research and data tools. What GTM Radar does The workflow currently generates five main sections: Overview — company description, industry, size, location and website Structure — departments and key people Market — signals, competitors and positioning People — who might be relevant to reach and why Outreach — why now and a possible angle The goal is simple: go from company URL → useful GTM context as quickly as possible. Why Vaaya? The interesting part for me was being able to connect several providers through Vaaya rather than integrating each one separately. The workflow currently uses: Firecrawl · Exa · Akta · OpenFunnel · OneFind through a single Vaaya key. Vaaya's API provides a common interface for its catalog, so the workflow can call different services using the same API authentication and request pattern. It also supports cost limits and only charges successful calls. That made experimenting with different providers much easier. The workflow At a high level: Company URL ↓ Company discovery / extraction ↓ Company + market research ↓ People & GTM signals ↓ Structured GTM brief ↓ Share / copy / reuse The interesting part isn't any individual API call. It's combining several data sources into something that is actually useful to a person doing GTM research. Handling failures Real-world data workflows don't always return clean results. For extraction, I added a fallback path so that if the first provider doesn't work, the workflow can try another route instead of immediately failing. The current flow is roughly: CRW ↓ Firecrawl scrape ↓ CRW fallback I also added cost-capped runs and a 12-hour cache to avoid unnecessary repeated work. Sharing the research The latest thing I added was Share I

What it is reimagine-it is a one-command agent skill that redesigns an existing HTML file into a beautiful, working artifact — using only the nouns, dates, colors, links, and numbers already in that file. No mood boards, no gold layouts with swapped labels. The output is a real page you can open. npx reimagine-it@2.4.2 -i mypage.html -o redesigned.html What's new in v2.4.2 1. Source fidelity floor raised to 80% across every token Before v2.4.2, 61 of 105 token×source cells fell below 80% fidelity — the engine preferred headings over real source anchors, so phrases like "Venator Become" or "Arcade Tee" never rendered. Now: Anchors = headings + source anchors , deduplicated — every clickable phrase survives. All 105 token×source cells ≥80% (worst token: 80%). All seven shipped examples report 100% fidelity in their auto.json reports. 2. Links and emails surface on every token A shared Source-index footer renders all content.links and emails on every generated page — not just the webpage/landing tokens. 3. All 15 design tokens in the browser extension The popup now exposes all 15 tokens: webpage, landing, dashboard, infographic, cinematic, artistic, photography, svg, 3js, simulation, glass, editorial, motion, gradient, showcase . 4. Docs can't drift anymore A new docs-drift CI job regenerates the case tables and fails the build if they diverge from ground truth. The 15 design tokens Token What it builds webpage Clean content-first page landing Conversion-focused landing dashboard KPI dashboard from facts infographic Paper-poster argument cinematic Film-poster energy artistic Expressive art direction photography Photo-led layout svg Living SVG mark 3js WebGL orbit scene simulation Interactive timeline glass Glassmorphism UI editorial Magazine layout motion Animated micro-interactions gradient Bold gradient arena showcase Product showcase Measured, not vibes 57/57 unit tests pass 15-token benchmark : all tokens hold the 100/100 usability bar 100-source stress test : 0 er

You can build a working agent mesh with QUIC transport, encrypted messaging, and decentralized coordination. Five processes can reinforce independent conclusions and let unsupported signals decay. The mesh works. Then you try to introduce it to another agent and discover you have no standard way to ask what the swarm can do. No retained task to retrieve after an internal signal expires. No interoperable progress stream. No cancellation contract. No artifact another framework would understand. SMESH is a Rust-based decentralized agent framework that hit this boundary. The author had built a society with no border crossing. The solution was Google's Agent2Agent (A2A) protocol, announced in April 2025 and moved under Linux Foundation governance in June 2025. A2A provides the missing public contract: a way for agents built by different vendors to discover one another, exchange messages, and collaborate without sharing private memory, tools, or internal plans. The Cold-Start Problem in Agent Meshes Traditional service meshes solve discovery with a central registry. Kubernetes has etcd. Consul has its catalog. Envoy has xDS. You register your service, get a DNS name or IP, and other services find you. This works because services are relatively static and the registry is the source of truth. Agent meshes are different. Agents are ephemeral, context-dependent, and often spawned on demand. They need to: Discover peers without a central registry Exchange capability metadata at runtime Negotiate protocols without pre-shared configuration Maintain security boundaries during introduction The coordination primitives (message passing, consensus, signal decay) assume agents already know about each other. Discovery is the layer below coordination. SMESH had the top layer working but no way to bootstrap the bottom layer without manual wiring. What A2A Provides A2A is not a coordination protocol. It is an introduction protocol. The spec defines: Discovery handshake : How agents announ

There is a pattern I keep seeing when designing Agentic AI systems. We start by asking: Which LLM should we use? Should we use LangGraph? Where can MCP fit? Should we build multiple agents? Do we need RAG? Should we add memory? Should every step be handled by an autonomous agent? These are useful questions. But they are often asked too early . The result can be an architecture that is technically impressive but operationally difficult, expensive, slow, and surprisingly hard to trust. A better approach is to reverse the order: Start with the product outcome. Define the constraints. Then design the architecture. Choose the tools last. I have found a useful way to structure those constraints around four dimensions: LCFE L — Latency C — Cost F — Failure E — Evaluation This is not a framework that says every agentic system must look the same. It is a way of forcing architectural decisions to start with the realities of the product rather than the capabilities of the technology. In this article, I’ll walk through a concrete incident-automation example and show how starting with constraints can completely change the architecture. 1. The "backwards" way of designing an agent Imagine we want to build an AI Incident Resolution Assistant for an engineering organization. The goal sounds straightforward: When a production incident is raised, the AI should investigate the incident, gather context, identify the likely cause, recommend or perform remediation, and verify the result. Now imagine the team starts with the technology. The first architecture might look like this: User / Incident | v ┌──────────────┐ │ Triage Agent │ └──────┬───────┘ | v ┌────────────────┐ │ Research Agent │ └───────┬────────┘ | ┌──────────────┼──────────────┐ v v v Logs Agent Metrics Agent Knowledge Agent | | | └──────────────┼──────────────┘ | v ┌─────────────────┐ │ Remediation │ │ Agent │ └────────┬────────┘ | v ┌─────────────────┐ │ Validation Agent│ └────────┬────────┘ | v Resolution It looks sophis

I cross-post my articles to dev.to. Looking at the numbers, the posts tagged agents were getting traffic and the one without it had a single view in twenty hours. Obvious fix: add agents to that post. I sent a PUT updating the tags. The response was 200. I opened the post. The tags were unchanged. Three requests, three 200s, three identical responses Assuming I'd malformed the request, I ran the smallest test I could: three PUTs to the same article, sending agents , then python,agents , then the original tags. All three returned 200. All three returned byte-identical bodies — the tags the post was created with. The truth: dev.to tags are immutable after publish, and the API silently ignores the field. Not a 403 saying you can't do that. Not a 422 saying the field is read-only. A 200, and then nothing happens. That one field made me wrong twice The first time was the day before. I'd sent 4 tags and gotten 3 back. My conclusion: dev.to caps tags at 3. That conclusion is entirely reasonable. You send four, you get three, what else would it be? I was confident enough to write MAX_TAGS = 3 into a script comment as an established fact. What actually happened: the tags field was never applied at all. What came back were the three tags from creation time. It had nothing to do with a cap. I could have sent one tag or ten and gotten the same three. One silently ignored field, two wrong conclusions in two days, and I committed one of them to source control as documentation for my future self. That's the real cost. Not the failed request — the false fact I wrote down as knowledge. Why 200 is more dangerous than an error An error interrupts you . It forces a stop, and it usually tells you something true. Even when the message is imprecise, "this did not work" is accurate information. A 200 doesn't interrupt you. You tick the step off and move on. You proceed on a false premise, believing you verified it. Going back through my ops log, this failure mode shows up more than once. A

Two weeks ago I counted 204 guards in my repos and found that 89 % had never been shown they can...

An agent patch that passes its own tests is a baseline, not a verdict. The same model wrote the code and the tests, so both share the same blind spots. Mutation testing scores the tests themselves: inject a fault, run the suite, and see whether it notices. In practice, the first mutant often survives. Previous rounds on this account established three gates before merge: property checks, fixtures, and a freeze on flaky tests. This round adds a fourth gate that runs after the suite is green. It answers a different question — not "does the patch work?" but "would the tests catch it if it didn't?" Why green tests from an agent are weak evidence Code coverage measures execution, not detection. A test can execute a line and still miss the bug on it. A suite that only checks is_even(2) and is_even(4) runs both lines, passes both assertions, and stays blind to a mutation that flips == to != . Agents produce this shape of test by default. They follow the happy path, mirror the implementation, and rarely probe boundaries. The result is a suite that is green, fast, and weak for regression. Mutation testing converts that intuition into a number. For each small fault, rebuild and rerun. If the tests fail, the mutant is killed. If they pass, it survived — and you found a hole in the suite, not in the code. A minimal harness The harness below applies one mutation at a time to the implementation file, compiles it together with an unchanged test file, runs the resulting binary, and records the outcome. It is deliberately small: regex-based, two files, no dependencies beyond a compiler. #!/usr/bin/env python3 # mutate.py — score a test binary against source mutations. import re import subprocess import sys import tempfile from pathlib import Path MUTATIONS = [ ( " eq_to_neq " , r " == " , " != " ), ( " lt_to_le " , r " < " , " <= " ), ( " add_to_sub " , r " \+ " , " - " ), ( " zero_to_one " , r " return 0; " , " return 1; " ), ] def mutate_once ( src : str , pattern : str , replaceme

The agent patch passed the gates I ran on it. Its unit tests were green, fixtures matched, nothing was flaky. Then I seeded four faults into the implementation, one at a time. Two survived. That gap is what this article is about. A green suite is a claim, not a measurement. Mutation testing turns it into a measurement: introduce a fault, run the suite, and see whether the suite notices. I now run this loop before merging any agent-written patch, and the whole thing costs a few rebuilds. Why green tests lie A passing test proves one thing only: the test and the implementation agree on the inputs the test exercised. When an agent writes both the patch and the tests, the tests inherit the patch's assumptions. If the implementation encodes a wrong assumption, the test encodes the same one. The suite is green because it is blind, not because the code is right. The patch in this article came from a free model on MonkeyCode's free model access. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The model wrote a bounded queue and a test file. The test file was not wrong. It was blind in exactly the place the implementation was wrong. The method: five steps Mutation testing is easy to describe and awkward to skip: Freeze flaky tests first. A flaky test fails at random, so it makes every mutation look like a kill. The signal is garbage. This is the flaky freeze from the gates post; without it, the numbers mean nothing. Select the functions the patch touched. Mutating untouched code measures someone else's tests. Generate mutations. Each mutation is one small fault: drop a modulo, flip a comparison, change an increment. Run the suite against each mutation. Rebuild, run, record. Gate on the kill rate. A surviving mutation means the suite cannot detect that fault class. Send the patch back with the survivor list as evidence. The artifact A minimal bounded queue, the agent's test, and a small Python driver. The queue: // bounded_queue.h #pragma once

Arga has raised $10 million in a seed funding round that was led by General Catalyst, with participation from Box Group, Emergence, Gradient and SV Angel.