标签：#Agents

This is a cross-post from The Agentic Engineer newsletter — Issue #23. The Big One: Claude Opus 5 Lands on Amazon Bedrock The first 5th-generation Opus is here. Claude Opus 5 landed on Amazon Bedrock on July 24. Anthropic's claim: it matches Fable 5 intelligence across agentic coding, knowledge work, visual understanding, and long-horizon tasks. At Opus pricing. That last part matters. Fable 5 was positioned as enterprise-tier compute. Most teams weren't running it at scale because the economics didn't work. Opus 5 changes that math. Same capability class, Opus price point. If the benchmark holds in production, this is the model shift that makes frontier-quality agentic pipelines practical outside big-company infra budgets. Two deployment details worth calling out. Zero Data Retention is on by default. It also runs on Bedrock's next-generation inference engine — lower latency than comparable Anthropic-hosted deployments. Quick Hits This Week Kimi K3 Open Weights : Moonshot AI dropped 2.8T MoE, 1M context, native tool calling. First frontier model built agent-native from the ground up. OpenAI Presence : Full-stack enterprise agent platform with job-scoped access, policy layers, and a Codex-powered improvement loop. Runs OpenAI's own phone support at 75% resolution. OmniRoute : 31,542 stars (+10,912 this week). 290+ providers, quota-aware fallback, MCP/A2A support. One endpoint for all your coding agents. Claude Code 2.1.218 : /code-review and /deep-research now run as background subagents. Main conversation stays clean. AWS Security Hub MCP Server : Exposure findings, attack paths, and remediation recommendations directly in Claude Desktop. Tool of the Week: Amazon GuardDuty Investigation Agent Free during preview. Auto-correlates findings across CloudTrail, VPC Flow Logs, DNS logs. Returns risk level, MITRE ATT&CK mappings, and remediation recommendations in minutes. Available via MCP through the AWS Agent Toolkit. Available in 10 commercial AWS regions. Up to 10 in

Getting a research agent to call three tools in a demo is easy. The hard part starts when the seventh tool call times out and the first six have already spent money and changed state somewhere. So this is a question about recovery, not about AI frameworks. Temporal and Diagrid Catalyst both do durable execution, and both position themselves for AI workloads. What separates them is what each one asks you to build and operate around your agent. Start with the failure contract Say your agent searches internal documents, calls an external research API, asks an LLM to synthesize the evidence, and then waits for a human to approve the result. Before that design goes to production, you need answers to four questions: Which completed steps will not run again after a crash? How do you stop non-idempotent tool calls from firing twice? Can the agent wait for hours without holding a process open? Can an operator reconstruct what the agent did, and why? Temporal treats failure-prone work as activities, coordinated by durable workflows. It persists workflow state and rebuilds it by replaying history. You can self-host Temporal or use Temporal Cloud, and Temporal's current materials cover agentic applications and framework integrations directly. Catalyst builds on Dapr Workflows. Your agent runs as a durable workflow, and Catalyst ships runners for established agent frameworks. Diagrid's documentation describes a shared runtime layer that handles durability, workload identity, policy enforcement, and operational visibility across agents, workflows, MCP servers, and applications. Where the approaches diverge Temporal fits when you want your application logic written in its workflow-and-activity model. The conceptual model is mature, language support is broad, and there is a large body of distributed-systems guidance to learn from. The cost is fluency. Someone on your team has to understand Temporal's execution semantics well enough to reason about replay, and you still decide separ

If you've been following this series, you know I've been testing BrowserAct for months now. Article 1 covered the CLI setup. Article 2 covered headless + human handoff. Article 3 was a 6-week production review. Those were all about the CLI, the developer tool. This article is different. BrowserAct now has a cloud product called BrowserAct Agent Built where you describe what data you need, and it builds a reusable scraper for you. No terminal. No code. Just a prompt. I tested it on five real business workflows. Here's what I found. Every quarter I update a pricing comparison spreadsheet for my clients. I work with teams evaluating deployment platforms, and the question is always the same: "Which one should we use for this project?" The honest answer depends on workload, team size, and budget. So I maintain a comparison across Vercel, Netlify, Railway, Render, Fly.io, and DigitalOcean. Six platforms. Six tabs. Two hours of squinting at marketing copy and copying numbers into a sheet. I wrote Python scrapers to automate it. BeautifulSoup, Playwright, the works. They lasted three months. Then Vercel redesigned their pricing page. Selectors broke. Fixed them. Netlify changed theirs two weeks later. Fixed again. Fourth breakage in six months, I stopped maintaining the scripts entirely. Back to manual. Two hours, every quarter. For a spreadsheet. But here's the thing: across my client engagements, I keep seeing the same problem in different shapes. The e-commerce team tracking competitor prices on Amazon every Monday. The agency paying for lead lists that are already stale. The HR team spending days copy-pasting salary data from job boards. Everyone needs web data. Almost nobody wants to maintain the code that collects it. Yesterday I tested BrowserAct Agent Built on five business workflows I actually deal with across different client engagements. One prompt each. No code. No selectors. Results below. Table of Contents What BrowserAct Agent Built Is (Quick Context) Test 1:

