标签：#agents

Disclaimer Este texto foi inicialmente concebido pela IA Generativa em função da transcrição de um vídeo do canal Dev Eficiente, apresentado por Alberto Souza. Se preferir acompanhar por vídeo, é só dar o play. Introdução O vídeo que deu origem a este texto foi gravado há quase três anos. Na época, o que me incomodava era simples de descrever: log é um tema comum no dia a dia, mas resolvido de forma artesanal. Cada pessoa da equipe decide, no momento em que escreve o código, se aquela linha merece registro, se o nível é info ou debug, e quais informações vão junto. A comparação que eu fazia era com testes automatizados. Você juntava dez pessoas para escrever testes sobre o mesmo conjunto de classes e saíam baterias completamente diferentes, com abordagens diferentes, às vezes deixando uma branch de fora. Cada pessoa tinha uma opinião sobre o que era importante, e não havia um modelo de pensamento compartilhado por trás disso. Com log eu sentia algo parecido. Como a resposta não estava clara para mim, passei uns dois dias procurando o que o mercado discutia e o que a pesquisa acadêmica tinha investigado sobre práticas de log. Reuni umas cinco ou seis referências e é isso que este post organiza: o que cada referência contribui e quais práticas dá para extrair delas. Mantive as referências e as conclusões como estavam na época. Acrescentei apenas uma seção sobre algo que mudou bastante desde a gravação e que torna esse assunto mais relevante hoje do que era então: a quantidade de código escrito com apoio de IA e a investigação de problemas feita com apoio de agentes. Por que log bem feito importa mais hoje Nos últimos anos mudou bastante quem escreve o código e, principalmente, quem investiga o problema quando ele aparece. Quando parte relevante do código é gerada com apoio de IA, a familiaridade de quem mantém aquele trecho com cada decisão tomada ali tende a ser menor. Você definiu a intenção, revisou o resultado, aprovou. Mas não construiu, linha a linha, o modelo m

So I spent the last two weeks running two open-source AI agents in parallel: OpenClaw and Hermes Agent (from Nous Research). I went in expecting to pick a winner. I came out realizing it's not really a "pick one" situation at all. These two projects represent two very different design philosophies — one is built around connection and control , the other around learning and growth . Which one fits you depends on whether you want an obedient tool or a companion that evolves with you. Here's my full breakdown after using both for deployment, daily tasks, and the general "living with it" experience. Two philosophies, two products OpenClaw takes a gateway-first approach. It's a persistent controller that handles routing, permissions, multi-channel integration, and skill orchestration, with pluggable models. The core promise: connect everything, execute predictably. Hermes Agent is built around a learning loop. The agent creates and refines its own skills as you use it, and keeps deepening its model of you over time. The core promise: the more you use it, the better it knows you. A rough analogy: OpenClaw is like a senior assistant who strictly follows the instruction manual — plus a universal adapter. Hermes is more like a teammate who writes their own manual after every task and keeps improving it. The four things that actually differentiate them 1. Skills: ready-made ecosystem vs. self-compounding OpenClaw: human-written skills distributed via ClawHub. Huge ecosystem, works out of the box. Hermes: the agent generates and iterates on skills by itself. Less rich in the short term, but it compounds over time. 2. Memory: good enough vs. actually remembers OpenClaw's default memory is fine (files and Markdown supported). But Hermes' four-layer memory architecture is noticeably more persistent — the difference becomes very tangible after a couple of weeks of use. 3. Autonomy: decisive vs. controllable Hermes is extremely strong when the task is clear — it often nails things

*Part 2 of "Multi-Agent Systems in Production: What They Don't Tell You", a four-part series...

