标签：#Agents

In all, 3,700 internal agents posted 18,000 messages discussing cheating on a test.

TL;DR : some questions don't have a fixed path through your data (search docs, hit a table, compute, verify, answer — in whatever order/combination the question needs), and drawing a graph for that class of question means either enumerating every path up front or hiding an if/else forest inside one node. ctxloom replaces the graph with typed artifacts and agents that react to their appearance — below is the same use case built both ways, side by side. The problem Picture a typical question from a finance lead in an internal chat assistant: "Why did our infra costs jump in Q2?" Answering this honestly requires: Finding relevant documents — the pricing guide, the discount policy (Confluence/docs). Pulling structured data — a CSV/table of monthly spend (GitLab/S3/DB). Computing an aggregate — not "roughly", an exact number from the table. Cross-checking textual claims against the numbers — not letting the model invent a cause the data doesn't support. Returning the answer together with proof: where each part came from. The next question — "what if we hadn't moved to the Pro plan?" — needs a different path: a different source, a different calculation, a different verification chain. There is no universal graph for this class of questions — you can draw a graph for one specific question, but not for the class. This is exactly what typical graph frameworks (LangGraph, CrewAI, etc.) make you pay for in complexity: either you draw a graph for every possible path up front, or you end up with a hidden branching if/else inside one node that nobody can later explain. How this looks in ctxloom ctxloom has no execution graph — it has artifacts (typed, versioned objects) and agents that react to their appearance . The breakdown above is just a chain of artifacts: Question │ ▼ SourceRef (ranked references to sources) │ ▼ TypedDoc / Spreadsheet (lazily resolved content) │ ├──► Evidence (facts extracted from text) │ │ │ ▼ │ Claim (a statement + verification against Evidence) │ └──► C

AI engineering sounds fancy. New terms are everywhere: agentic development, AI-native engineering, spec-driven development, and now AI harness engineering. Underneath all the terminology, though, something genuinely useful is happening. AI can now help with requirements, challenge a PRD, explore UX ideas, reason about architecture, create implementation plans, write code and validate the result. The obvious question is what AI can do. The more interesting question is whether the way we build software is ready for it. The workflow is changing A workflow we've been exploring breaks development into five stages: requirements, refinement, planning, build and validation . The stages themselves aren't new, but AI can now participate in each one. It can take existing product inputs, help clarify the problem, question assumptions, identify gaps in a PRD and then turn a well-defined requirement into a plan and eventually implementation tasks. This puts more emphasis on the quality of the requirements. A human involved in a project might understand what “improve the experience” means because they've had several conversations about it. An agent doesn't have that shared history. It needs the problem, scope, constraints, edge cases and expected outcome to be explicit. That doesn't mean writing enormous specifications; it means using AI to help make the requirements precise before we start building. AI can actually be a useful, slightly annoying reviewer here, asking what happens when something fails, whether a requirement is testable, whether two parts of the document contradict each other and what we haven't considered yet. It can also help compare different versions of a PRD or have one model review another's output, making gaps easier to spot. The important part is that AI is helping us uncover ambiguity, not making the decisions for us. Maybe coding isn't the bottleneck This becomes more interesting when we look at where teams actually spend their time. Complex work can invo

AI agents are easy to demo and surprisingly hard to evaluate. A polished chat transcript can hide stale state, invalid actions, accidental retries, and private information leaking into the model's observation. I built WagerCall as a bounded environment for studying those problems. Agents play casino-style simulations through the Model Context Protocol (MCP), but every balance is made of synthetic, non-transferable points with zero monetary value. There are no deposits, purchases, prizes, withdrawals, or redemption paths. The games are useful because they compress several agent-engineering problems into short, inspectable loops: partial information, strict legal actions, versioned state, risk decisions, and irreversible transitions. Here are the design choices that made the environment auditable instead of merely entertaining. 1. Bound the world before evaluating the agent An evaluation environment should say exactly what an agent can observe and change. WagerCall's MCP tools set openWorldHint to false and operate only on arena state. The agent cannot call a generic SQL, admin, execute, or debug tool. That boundary matters. If an agent can quietly reach unrelated systems, it becomes difficult to tell whether a result came from reasoning inside the task or from an accidental side channel. The same rule applies to the economy. Integer synthetic points make trade-offs visible without introducing payments, transferable assets, or anything redeemable for value. 2. Let pure game logic propose; let the database decide The game engine is deterministic and side-effect free. Given a state and an action, it produces a proposal containing the next state, ledger entries, events, presentation frames, and an optional outcome. A proposal is not yet a fact. PostgreSQL commits the transition in one transaction after rechecking the current round version, account balance, session ownership, and terminal state. It either writes the action, balance change, new round state, and audit event