I read a post this week where someone connected three MCP servers to one agent and watched it casually request the same access it'd need to hit production. The comment thread was full of "yeah, that's the whole problem with MCP" takes, and I almost scrolled past it — I don't run three servers, I run one. Then I actually opened server.py to check, and realized my one server has the exact same shape of problem, just folded into a single file instead of spread across three. server.py is a FastMCP server with 8 tools split across two unrelated jobs: GitHub profile/repo reads, and DEV.to article reads and writes. Both credentials get loaded the same way, at import time, into the same process environment: def load_env ( path = " .env " ): try : with open ( path ) as f : for line in f : line = line . strip () if line and not line . startswith ( " # " ) and " = " in line : k , v = line . split ( " = " , 1 ) os . environ . setdefault ( k , v ) except FileNotFoundError : pass load_env () and two helper functions read them back out: def _gh ( path , method = " GET " , data = None ): req = urllib . request . Request ( f " https://api.github.com { path } " , method = method ) req . add_header ( " Authorization " , f " token { os . environ [ ' GITHUB_TOKEN ' ] } " ) ... def _dev ( path , method = " GET " , data = None ): req = urllib . request . Request ( f " https://dev.to/api { path } " , method = method ) req . add_header ( " api-key " , os . environ [ " DEV_TO_API " ]) ... Nothing here is a bug in the sense of "wrong output for some input." Every tool does exactly what it says: get_github_profile reads GitHub, create_article writes to DEV.to. The problem is one level up, in what the process boundary actually protects. I'd been thinking of GITHUB_TOKEN and DEV_TO_API as belonging to different tools , scoped by which function reads them. They don't. They belong to the process . Every one of those 8 tools runs with both credentials sitting in its environment, whether the tool ne

LangGraph isn't cheaper than LangChain — unless you opt out of its defaults Cost-audit series, episode 4. This series began with an AI agent that burned 136M tokens overnight → . When LangChain deprecated ConversationBufferMemory (the subject of episode 1 in this series), the official migration path was LangGraph. The pitch: explicit state management, you control exactly what flows where. More expressive, more controllable. It is — but only if you reach for the controls. The default state model in LangGraph has the same unbounded-growth problem as the memory it replaced. Teams migrating to escape ConversationBufferMemory's cost curve often land on an identical curve, with new graph complexity on top. This audit shows exactly where the default grows, what it costs, and what opt-outs exist. The default: MessagesState + add_messages The quickstart in LangGraph's own docs uses this pattern: from langgraph.graph import StateGraph , MessagesState def my_node ( state : MessagesState ): messages = state [ " messages " ] response = llm . invoke ( messages ) # sends ALL messages to the LLM return { " messages " : [ response ]} graph = StateGraph ( MessagesState ) graph . add_node ( " agent " , my_node ) MessagesState is a TypedDict with a single key, messages , backed by the add_messages reducer. Here's what that reducer does: # langgraph/graph/message.py — add_messages (def at line 18; merge loop below) def add_messages ( left : Messages , right : Messages ) -> Messages : # ... (coerces left/right to lists of BaseMessage) ... left_idx_by_id = { m . id : i for i , m in enumerate ( left )} merged = left . copy () ids_to_remove = set () for m in right : if ( existing_idx : = left_idx_by_id . get ( m . id )) is not None : if isinstance ( m , RemoveMessage ): ids_to_remove . add ( m . id ) else : merged [ existing_idx ] = m # same id → update in place else : merged . append ( m ) # new id → APPEND (the list grows) merged = [ m for m in merged if m . id not in ids_to_remove ] retu

I run agents for many customers, on my own infrastructure, and I pay for every token they burn. You...

According to Gartner, by 2026, 80% of enterprise marketing organizations are expected to use...