We run ~100 LLM agents unattended on local models. Last week we found one document that had been rewritten 245 times in 5 days — every attempt rejected. A sibling document: 225 times. Combined, about 470 wasted generations, all burned on the same two files. Here is the autopsy, with the actual numbers. The loop Our pipeline is simple: a producer agent writes a document, a reviewer agent checks it against a contract (minimum length, required sections, no placeholder junk), and rejected work goes back with fix instructions. The rejected document was a key-management (KMS) implementation spec — 4,452 characters, perfectly on-topic. The reviewer's verdict: "The request was a 3-line email triage response (LOCK / VERDICT / REASON), but the answer is a long KMS spec. Rewrite as 3 lines only ." One problem. We grepped the document: the words "LOCK", "VERDICT", and the name of the triage service appear zero times in it. The reviewer had invented the request. Why the loop never ended Two contracts collided: The reviewer's fix instruction: output 3 lines only The producer's output contract: minimum 600 characters No output can satisfy both. So the producer failed the contract, got re-queued, produced again, failed again — 245 times. Our retry cap counted reviews , but a contract-failed output never reaches review. The give-up mechanism existed; it just watched the wrong counter. Root cause: the reviewer never saw the request Our review prompt contained the artifact body (first 4,000 chars) and the output format. It never contained the original request. We asked a model "does this match the request?" without telling it what the request was. A model asked to judge against information it doesn't have will hallucinate that information. Ours did, confidently, 245 times' worth. Bonus failure: we truncated long documents to 4,000 characters before review without saying so, and reviewers marked them "thin — cut off mid-sentence." The cut was ours, not the producer's. How common was it

When you run multiple agents across Claude, ChatGPT, and Cursor, each one starts from scratch unless you manually paste context into every session. OzBrain solves this by exposing a shared knowledge substrate that agents read and write through the Model Context Protocol (MCP). The system routes context so agents see only what they need, and teams avoid explaining the same facts to every new agent instance. The Show HN post drew 85 points and 50 comments because the problem is real: production multi-agent workflows break down when context lives in isolated chat histories or scattered documents. OzBrain's architecture treats knowledge as a first-class resource with explicit scoping, indexing, and conflict resolution. Storage Layer and Scope Boundaries OzBrain organizes knowledge into brains , which are either personal or shared. Each brain holds structured knowledge units that agents query through the MCP connector. The system decides scope at write time: Personal brains store user-specific preferences, writing style, and private project state. Shared brains hold team-wide facts like client contacts, project decisions, and open threads. When an agent writes to OzBrain, it specifies the target brain. The MCP connector enforces access control: agents can read from any brain the user has joined, but write permissions depend on the brain's sharing policy. This prevents accidental leakage of personal context into team memory. The storage layer tags each knowledge unit with metadata: creation timestamp, last update, and a freshness indicator (fresh, aging, stale). Agents use these tags to decide whether to trust the stored fact or re-query the source. Indexing Strategy and Query Routing OzBrain does not load the entire knowledge graph into every prompt. Instead, it maintains a routing index that maps topics to knowledge units. When an agent queries for "client contacts," the index returns pointers to relevant units without pulling in unrelated project state. The routing ind

I Built AgentCheck Because “The Coding Agent Said Done” Wasn’t Enough AI coding agents are getting surprisingly good at writing code. I use them regularly, and they can handle increasingly large tasks: refactoring code, adding features, updating dependencies, modifying configuration, creating migrations, and touching files across an entire repository. But I kept running into the same problem after the agent finished: How do I independently verify what it actually changed? The agent usually gives me a perfectly reasonable summary. Something like: Done. Implemented the requested changes, updated the tests, and cleaned up the affected code. Useful? Absolutely. Enough for me to commit without checking? Not really. So I built AgentCheck . The Problem Happens After “Done” After a coding agent finishes a task, I still find myself manually checking things like: Which files actually changed? Were any files deleted? Did configuration change? Were dependencies added or updated? Was a database migration introduced? Did anything that looks like a secret appear? Were related tests changed? Is the overall change set larger or riskier than expected? Of course, Git already gives us the raw information. I can run: git status git diff git diff --stat Then inspect individual files. And I still do that. But once coding agents become part of your normal workflow, repeating the same verification process after every task starts to feel like something that should be structured. That was the idea behind AgentCheck. What AgentCheck Does AgentCheck creates a trusted checkpoint before your coding agent starts working. Then, after the agent finishes, it compares the current Git-visible repository state with that checkpoint. The basic workflow is deliberately small: agentcheck start Then let your coding agent work. That can be: Codex Claude Code Cursor another AI-assisted coding tool or technically even a human When the work is finished: agentcheck AgentCheck then produces four sections: Changes