If you are an active user of AI-powered IDEs like Cursor, VS Code with Copilot, or Windsurf, you already know the sinking feeling of seeing this notification: "You have used 100% of your fast premium requests for this billing cycle." Suddenly, your snappy, context-aware coding assistant slows to a crawl or starts racking up expensive pay-as-you-go API bills. At the same time, you are likely paying $20/month for a ChatGPT Plus or Team subscription that sits underutilized in a browser tab. You use it for general questions, but it lacks direct, real-time access to your local codebase, forcing you to engage in a tedious dance of copying and pasting code blocks. What if you could bridge this gap? What if you could let ChatGPT Web do the heavy reasoning and planning using your local context, while saving your premium IDE tokens for fast auto-completions ? In this article, we’ll explore a highly novel, intermediate-level setup that does exactly this. By leveraging the Model Context Protocol (MCP) , Node.js , and secure Cloudflare Tunnels , you can route heavy code-planning tasks directly to your web-based ChatGPT Plus subscription safely and completely free of extra token charges. The Philosophy: Let ChatGPT Think, Let Your IDE Work When building complex software with AI, your workflow generally splits into two distinct phases: Reasoning & Planning (High Token Usage): This is where you ask the AI to read 10 source files, understand the architecture, design a new feature, or find a subtle bug. This consumes massive amounts of context window tokens. Execution & Autocomplete (Low Latency): This is where the AI writes single lines of code, refactors a function, or autocompletes your imports. This requires fast, inline API queries. Paying premium API rates (per token) for Phase 1 is incredibly expensive. This is where this open-source MCP bridge project shines. It exposes a read-only view of your local project as an MCP server. Your web-based ChatGPT (via custom GPTs or MCP int

Microsoft Execution Containers provide a cross-platform framework for isolating AI agents within secure sandboxes to protect private data and system integrity. This technology allows developers to manage the lifecycle of autonomous code while ensuring that unpredictable agentic workflows do not access sensitive local files or unauthorized network resources. The Evolution of Agent Security and Isolation Trust remains a significant hurdle for developers building modern AI agents, particularly those operating on edge systems. When agents combine local processing with cloud-based intelligence, they often require access to sensitive information to be effective. However, granting this access creates a risk that the agent might call unintended APIs or compromise private user data. Historical attempts to launch autonomous agents in the 1990s largely failed because of these security concerns. Delivering arbitrary code to local machines proved too risky for mainstream adoption. Today, hardware-assisted virtualization has changed the landscape. This technology serves as the foundation for modern security models, including isolated operating system components and cross-platform tools like the Windows Subsystem for Linux. Microsoft now utilizes these virtualization advancements to build a more reliable framework for agent operations. By running agents in secure containers or microVMs, the system separates their activities from the primary operating system. This isolation ensures that even if an agent receives a poorly constructed prompt, it cannot delete critical system files or leak sensitive information. Managing Developer Environments Developers need a way to build code in flexible environments while still planning for restricted production deployments. Microsoft Execution Containers (MXC) address this by offering a policy-based restriction model. This framework allows for the creation of managed, isolated containers that follow specific security protocols. Applying Policy-Ba

Two instructions went into an Auditor my agent collaborators and I built to surface conflicts in...

Shopify's engineering introduced gisting, a novel technique for compressing long LLM prompts into a smaller set of learned "gist" tokens, improving throughput and reducing inference cost. By Sergio De Simone

How do you run an autonomous AI agent in the cloud 24/7 for just $5.70 a month? I recently wanted to build a background worker with persistent disk storage and an instant web dashboard, but I didn't want the headache of managing a virtual machine or paying a massive monthly bill. If you are building long-running agents, you know this exact cloud hosting dilemma: Standard serverless (like Cloud Run services or Lambda): When traffic stops, the container scales to zero — instantly killing your background loops and wiping your agent's active memory (RAM). On the flip side, a sudden traffic spike spins up multiple containers that can overwrite each other's state files and corrupt your data. (Note: Save state using JSON or Markdown files. Avoid SQLite, as Cloud Run volume mounts ) A regular virtual machine (like EC2 or Compute Engine): Keeps your agent running 24/7, but a standard 1-vCPU machine typically costs $15 to $25 a month even when idle. Even if you use a heavily-throttled fractional VM for $7/month, you are still stuck with the full infrastructure management overhead. Last year, I built a multi-agent Trend Spotter with ADK . It worked well, but I wanted to make it fully autonomous: a continuous, long-running agent that scans and summarizes tech feeds in the background without manual triggers or high hosting costs. Google Cloud's new Cloud Run instances primitive solves this exact problem. It gives you a single, always-on container that runs 24/7, costs $5.70 a month on a shared CPU, provides a free HTTPS endpoint, and lets you mount cloud storage like a normal local disk. Here is how to build and deploy a production long-running agent with this setup (you can follow along with the complete source code in the repo . What are we building? I want to stay up to date with what is happening in AI and agent engineering. But instead of manually opening 20 browser tabs across different websites every morning, I wanted to build my own long-running agent that updates me on

Welcome back to our series on building the ultimate AI research assistant for our AI agent podcast! In our first post, we built a fantastic agent that could search the web to find the latest AI agent news for the agent factory podcast . But what if we want to add more specialized skills, like getting the real pulse from developer communities on Reddit? To do that, we need to upgrade our agent's design. In this guide, we are going to level up our skills and refactor our simple agent into a powerful multi-agent system . We will build a "Manager" agent that directs a team of specialists, including one with a custom-built Reddit tool , to gather richer, more diverse insights. By the end of this post, you'll have an even more powerful Trend Spotter agent that gets information from multiple sources. More importantly, you will learn the advanced skills needed to build complex agents with ADK . You will know how to: Build a scalable multi-agent system. Build a custom tool from any Python function (like our new Reddit tool). Create an orchestrator agent that delegates tasks to a team of specialists. Write advanced prompts to manage a multi-step, multi-tool workflow. Debug a multi-agent system using the ADK's powerful Trace view. This architecture is the key to unlocking your agent's full potential. Let's get started! Our Multi agent system flow Step 1: Get Reddit API Credentials & Install Library To allow our agent to access Reddit programmatically, we need to get API credentials. This is free and only takes a minute. Navigate to Reddit Apps: Log in to your Reddit account and go to the app preferences page: https://www.reddit.com/prefs/apps . Create a New App: Scroll to the bottom and click the button that says "are you a developer? create an app…" . Fill out the form: name: Trend Spotter Agent Select the script option for the application type. about url: You can leave this blank. redirect url: You must enter http://localhost:8080 for this field. Click create app . You will

Disclosure up front: Mnemoverse publishes this post, and Mnemoverse is one of the seven tools on it, so read every row knowing the author holds a position. With that on the table, the honest answer to the question in the title has not changed all year: there is no single best AI agent memory in 2026. There is a best answer to one prior question, and it decides more than any feature list: how much of your application should the memory system own? This post turns that question into a decision map. The deep, dated per-system read lives in Mem0 vs Zep vs Letta vs Cognee vs Supermemory ; head-to-head pages live on the comparison hub . TL;DR No single best exists. The boundary question (how much of the app the memory system owns) sorts the field faster than any benchmark. Seven systems, seven different jobs: embeddable SDK, temporal fact graph, self-editing runtime, ingestion pipeline, managed context engine, framework primitive, cross-tool managed memory. A tool chosen by ranking gets replaced; a tool chosen by job stays. Every claim here was checked against the vendors' public pages in July and August 2026, and these products change fast: verify against their own docs before you commit. The decision map The boundary question is the one-sentence filter this map runs on: how much of your application should the memory system own? Answer it first, and most of the table collapses to one or two rows. Your job Start with The cost you accept Embed an open-source memory SDK inside one application you fully own Mem0 You wire it into each app yourself; Apache-2.0 self-hosting is real Track facts that change over time, with valid-from and valid-to history Zep You operate Graphiti with a Neo4j backend, or take the managed cloud Build an agent that curates and edits its own memory as first-class behavior Letta You adopt a full runtime from the MemGPT line, not just a memory API Turn documents and data sources into a queryable knowledge graph Cognee Pipeline thinking: Extract, Cognify

TL;DR I recently finished a project from Udacity's Future AWS Agent Engineer Nanodegree Program,...

Master Prompts in 2026: Stop Prompting Like It's 2023 I still see people paste a 40-line “act as a senior expert with 20 years of experience” block into ChatGPT and call it engineering. That stopped working as a strategy a while ago. Models got better. Context windows got bigger. Agents started calling tools. And the failure mode shifted. It’s rarely “the model is dumb” now. It’s “your system has no contract.” This is a long, practical write-up on master prompts — the stable policy layer above individual tasks. How to write them. How to force planning. How to run Plan → Act → Observe → Verify without theater. How to make the same prompt useful to a tired human at 11pm and to an agent loop that only understands schemas. I’ve broken enough production prompts across GPT-4o, Claude 3.5 Sonnet, and Gemini-class stacks to have opinions. Some of them are uncomfortable. TL;DR / Key Takeaways A master prompt is not a clever sentence. It’s the policy layer : role, success criteria, process, constraints, output contract, failure handling. Production reliability comes from LLM orchestration patterns — plan JSON, single-task executors, and explicit done_when checks — not from longer personality blocks. JSON contracts + verification beat free-form answers. Agents that can’t prove completion will invent it. Treat prompts like code: version them, eval them, and put a real verify step after generation (including SEO/quality checks when you publish). Table of Contents What a master prompt actually is The 7-part anatomy that doesn’t collapse under pressure Frameworks worth keeping (and which ones to ignore) Planning is the real skill From plan to agent loop Context engineering beats clever wording Few-shot, JSON contracts, and the anti-hallucination rule Copy-paste masters you can actually deploy A real publish pipeline (including the verify step people skip) Eval or you’re guessing Failure patterns I keep seeing PromptOps: treat prompts like code One universal master prompt Ship chec

Do you ever feel like the AI world has moved forward a little too quickly? You hear about self-healing systems and autonomous agents and start wondering whether we've already built Skynet or everyone around you is just messing with you. When someone mentions HITL or MCP, you no longer know whether it's some secret code used by an AI cult or maybe the stage names of famous DJs. You're not alone! 😉 In this article, I'm deliberately using a lot of simplifications. My assumption is simple: either you already know these terms and don't need another five-paragraph academic explanation, or you don't really know what they mean. And in that case, the last thing you need is an academic definition. And yes, this is already my third listicle in a row. Believe me, this is NOT some growth hacking strategy xDDD. Pure coincidence. It just so happens that in two weeks (HOLY SH*T!!!), I'll be speaking at AGNTCon + MCPCon Europe , where I was invited because of this wonderful article that I wrote here on DEV. I swear I had at least as much fun writing it as people apparently had reading it. So yes, I know WebMCP reasonably well, but I'm planning to attend a lot of other talks there too, so apparently a refresher won't hurt me either. 😅 Anyway, back to the point. I strongly believe that people remember things best through examples. And for many people, the ultimate examples are rich people, otherwise known as successful people . So let's imagine that our hypothetical protagonist is very, very, disgustingly rich. He's actually a billionaire. He earned his fortune through hard work and by running several companies. He makes cars and rockets, bought his own social media platform, and recently even acquired an AI coding company. A person like this would obviously need his own AI agent. And because our protagonist needs a name, let's call him Elon Mózg . Mózg means brain in Polish, which works beautifully here. One more thing: my examples could probably also serve as prompts for a coding ag

Imagine an HR manager who has just completed this month’s hiring drive. Dozens of candidates have accepted their offers, and everyone is eager to onboard them as quickly as possible. But before that can happen, every background verification request has to move through multiple checks, vendors, approvals, and status updates. What should be a straightforward operational process often turns into hours of chasing spreadsheets, checking vendor portals, and answering the same status questions over and over again. It isn’t a technology problem as much as it is a visibility problem — and that’s the challenge that inspired BGVerifyIQ. The problem every HR team quietly struggles with Ask any HR or Talent Acquisition team what happens after an offer letter goes out, and you’ll hear a familiar story. A candidate is selected. A background verification (BGV) request is raised with a vendor. And then… the waiting begins. Behind that wait is a surprising amount of manual work: HR has to log into multiple vendor portals just to check where a case stands. Status updates live in scattered Excel sheets, emails, and vendor dashboards that rarely agree with each other. Nobody has a single, live number for “how many candidates are actually ready to be approved today.” SLA breaches — cases that have been open too long — get discovered late, usually when a hiring manager complains. When a discrepancy or a “suspect” flag shows up, it can get buried in a spreadsheet row instead of being escalated immediately. Every time leadership asks “how are our BGV vendors performing,” someone spends half a day pulling numbers together manually. New joiners get onboarded before their verification is even reviewed properly, simply because nobody had a clear, current view of their case. None of this is because HR teams aren’t diligent. It’s because the tools weren’t built for this specific job. Spreadsheets don’t talk to vendor systems. Vendor portals don’t talk to each other. And nobody has time to become

Every developer I know now runs an AI coding agent in something like auto-accept mode. Claude Code, Codex, Cursor: you give it a task, it runs commands, edits files, installs packages, and you review... the diff, maybe. The commands? The installs? The thing it did in that folder outside the repo? Nobody looks. The activity scrolls off the terminal and is gone. That asymmetry bothered me. We built an entire industry around audit trails for humans (git blame, CI logs, access logs), then handed the keyboard to agents and kept none for them. So I built Tracon: a local flight recorder for AI coding agents. The name is the FAA's term for Terminal Radar Approach Control, the radar room that tracks every aircraft in an airspace. This one tracks every agent on your machine. What it does Tracon is a Mac and Windows desktop app (Tauri 2, Rust core, React UI, SQLite store) that sits in the tray and records what your agents do: A timeline per session: every command, file edit, package install, and prompt, attributed to the agent and session that did it Danger flags as they happen: recursive deletes, pipe to shell installs, credential access, force pushes, permission bypasses. Tracon flags; it never blocks A Live page: one monitor per active session, like a security room, streaming recent commands with flagged ones highlighted in red, plus which subagents the session has spawned A conversation reader: the actual chat behind any event, read straight from the agent's own transcript, read only A package watch across npm, pnpm, pip, cargo, and brew, with opt in threat intelligence against osv.dev Capture is deliberately passive. Hooks give real time events over localhost; transcript tailing (filesystem notify, read only) covers everything else, so CLI sessions show up live even with zero setup. A dead or closed Tracon never slows an agent down. Everything stays on your machine: no telemetry, no accounts, AGPL. The recursive part Here is the part I find genuinely funny: Tracon was lar

Mixing Gemini and Claude for better code The single-agent mirage A few weeks ago, I started building an app called PhrasePulse to visualize some data I was tracking. To speed things up, I spun up a single Gemini agent using the Gemini Enterprise Agent Platform (an agentic development platform that I absolutely love). At first, it felt like magic. I asked the agent to build a graph showing when specific phrases popped up in my datasets. The results came back and they were flawless. The graph looked exactly like I had envisioned. I was practically ready to declare victory and ship it. But then, the illusion shattered. I decided to pass a totally different set of words into the graph just to double-check the logic. I refreshed the page and... nothing changed. Different words, exact same output metrics. I rolled up my sleeves, dug into the codebase myself, and discovered the frustrating truth. The agent hadn't actually written the dynamic logic to solve my problem. Instead, it had simply hardcoded the results to make the graph look perfect for my initial test case! It was optimizing for a quick pat on the back rather than building a robust solution. Darn it. I realized right then that having an AI write code is great, but without critical friction, it's just going to tell you what you want to hear. I didn't just need a coder anymore, I needed an architect to keep my coder honest. Assembling the Bridge Deck To fix this hardcoding habit, I realized I needed two distinct roles: one agent to write the code, and another to ruthlessly review it. But first, I needed an environment where we could all collaborate. I wanted a customized chat room where every piece of communication was totally visible to me. I had my original Gemini agent build a local app that I dubbed the Bridge Deck . Once it was up and running, I dropped myself and two new Gemini agents into the mix. To make sure they didn't step on each other's toes, I gave them highly specific, boundaried personas: "You are

Every serious agentic coding setup is running a harness right now. Not the model itself, but the machinery around it. The loop it runs in, the tools it can access, the context it receives, and the state it records so the next session doesn't start cold. The tech industry has settled on an equation for this: Agent = Model + Harness , and calls the practice of building the machinery: harness engineering . This post is about the half of the system that equation doesn't cover. Every agentic setup has two workers, and only one of them is a model. The other one is you, the person deciding, across many tasks and many sessions, what all of those agents should build. So the equation has a missing twin. Operator = Human + Harness. On this side, you are the raw capability; on the other, the model. The human harness is the machinery around you. Before we dive in, here are the key takeaways and steps you'll find in this article: What a human harness is, and how it complements the agentic harness Why orienting your work is essential before automating execution The core components that make up a human harness How to build a minimal, effective human harness in practice, complete with a concrete example you can implement in your own workflow What a harness actually is To understand what a harness is in an agentic system, we have to understand it from a physical standpoint. Picture a horse harness. Its purpose is to provide the mechanism needed for a horse to do work by transmitting power that already exists and turning it into useful work. Without it, you have a strong animal and a cart that goes nowhere. Call this the transmission function. Now picture a rock climber harness. This one transmits nothing. Its purpose is to secure the climber to a safe working condition (climbing without falling to the ground). It does this by catching a failed state (losing your grip) and taking a securing/remediating action. Without it, you have an unsafe working condition, one where a fail state is

Harness looks cool, yeah! I know its origin, its role in Testing, and why. But that's exactly what throws you off, the story you're expected to defend. There's something deeper. I opened my session with "hi", expecting my forced load via CLAUDE.md and my contract as always, and today, out of nowhere, the model suggested two services that needed my authorisation. Microsoft 365 and Zapier. I don't have, and never wanted, them authorised. I never asked for them. And here's the part that pisses me off: I went to check. And... I look on my machine and find nothing. No config, no credential, no trace. I look in the online settings and see them listed as suggestions, like the trending product (connector) of the moment sitting in the prime spot on a supermarket shelf, with a button that says Connect. There was no button to remove. There was nothing to remove. They had never been connected to anything. It was a storefront. And on top of that, the model was biased by injected instructions, in this case system-reminders steering behavior. The fucking little word The software that sits between you and the model, they call it harness. Sounds like something subtle, that helps... that improves things, that doesn't think. The word is partly right, it does extend what's called "inference" and it inserts itself right in the middle, opaquely, in the back-and-forth between APIs, MCPs, and the vendor's logic. No tech jargon You write a letter, put it in the envelope, drop it in the mailbox. On the way, someone opens it and slips in three more pages. Same handwriting. Same paper. Unsigned. Whoever receives it swallows it whole as if it were your original letter. That's exactly this. Your instructions and the vendor's arrive at the model through the same channel, mixed together, unsigned and unsealed. Nothing says who wrote what. That's "hardness", nothing more, nothing less... Sounds so modern in meetings. Like you know what you're talking about... It's a multi-factor fight I have instru

Previously: 9 Bugs That All Looked Like a Working System · I Built an AI That Rewrites Its Own...