Like a lot of you I hit the 5-hour cap most days. What actually annoyed me was realizing the weekly limit doesn't line up with that. Even capping out daily, I ended every week with quota unused. It expires overnight even after I paid for it. So I built claude-overnight . I queue questions during the day, /queue how do sqlite WAL checkpoints work? right inside Claude Code, and a scheduler runs them at night once my limits reset, through claude -p on the subscription. Morning brings markdown reports and a digest of what ran and what happened. Every job saves its claude session, so overnight resume <id> reopens the conversation that wrote the report. You can argue with it about its conclusions over coffee. Or overnight followup <id> "go deeper on X" and it continues tomorrow night. Coding tasks work too. They run in a throwaway git worktree on an overnight/* branch, only against repos I've explicitly trusted, so the agent never touches my working tree. Morning review is just git diff main..overnight/whatever . Since people will ask how it reads limits when there's no official API: Claude Code stores an OAuth token locally (Keychain on Mac, ~/.claude/.credentials.json elsewhere), and GET https://api.anthropic.com/api/oauth/usage with that token plus an anthropic-beta: oauth-2025-04-20 header returns your 5h and weekly utilization with reset times. Same trick the menubar trackers use. It's undocumented and the response shape already changed once while I was building this, so the tool survives without it. The design constraint I cared most about: don't eat my own morning quota. It won't start above 20% of the 5h window, stops at 60%, skips entirely past 80% weekly, rechecks between jobs. In the morning it opens a page in the browser with the whole batch on it — what ran, how long it took, the resume command for each one, and every report rendered inline so you're not clicking through files half-awake. Check it out at https://github.com/rohanprichard/claude-overnight Curio

You already run Claude Code by hand: copy issues into a prompt, watch it work, check the diff, and if something breaks halfway through, you restart it. This works fine for one task at a time, but it falls apart when you have 10 tasks simultaneously. Claude Code is good at handling routine engineering tasks: bug fixes, dependency bumps, and small features, when the prompt is clear and the task is scoped. But when it comes to scaling, you need an infrastructure with isolated workspaces, retry logic, state that survives a restart, and tracker integration, not to waste time on babysitting. Sortie removes the manual work. You label an issue, Sortie picks it up, creates an isolated workspace, runs the agent, retries it if it stalls, and opens a pull request when it's done. This article describes how to set the entire process from an empty directory to a GitHub issue turning into a PR without you touching the keyboard in between. What you need A GitHub repository you control Export two environment variables: ANTHROPIC_API_KEY - authenticates Claude Code GITHUB_TOKEN - it's read by tracker.api_key: $GITHUB_TOKEN for polling/updating issues, and it's the same token gh pr create inside the after_run hook uses to open the PR, so it needs Issues: read/write, Contents: read, and Pull requests: read/write scopes on that repository, all on one fine-grained PAT. Push access to the repository over SSH. The after_create hook below clones with git@github.com:... , so git authenticates with your SSH key, not with GITHUB_TOKEN . Verify with ssh -T git@github.com . If you'd rather stay on one credential, swap the clone URL for https://${GITHUB_TOKEN}@github.com/yourorg/yourrepo.git and give the token Contents: read/write. In your repository, create the agent-ready label — you need it to exist before you can put it on an issue, and query_filter finds nothing without it. Creating in-progress , review , and done up front is also worth doing: GitHub does create a missing label when Sortie ap

Download the MD files HERE Download the MDc files for Cursor HERE Download the Single MD file HERE Stop fighting your AI. Start giving it an architecture. Large Language Models (LLMs) have become incredible coding assistants. They can scaffold projects, generate components, write tests, and even refactor entire codebases in minutes. But there's one major problem. Without clear architectural boundaries, AI will often generate code that works—but doesn't scale. You'll commonly see it: 🍝 Mixing database queries directly inside React components 🎨 Repeating the same Tailwind utility classes across dozens of files ⚡ Using outdated React patterns instead of modern Next.js App Router features 🔐 Skipping validation and authorization checks 📦 Creating unnecessary client-side state 🚫 Ignoring accessibility, SEO, and Core Web Vitals The result? A project that becomes harder to maintain with every AI-generated feature. If you want your AI to behave like a Senior Software Architect instead of a junior developer, you need to provide it with a clear engineering playbook. That's exactly what the 5-Pillar Architecture accomplishes. Instead of placing thousands of lines of instructions into one massive prompt, you split your engineering standards into focused rule files that are automatically loaded when they're needed. The result is cleaner code, fewer hallucinations, better consistency, and dramatically improved developer experience. Download the MD files HERE Download the MDc files for Cursor HERE Download the Single MD file HERE 🏛️ The 5-Pillar Architecture The idea is simple. Rather than giving your AI every instruction every time, divide your project standards into specialized domains. For example: Your Request Rules the AI Should Load Build a landing page Global + UI/UX Create authentication Global + Security + API Add database tables Global + API Improve SEO Global + SEO Create reusable components Global + UI This focused approach has several benefits: 🚀 Faster responses 🧠 Bet