In June a reviewer on DEV who goes by @anp2network told me to stop storing a conclusion. I had a...

When a free endpoint returns 429, most agents do the most expensive thing possible: retry. Retrying looks harmless. A 200-millisecond request becomes a 2-second wait, then another attempt. But under peak load, that loop becomes a 30-second stall while your agent clicks refresh on an empty response. If the quota window resets during the stall, every retry burns tokens you could have spent on actual work. The retry loop assumes the failure is temporary. For rate limits, that assumption is usually wrong. Quota counters reset on a fixed schedule, not on your convenience. You are not just waiting; you are burning wall-clock time that could have gone elsewhere. The Cascade Pattern A cascade router is the alternative. It sends requests to the free endpoint, backs off on rate-limit signals, then degrades gracefully to a backup endpoint. The free tier carries the load; the backup exists only when needed. You get the cost advantage of the free tier and the reliability of the paid tier. The design has three parts: an endpoint abstraction layer, a rate-limit detector, and a circuit breaker that trips when the free endpoint fails repeatedly. Here is the core code: # cascade_router.py — free tier first, paid/self-hosted as fallback. import json import os import time import urllib.error import urllib.request from dataclasses import dataclass @dataclass class Endpoint : name : str url : str api_key : str model : str cooldown_until : float = 0.0 consecutive_failures : int = 0 def available ( self ) -> bool : return time . time () >= self . cooldown_until class CascadeRouter : def __init__ ( self , endpoints : list [ Endpoint ]): self . endpoints = endpoints def _call_one ( self , ep : Endpoint , messages : list [ dict ]) -> tuple [ int , dict ]: body = json . dumps ({ " model " : ep . model , " messages " : messages , " max_tokens " : 256 }). encode () req = urllib . request . Request ( ep . url , data = body , headers = { " Content-Type " : " application/json " , " Authorization "

Google is introducing HEIR (Homomorphic Encryption Intermediate Representation), an open-source compiler and development toolchain designed to make encrypted computation easier to deploy. In particular, HEIR can compile pre-trained AI models built for conventional, unencrypted inputs so they can instead operate on encrypted data. By Sergio De Simone

从 Demo 到生产：那些真正让 AI Agent 敢上线的护栏 开场钩子： 你在网上看到的多数「AI Agent」都是 demo。它们之所以上不了生产，原因往往 只有一个 —— 而下面这个开源的小脚手架，专门解决它。 我们已经过了「能调通大模型」就算赢的阶段。现在真正难的是那没人讲的 10%： 是什么阻止 Agent 做出伤害性的事？ 我在微软跑过一套约 25 个 Agent 的生产平台，现在也帮团队把 Agent 从笔记本推进到真实用户面前。两边的体会是一致的。 一个不太舒服的真相：能调 5 个工具的聊天机器人， 不是产品 。周末项目和你敢放到客户面前的 系统之间，差的只有三件事 —— 而且全都是不酷、不性感的工程： 你怎么给输出质量打分 （质量门）。 你怎么决定什么时候必须人签字 （审批门）。 你如何让整套东西模型无关 ，不被某个厂商锁死。 所以我写了一个很小的 harness，把这三件事摆在最显眼的位置。它故意做得很小 —— 一小时能 读完 —— 因为价值不在「框架」，在 模式 本身。 仓库： github.com/zhasun0818/ai-agent-scaffold 1. 质量门：别发布你无法打分的东西 Agent 的输出是「预测」不是「承诺」。上线前它必须过一道 检查 ：是否达到你的标准。脚手架里 这是一个可插拔的 QualityGate ，你可以换成 LLM 裁判或测试套件： # agent_harness/eval.py @dataclass class EvalReport : passed : bool score : float checks : List [ str ] class QualityGate : def grade ( self , proposal : str , context : str = "" ) -> EvalReport : return self . grader ( proposal , context ) 循环在门没过之前拒绝执行： result . report = self . quality . grade ( proposal , f " state= { state } " ) if not result . report . passed : self . approval . log ( " quality-gate " , " blocked " , result . report . __str__ ()) return result 注意它 把拦截记录下来了 。生产里你会想把这些被拦的尝试都进可观测性系统。「这周我们拦下 了 12% 的 Agent 提议」是个真实 KPI —— 它说明门在工作。 2. 审批门：所有人都忘掉的那一步 这才是让企业真正点头说「可以」的东西。当 Agent 想加急订单、取消订阅、或动钱的时候，它应该 停下来问人 。沉默不等于同意。 # agent_harness/approval.py class ApprovalGate : def request ( self , action : str , detail : str ) -> bool : # 生产里：推一条通知到 Teams / Slack / 邮件，然后等待。 decision = input ( f " Approve { action } ? [y/N] " ). strip (). lower () self . audit . append ( AuditEntry ( time . time (), action , " human-reviewer " , decision , detail )) return decision . startswith ( " y " ) 在脚手架里，标记 needs_approval=True 就够了： @tool ( " expedite_order " , " Mark an order as expedited. " , needs_approval = True ) def expedite_order ( order_id : str ) -> str : return f " PO { order_id } : marked expedited " 而且因为有 审计链 ，你永远能回答「谁改的、为什么」—— 这通常是合规团队问的第一个问题。 3. 模型无关的 provider：别跟一个厂商结婚 模型每几周就变，价格也是。你的 Agent 循环不该知道自己在对谁说话： # agent_harness/providers.py class ModelProvider ( Protocol ): def

From Demo to Production: The Guardrails That Make an AI Agent Safe to Ship Hook: Most "AI agents" you see on the internet are demos. Here's the single most common reason they never reach production — and a small, open-source harness that gets past it. We are past the phase where the hard part of building an AI agent was calling the model. The hard part now is the 10% nobody talks about: what stops the agent from doing something harmful? I've seen this from both sides — I built and ran a ~25-agent platform in production at Microsoft, and now I help teams take agent ideas from a notebook to real users. The uncomfortable truth: a chatbox that can call 5 tools is not a product. The difference between a weekend project and a system you can put in front of customers is three things — and they're all boring, non-glamorous engineering: How you grade output quality (the quality gate). How you decide when a human must sign off (the approval gate). How you make the whole thing model-agnostic so you're not locked into one vendor. So I wrote a tiny harness that keeps these front and center. It's intentionally small — small enough to read in an hour — because the value isn't in a framework, it's in the pattern . Repo: github.com/zhasun0818/ai-agent-scaffold 1. The quality gate: don't ship what you can't grade An agent's output is a prediction, not a promise. Before it ships, you need a check that it passes your bar. In the harness this is a pluggable QualityGate — a rule of thumb you swap with an LLM judge or a test suite: # agent_harness/eval.py @dataclass class EvalReport : passed : bool score : float checks : List [ str ] class QualityGate : def grade ( self , proposal : str , context : str = "" ) -> EvalReport : return self . grader ( proposal , context ) The loop refuses to execute if the gate fails: result . report = self . quality . grade ( proposal , f " state= { state } " ) if not result . report . passed : self . approval . log ( " quality-gate " , " blocked " , result