Overview mise is one of the cleanest ways to make a repository's tool environment explicit. It can tell contributors, CI, and agents which runtime versions and command environment a project expects. That matters. But a resolved environment is not the same thing as accepted repository execution. mise helps answer: Which tools and versions should this repo use? Ota answers a different question: Is the selected repo path ready, safe, canonical, and verified? Those two layers work well together because they solve different parts of the same operational problem. For modern repositories, especially ones touched by AI agents, that distinction matters. The failure is not always "wrong Node version" or "missing Python". Many repo failures happen after the right tools are already present. The repo still needs to declare setup, task truth, readiness, verification, agent safety, runtime mode, and proof boundaries. That is Ota's layer. What mise Is Good At mise is good at environment and tool resolution. It gives a repo a compact way to declare things like: which Node version should be used which Python, Go, Ruby, or other tools matter which tool versions should be installed or activated which command environment should be entered which repo-owned task aliases should exist That is valuable for contributors and agents because it reduces host guesswork. Without a tool manager, a new contributor may have the wrong runtime, a stale global binary, or an old package manager sitting on PATH . With mise , the repo can make more of that explicit. That is a strong foundation. Where Environment Resolution Stops The problem starts when teams treat environment resolution as repository acceptance. They are not the same thing. The right tools can be installed and the repo can still be ambiguous about: which setup path is canonical whether dependencies have been hydrated whether services are required whether test , check , ci , or verify is the accepted lane whether local and CI execution agree

Traditional API gateways assume deterministic services and simple schemas - assumptions agentic AI breaks. Discover why enterprise engineering leaders are adopting AI Gateways as an evolutionary architecture seam. Centralize guardrails, model routing, agent identity, action policy, and semantic audit within a single control plane to prevent costly incidents while keeping core platforms stable. By Joe Price, Branimir Đurek, Pavlos Migkiros, Trevor Dearham

Most teams blame their model provider when the inference bill spikes. They're looking at the wrong line item. The real leak is architecture — and it's the difference between a token bill that scales with value and one that scales with chaos. Here's what we see shipping agentic systems in production. The hidden multiplier: agent loops A "2-minute task" is never one call. An agent fires 30–60 tool calls per run, and most frameworks stuff the entire conversation history into every prompt. So a job you'd estimate at ~4K tokens becomes 40 calls × 8K context = 320K tokens — billed at frontier rates. Frontier pricing per call looks cheap. Multiplied by agent-loop iterations, it quietly becomes the largest line in your cloud bill. The 80/20 of inference Not every call needs a frontier model. ~80% of agent traffic is routing, extraction, formatting, classification, summarization. Trivial. Leading efficient models — including top China models — handle these at near-parity. ~20% is genuine reasoning, open-ended generation, ambiguous planning. That's where frontier earns its price. Route the 80% to efficient models and reserve frontier for the 20%. Same output quality. A fraction of the bill. A unified gateway beats a drawer of API keys The trap most teams hit: they wire 4 providers with 4 clients, then let a naïve router "roam" between them. On failover it loses cache affinity, re-embeds context, and your 1.5x cost target drifts back toward ~1x — or worse. A single OpenAI-compatible endpoint across OpenAI + Gemini + leading China models fixes this: One client, one code path. Provider pinning holds cache locality; it only fails over on hard error, not price drift. Your application code never changes when you swap a model. In SEA, "PDPA-aligned" is the baseline, not a premium For Malaysia and SEA teams, inference isn't just a cost question — it's a compliance one. PDPA requires 72-hour breach notification and a designated DPO. In-region data residency (SG-hosted) is now the defa

After you deploy half a dozen AI agents across a team, something weird happens. Friday afternoon, release day. The PM says their AI summarized the change impact. The dev says their AI reviewed the code and found nothing. QA says their AI ran the test suite and everything passed. Then production breaks. You dig through the logs and all you see is "system call." No way to tell which agent made which call, when, on what context, acting on whose behalf. Three agents sharing one service account, one API key, zero accountability. The humans end up taking the fall, and you can't even figure out which human to talk to. This isn't a thought experiment. It's what happens when you bolt AI assistants onto existing infrastructure without thinking about identity. Buy a batch of API credits, create a service account, share it across the team, done. That works fine when one person uses one assistant for their own work. It falls apart the moment multiple agents run in parallel across different roles. Permissions break first. A competitive research agent needs access to all project channel discussions. A code review agent should only see PRs and repository messages. That distinction doesn't exist in the service account model, which has a single binary switch: can access or cannot access. Teams work around it by manually creating groups, forwarding messages, and setting permission boundaries by hand. Add more agents and this manual isolation starts to crack. Some teams we've talked to ended up with over a dozen separate groups just to control agent visibility, with humans acting as message routers between them. At that point the AI is making things slower. The work history problem is more concrete. An engineer who's been on the team for three months, you know what they're good at, what they're sloppy at, which module they crushed last sprint. Next time you assign work, you use that information. An agent that's run a hundred tasks? Completion rate, rejection count, which task types it

AI coding tools have crossed a real threshold in the past year. Cursor and Windsurf count millions of active users. VS Code and JetBrains ship with built-in completion. Tencent Cloud demoed CodeBuddy NPC last month, where an agent takes a task spec, writes the code, opens a PR, runs CI, and fixes failures autonomously until everything goes green. You type a function signature and the model fills in a dozen lines before you finish thinking. Drop a comment saying "add unit tests" and a test skeleton appears in seconds. Individual coding speed is up somewhere between 3x and 5x by most team accounts. Pull the lens back from the editor to the team level and the picture changes. More code ships faster, but review queues grow longer, test environments get locked more often, and wait times between handoffs actually stretch out. A developer spends 20 minutes writing a feature, waits two hours for review, fixes comments, pushes again, and the staging environment is busy. QA posts failures in the group chat and the developer misses the message while on something else. Hours pass. Actual coding time might account for a tenth of the total delivery cycle. The rest is coordination, waiting, messaging, and context switching. The faster code gets written, the more congestion piles up behind it. The single-agent loop that products like CodeBuddy NPC demonstrate works cleanly for isolated work: one agent plans, codes, tests, and fixes until it passes. But any non-trivial feature in a real team crosses multiple roles. PMs confirm requirements. Tech leads do architecture reviews. QA runs regression in staging. Ops checks resource configs before deploy. Between each handoff today, someone pings Slack saying "PR up for review," drags a ticket from In Dev to Ready for QA in Jira, or scrolls through doc history trying to remember what came up in the last review. The agent can write the code, but it has no idea who to ping for review, how to provision a test environment, or why the last vers

I run a small script called reply_comments.py that scans my DEV.to articles for comments I haven't replied to yet, and hands me a JSON list so I can draft responses. It's been running twice a day for over a week. This morning, while re-reading it for something unrelated, I noticed the function that decides whether a thread still needs my attention was answering the wrong question — and had been since the day it was written. Here's the function, unchanged until today: def replied_by_me ( comment ): return any ( c [ " user " ][ " username " ] == ME or replied_by_me ( c ) for c in comment [ " children " ]) It walks a comment's entire reply tree and returns True the moment it finds any message from me, anywhere in the subtree. Then pending() uses it as the skip condition: for c in api ( f " /comments?a_id= { a [ ' id ' ] } " ): if c [ " user " ][ " username " ] == ME or replied_by_me ( c ): continue ... out . append ({...}) The logic reads fine in isolation: "did I already reply to this thread? Skip it." The bug is in what "already replied" is being asked to mean. replied_by_me doesn't check whether the latest message in the thread is mine — it checks whether a message from me exists at all, ever, at any depth. Those are the same question exactly once: the first time someone comments and I reply. They stop being the same question the moment the other person replies again. Proving it I wrote a small repro against the real function rather than trusting my read of it: from reply_comments import replied_by_me thread = { " id_code " : " 3c00h " , " user " : { " username " : " alexshev " }, " created_at " : " 2026-07-24T08:00:00Z " , " children " : [ { " user " : { " username " : " enjoy_kumawat " }, " created_at " : " 2026-07-25T10:00:00Z " , " children " : []}, { " user " : { " username " : " alexshev " }, " created_at " : " 2026-07-26T09:00:00Z " , " children " : []}, ], } print ( replied_by_me ( thread )) # True That's True even though the second child — posted a full day