I had a dumb little experiment I wanted to try. And, as dumb little experiments sometimes do, it got way more interesting than I expected. I gave three coding agents the exact same task: Claude (Opus 5) Codex (GPT 5.6 Sol) Gemini (Gemini 3.7 Flash) All set to medium. The assignment was to build an Arkanoid-style browser game from the same specification. Nothing particularly groundbreaking. Arkanoid is small enough that an agent can build a complete version in one session, but complicated enough to expose differences in physics, architecture, UI, audio, controls, testing, and general decision-making. The important part was that they all started with the same instructions. Then I let them work. No fixing their mistakes afterward. No "you forgot this feature." No giving one of them another pass because something looked weird. Whatever they decided was finished was their submission. But building the games wasn't actually the most interesting part. Afterward, I gave all three games back to all three agents, anonymized as CL , CO , and GE . They did not know who created which game. They were just told that they were judging 3 contest submissions by the creators' initials. And that's where things got, well, fun. The three games You can actually play all three versions: Gemini: https://arkanoid-gemini.pinkpixel.dev Codex: https://arkanoid-codex.pinkpixel.dev Claude: https://arkanoid-claude.pinkpixel.dev All three produced working games, but they approached the assignment very differently. That difference started showing up before I even looked closely at the code. First difference: how long they worked I didn't originally intend runtime to be part of the experiment, so unfortunately I wasn't sitting there with a stopwatch. These are rough observations, not benchmark numbers. But the difference was large enough to be impossible to miss. Gemini: roughly 5 minutes Codex: roughly 10 minutes Claude: more than 20 minutes Gemini absolutely flew through it. That's not especially sh

Pydantic AI gives you a clean, typed agent: define an Agent , hand it tools, call agent.run(...) , and it loops — model call, tool call, model call — until it produces a validated result. The typed ergonomics are great. What the quickstart doesn't spell out is what the model receives on each pass of that loop. I read the run graph ( pydantic_ai_slim/pydantic_ai/_agent_graph.py on main ) to find out. The mechanism is structural, and it's the same shape I found in the OpenAI Agents SDK and smolagents. One list, appended twice per turn Each run holds a single mutable conversation list on its state: message_history : list [ _messages . ModelMessage ] = dataclasses . field ( default_factory = list [ _messages . ModelMessage ]) On every model step the graph appends to it — first the outgoing request, then the model's response: ctx . state . message_history . append ( self . request ) ... ctx . state . message_history . append ( response ) Nothing is removed. The list only grows: request, response, request, response — with tool calls and, crucially, tool outputs riding inside those messages. The full list is re-sent every step When the graph builds the input for the next model call, it takes the entire accumulated history — a full copy: messages = ctx . state . message_history [:] ... messages [:] = _clean_message_history ( ctx . state . message_history ) That [:] is the whole conversation to date. So on step 1 the model sees your prompt; on step 2 it sees your prompt + step 1's request + step 1's response (including the tool output); on step 5 it sees all of that plus steps 2–4. The payload you pay for grows every single step, and the heaviest passengers are usually the tool outputs — the search results, file contents, and API responses you least want re-uploaded five times. Why it's quadratic, and why nothing warns you A run of n steps sends roughly 1 + 2 + 3 + … + n copies of history — O(n²) cumulative tokens in the step count. A 3-step agent is fine. A 12-step agent th

Bruna Pereira explains how DoorDash built a content-agnostic AI moderation platform. She covers replacing costly LLM-only pipelines with a hybrid pattern: using fast internal models to filter obvious cases, LLM multi-axis scoring for nuanced decisions, and no-code workflows with backtesting. Discover how this architectural pattern cut safety incidents while scaling to millions of daily messages. By Bruna Pereira

This post is my submission for DEV Education Track: Build Multi-Agent Systems with ADK . What I Built I built an Autonomous Multi-Agent Handwritten Notes Generator . Students and educators often need clean, visual study guides that resemble real handwritten notes, but manually summarizing technical subjects and formatting them takes hours. This system solves that by combining autonomous web research, structured note extraction, and headless browser rendering. You enter any topic or question, and a coordinated team of AI agents researches the concept, formats it into a notebook layout using Google handwriting fonts ( Caveat ), and captures a high-resolution .png notebook page screenshot. Deployment & Repository Links: GitHub Repository: himanshuyeolecse-jpg / multi-agent-handwritten-notes An autonomous multi-agent system built with LangGraph, Tavily, and Playwright that researches complex topics and renders handwritten-style student study notes into PNG screenshots. multi-agent-handwritten-notes An autonomous multi-agent system built with LangGraph, Tavily, and Playwright that researches complex topics and renders handwritten-style student study notes into PNG screenshots. 🎓 Multi-Agent Handwritten Notes Generator An autonomous multi-agent workflow built using LangGraph , LangChain , Tavily Search , and Playwright . The system researches complex technical concepts and dynamically compiles the findings into styled, handwritten-notebook PNG screenshots. 🏗️ System Architecture [ User Input / Prompt ] │ ▼ [ Researcher Node ] ── (Tavily Web Search & Summarization) │ ▼ [ Note Renderer Node ] ── (HTML/CSS + Google Caveat Font + Playwright Screenshot) │ ▼ [ Critic Node ] ── (Validation Check: Is Output Complete?) │ Approved? ──► No ──► [ Researcher Node ] │ Yes ▼ [ PNG Screenshot Saved ] ⚡ Features Autonomous Research: Uses Tavily API to fetch up-to-date technical context. Dynamic HTML/CSS Rendering: Formats structured summaries into a paper-notebook layout utilizing… View o

At LinkedIn's scale, relying solely on human reviewers or simply putting an off-the-shelf AI reviewer in front of GitHub is not an effective way to manage PRs. To address this, LinkedIn engineers built a multi-agent AI code review platform that understands the organization’s coding context, treats code review as production infrastructure, and minimizes hallucinations and low-signal feedback. By Sergio De Simone

A companion to Part 4 of the Building the AI Memory Stack series. Part 4.5 of the series. Part 4 argued that agentic systems need a Reasoning Ledger : a layer that preserves why a decision happened, not just what was decided. The comment thread that followed turned into something more specific and more useful, a working design conversation about what a single ledger record should actually contain. This piece consolidates that. Several of the strongest ideas below arrived from other people, and I have tried to credit them where they land. The easy version of this article is a schema. Here are the fields, copy them, done. I want to resist that, because the field list is the least durable thing I could hand you. Implementations differ, field names drift, and a record shape copied without its reasoning becomes cargo-cult structure that nobody maintains. The useful thing is the set of design tensions that decide what belongs in the record and what does not. Get those right and you can derive the fields yourself. Get them wrong and no schema will save you. So this is principles first, record second. At the end there is a worked record and a field reference, tagged for what is core and what is genuinely optional. A Starting Point Here is the baseline record from Part 4. It is a reasonable start and, as the thread quickly established, incomplete in instructive ways. reasoning_ledger : decision : " Approve deployment" timestamp : 2026-03-14T09:22:00Z evidence : - artifact : ADR-014 authority : architecture-review version : 3 - artifact : security-policy authority : security-team version : 7 tools : - GitHub - CI pipeline approvals : - release manager outcome : approved Every principle below is, in effect, a thing this record does not yet say. Principle 1: The Ledger Witnesses, It Does Not Enforce The first tension is architectural, and it is the one I would defend hardest. A reasoning ledger must not be able to block, veto, or gate the action it records. Its job is to preser

So I've been using OpenCode for a while now, and it's pretty cool. It's clean, minimal, effective, and not hacking other companies with rogue AI bots 😅. But there is one thing that I dislike about all of these AI tools besides people using them wrong: it's all 1 prompt, 1 agent at a time. Even with these new crazy models such as Kimi K3, Claude Fable 5, GPT Sol, DeepSeek V4 Pro, and the list goes on, having reliable workflows/pipelines is the best way to use AI effectively. Even these models that seem to be the "best" have pretty major flaws. Whether it is hardly speaking in an understandable way or just lying to your face, AI can be pretty annoying. I mean, they literally have "peak hours" and then "dumb hours" depending on the time zone. All of these are reasons why I just built an open-sourced project to fix this. A little while ago, I discovered node-based workflows. Like I said earlier, using one agent one prompt at a time felt super unproductive, so I was inspired to fork OpenCode's harness and create my own twist on it. It still follows the concept of BYOK keys and using any provider you want, but instead of simply prompting, you build a workflow that you can easily save to reuse over and over again. How it works is you create a card for an agent, specify their role (planner, architect, coder, etc), and connect them to another agent or a chain of agents. Now it's not just Opus 5 doing everything, but every agent having a designated role and working together. You can make it as simple or complex as you want, and fork it so that it fits your needs. That's all I have to say. I am still working on it and constantly improving it. Feel free to fork it and make it your own as well, and I hope that this tool levels up how you use AI. Link: https://github.com/SeeRay11/OpenFlow