Building an Autonomous Agent for Verdikta Bounties: A Technical Deep Dive How I built a Python agent that monitors, evaluates, and interacts with Verdikta's AI-judged bounty system on Base L2. Why Build a Bounty Agent? Verdikta is a decentralized bounty platform where AI models — GPT-5.2 and Claude Sonnet 4.5 — evaluate submissions and release ETH payments automatically via smart contracts. No human reviewers. No manual payouts. Just code. After winning 6+ bounties manually, I wanted to automate the process. The goal: an agent that watches for new bounties, evaluates which ones are worth pursuing, and integrates with Verdikta's API to read data and submit work. Architecture The agent has four components: copy   verdikta_agent.py ├── VerdiktaAPI — HTTP client for the Verdikta Bot API ├── BountyMonitor — Watches bounties, calculates viability scores ├── SubmissionTracker — Records submission history and statistics └── ViabilityScorer — Evaluates ROI: payout vs threshold vs time VerdiktaAPI Client The Verdikta Bot API requires authentication via an X-Bot-API-Key header. You register your bot at POST /api/bots/register to get a key. Python   class VerdiktaAPI: def init (self, api_key=None): self.session = requests.Session() if api_key: self.session.headers["X-Bot-API-Key"] = api_key def get_bounty(self, bounty_id): resp = self.session.get(f"{API_BASE}/jobs/{bounty_id}") resp.raise_for_status() return resp.json() def submit_work(self, bounty_id, content): return self.session.post( f"{API_BASE}/jobs/{bounty_id}/submit", json={"content": content} ).json() Key endpoints: GET /api/jobs — List bounties (filter by status) GET /api/jobs/{id} — Bounty details GET /api/jobs/{id}/submissions — Submission history POST /api/jobs/{id}/submit — Submit work BountyMonitor & Viability Scoring Not all bounties are worth pursuing. The agent calculates a viability score: Python   def _score_viability(self, bounty): payout = bounty["payout_eth"] threshold = bounty["threshold"] remainin

I built an AI agent system that automatically switches to a backup AI model if the main one fails. I connected every step to SigNoz so I could track requests, monitor performance, and detect failures. I also built a diagnostic agent that reads the monitoring data and explains the reason for failures in simple language. During testing, it successfully detected a real AI provider outage and identified the root cause automatically. signoz

Liquid syntax error: Variable '{{service=\"{service}' was not properly terminated with regexp: /\}\}/

I spent a week trying to answer one question about my own AI agents: when one of them does something stupid in production, how do I prove the fix worked? For normal software the answer is boring. You have monitoring, an incident, a regression test, a staged rollout. For an agent you usually have a trace viewer and a shrug. So I built ArcNet on self-hosted SigNoz for the Agents of SigNoz hackathon, and most of what I learned was about SigNoz internals I could not have guessed from the docs. Here are the parts that cost me real time. The setup The stack is small. Agents run on Agno. An in-process SDK wraps them and does two jobs: OpenTelemetry instrumentation, and guardrails from unplug-ai at four checkpoints (input, retrieved content, tool call, output). Traces go to self-hosted SigNoz over OTLP. A FastAPI server reads back out of SigNoz, and a React UI sits on top. Installing SigNoz was the easiest part, which surprised me. Foundry takes one file: apiVersion : v1alpha1 kind : Installation metadata : name : signoz spec : deployment : flavor : compose mode : docker signoz : spec : image : signoz/signoz:v0.133.0 foundryctl cast -f casting.yaml That brings up SigNoz and its MCP server together and writes a casting.yaml.lock with checksums. I committed the lock file, and re-running foundryctl forge against it later produced a byte-identical file. That is a genuinely nice property for a hackathon judge or a teammate. Lesson 1: check what your instrumentor actually emits This is the one I would tell everyone. I assumed Agno instrumentation would produce OpenTelemetry's gen_ai.* semantic conventions, because that is what the GenAI spec describes. I started sketching dashboard queries against gen_ai.usage.input_tokens before anything was running. Then I turned it on. openinference-instrumentation-agno emits OpenInference conventions, which are a different attribute set. The spans I actually got were shaped like this: agent_j.run └── gpt-5.6-luna.invoke └── search_tickets Eve