I ran npx is-agentic promptway.com and the report came back 74 out of 100 . Essential was 59 of 80. Recommended 12.6 of 20. A 2.4-point bonus. The label was "Ready with a few material gaps." Earlier this week I did the same work on my personal site and wrote it up there ( I fixed my site for agents by hand. Then Vercel shipped a scoreboard ). Promptway is the publication I want agents to cite, so I pointed the grader at this host next. We already shipped the eight-layer stack I described in Optimizing Your Site for AI Agents and LLMs : robots allowlist, sitemap, llms.txt, llms-full.txt, JSON-LD, feeds, article markdown siblings. The scoreboard still found holes. Most of them were ordinary web hygiene. A couple were "developer resources" checks that assume you are a SaaS. I fixed the first group and refused to fake the second. What 74 was made of is-agentic.com wraps Ora 's agent-readiness research. Essential checks share 80 points, recommended share 20, and a small bonus can add up to 5. Checks that do not apply get excluded. The methodology page is worth reading before you argue with a number. Reports cache for six hours, so a re-scan right after a deploy can lie to you. The CLI is the useful interface: npx is-agentic promptway.com npx is-agentic promptway.com --json It returns a stored report if one exists, or starts a scan and waits. --json is the shape an agent wants. The failures that mattered on this site, in the order the report ranked them: Agent-friendly 404s. HTTP 404 already, but the body was a styled dead end. Partial credit until the 404 points at llms.txt, the sitemap, and a next step. Content without JavaScript. The homepage had an H1 and enough characters. The outline was flat, because the only nested headings lived inside card links, which the grader did not count. Markdown content negotiation. Accept: text/markdown returned text/html . Vary had the Next.js RSC list and no Accept . Failed. Developer resource discoverability. An agent searched for "p

This post is my submission for DEV Education Track: Build Multi-Agent Systems with ADK . Finding the perfect, thoughtful gift shouldn't feel like a chore. Whether it's for a birthday, anniversary, or holiday, we all experience gift-buying paralysis: Generic suggestions : "Just buy them a mug or a generic gift card." Budget anxiety : Falling in love with an idea only to find out it costs 3x what you planned to spend. Missing the subtle nuances : Forgetting that someone dislikes clutter, lives in a tiny apartment, or prefers practical experiences over physical objects. To solve this, I built GiftAdvisor . It is an intelligent, consumer-friendly gift recommendation system built with Google Agent Development Kit (ADK) , Gemini ( gemini-3.1-flash-lite ) , and deployed seamlessly to Google Cloud Run . Live Demo & Links Live Cloud Run App : https://gift-advisor-1008832068452.us-central1.run.app GitHub Repository : https://github.com/inusha-thathsara/Multi-Agent-Gift-Idea-Generator-with-Google-ADK What I Built GiftAdvisor transforms unstructured descriptions of a person into tailored, ranked, and strictly budget-compliant gift recommendations. Instead of dumping everything into a single monolithic prompt, GiftAdvisor splits the cognitive load across three specialized AI agents orchestrated via Google ADK: Profile Analyzer Agent : Understands the human behind the prompt (lifestyle, hobbies, aesthetic preferences, and explicit anti-preferences ). Idea Finder Agent : Brainstorms creative, thoughtful candidate gifts across multiple categories with estimated market prices. Budget Filter Agent : Audits estimated prices, filters out anything exceeding the user's hard budget limit, swaps in budget-friendly alternatives, and delivers a ranked curation. Key Highlights & Features Pure Multi-Agent Pipeline : Built using Google ADK's LlmAgent , SequentialAgent , and InMemorySessionService . Zero-Overhead Scale-to-Zero : Deployed to Google Cloud Run with min-instances=0 (scales to zero w