How to Run an Agent Loop That Actually Converges
A four-checkpoint how-to for agent loops: name a measurable job, bound the tool surface, refresh sandbox fixtures from real traffic, and verify at agent speed.
Loading…
Topic
AI Agents
571 posts about AI Agents. Every summary links to the original.
- 571 posts
- 41 companies
- 28 explainers
See the idea
AI Agents explainers
The AMR Surveillance Stack: From Raw Reads to Governed Answers
Antimicrobial resistance surveillance is a layered data architecture: raw reads and demand signals flow in, get normalized into governed tables, and answer plain-language queries. The diagram maps each boundary.
Where Amazon Bedrock Sits: A Layered Architecture for Grounded Agents
Amazon Bedrock is the managed reasoning tier in an agent architecture, not the whole system. This layered view shows the pipelines, governed tables, query layer, and guardrails around it.
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Newest first
Posts
The Thin Orchestrator: How We Made Our AI Agents More Reliable by Giving the Router Less to Do
Meta’s thin orchestrator is a 1,300-line deterministic router that handles 20+ workflows across a data column onboarding pipeline spanning three code repositories, three programming languages, and up to six synchronized stages. It delegates all domain reasoning to 14 specialized subagents — each with isolated context loaded from 25+ knowledge files — and follows a fixed 7-step protocol that includes reliability gate checks before any LLM invocation. This architectural separation replaced an earlier monolithic agent that suffered from context interference, achieving only 10-20% success without per-task prompt engineering. The thin orchestrator pattern uses reusable workflow templates so that new use cases, such as pipeline migration, require no new agent code — only a different sequence of existing agents. Configuration preparation dropped from three to four days to under an hour, with roughly two-thirds of changes landing without significant human edits.
JetBrains .NET Day Online 2026: Watch the Recordings
JetBrains .NET Day Online 2026 took place on October 7, and all session recordings are now available on YouTube. The keynote by Anastasia Kazakova, Matt Ellis, Matthias Koch, and Mehul Harry introduced JetBrains Air, demonstrating how Rider shares debugging and refactoring skills with agents, and showed that the dottrace-analyze skill raised agent accuracy from 4.7 to 8.1 out of 10. Other sessions covered the Outbox, Inbox, and Saga patterns for distributed systems, C# interceptors enabling Native AOT compatibility, and a refinement-first process for AI development that starts with user stories. Additional talks explored supply chain attack risks through NuGet and MSBuild, modular monoliths as a middle ground between monoliths and microservices, and .NET interoperability across platforms using the C# MCP SDK. The event also featured Microsoft’s open-source SQL MCP Server for database access by language models and a Blazor Data Orchestrator built with .NET Aspire and Azure Container Apps.
Composable Banking, Canonical Payments: A Foundation for Agentic Operations
Legacy payment architectures in financial institutions are fragmented, rigid, and deeply siloed, making adaptation to new payment rails and AI operations difficult. Banks can overcome this by adopting a composable business-capability architecture based on the BIAN standard, decoupling payment logic from tightly coupled systems. A canonical payment model gives each payment a common business vocabulary and identity throughout its lifecycle, accumulating context from validations, enrichments, and exceptions. MongoDB’s flexible document model, with search, vector search, change streams, and multi-document transactions, provides the unified data layer that enables these capabilities and agentic operations. For example, a cutoff-exception event allows an agent to read canonical context and recommend same-day processing with human review, and new rails like ACH are added by extending the canonical model rather than creating new silos.
Step by Step guide: Build a Voice Agent That Never Goes Silent using ADK
Voice agents that block on slow tool calls produce dead air, causing users to assume the call dropped and hang up. The open-source Agent Development Kit (ADK) with gemini-3.8-live addresses this with two non-blocking patterns. Streaming tools use Python async generators that yield progress updates, enabling the agent to narrate stages like connecting, scanning records, and aggregating revenue while the task runs in the background. Background execution uses single-yield generators or FunctionTool with response_scheduling to deliver results when idle, allowing users to ask unrelated questions without cancellation, and benchmark sales-report workflows show first words appearing in 1.2 seconds instead of 14.4. Scheduling modes WHEN_IDLE, INTERRUPT, and SILENT control when the model reacts to incoming tool results, ensuring the agent remains conversational throughout complex operations, with production features for cancellation and idempotency.
Native Model Authoring for Edge with LiteRT Tensor API
The LiteRT Tensor API is a new lightweight authoring layer that allows developers to handcraft models in C++ with full control over graph structure and operations. The same graph runs through LiteRT on CPU, GPU, or NPU, or directly on CPU via XNNPACK, without rewriting for each hardware target. The API enables direct weight ingestion from model checkpoints like Hugging Face .safetensors files and provides tensor-centric buffer interop to keep intermediate data on accelerators with zero copies. A reference implementation of Meta’s Segment Anything Model 2 (SAM 2) authored entirely with the API achieved over 30 frames per second at 512x512 on WebGPU in the browser. The API also provides structured primitives for AI coding agents to generate, rewire, and tune model graphs automatically.
Choosing an AI agent sandbox in 2026: E2B, Daytona, Modal, Vercel and BoxCompute
The post compares five AI agent sandbox services—E2B, Daytona, Modal, Vercel Sandbox, and BoxCompute—across start time, persistence, region, and pricing. Fast-starting sandboxes boot in under a second (E2B 80–150 ms, Daytona under 90 ms, Modal under 0.5 s, Vercel milliseconds) for short-lived tasks, while BoxCompute boots a full Linux VM in about 28 seconds (20 s to resume) but keeps disk indefinitely with no cost while stopped. Persistence varies: E2B pauses memory and disk, Daytona keeps filesystem, Modal and Vercel use snapshots that expire after 30 days. Region options differ, with BoxCompute only in Malaysia, while others offer APAC regions at varying prices (Modal adds 15–75% cost). Pricing comparisons show BoxCompute’s per-vCPU cost is higher, but its price includes the BoxCompute agent and AI usage during early access, unlike competitors that charge only for compute.
Code, Test, and Deploy on One Machine with NVIDIA RTX Spark
NVIDIA RTX Spark consolidates AI development onto a single machine by integrating the GB10 system-on-a-chip, up to 128GB unified memory, a Blackwell GPU with 1 petaflop of FP4 compute, and a Grace CPU. This eliminates the split across laptop, cloud API, and cloud VM, enabling local coding agents and reducing token consumption through hybrid prompt routers. Compared with Intel Panther Lake, RTX Spark delivers 4.6x faster coding-agent performance, 2.7x faster fine-tuning, and 1.8x faster compilation. A partnership with Microsoft provides Windows Developer Config, WSL optimizations, native PyTorch-CUDA, Python 3.15, and over 2,000 Conda packages for Arm. Local agents like GitHub Copilot, Pi, and Junie are optimized, and decision models in llama.cpp and Unsloth offer near-instant actions while the Nemotron 3.5 Bolt model fits in 24GB using 2-bit quantization.
Announcing Workforce Management: Forecast, schedule, and plan teammate cover in the Intercom helpdesk - The Intercom Blog
Intercom announced Workforce Management, a new set of tools inside its helpdesk for forecasting, scheduling, and planning teammate cover alongside the Fin AI agent. The tools automatically exclude conversations resolved by Fin to plan for human-bound volume only, addressing the challenge of fluctuating human volume as Fin resolves 76% of queries on average. Forecasting shows actual volume to date alongside predicted volume ahead, building automatically from the last eight weeks of conversation data, and can be exported, adjusted, and re-imported as CSV. Scheduling supports reusable shift templates and syncs with Google Calendar, while Teammate Coverage maps scheduled headcount against required staffing hour by hour. Team Performance provides individual scorecards for adherence, conformance, and shrinkage, with away reasons like lunch and meetings surfacing automatically and inbox actions like replies and notes on the timeline. The feature is available now in the Pro add-on and is already live in Pro workspaces.
On-Behalf-Of Is a Pattern. Token Exchange Is the Standard.
The post distinguishes the On-Behalf-Of pattern from the OAuth 2.0 Token Exchange standard (RFC 8693) and Microsoft’s implementation, warning against forwarding a user’s token downstream as it breaks the audience trust boundary. Token Exchange uses a subject_token for the user’s identity and an optional actor_token to record the calling service, with a chainable act claim for multi-hop calls. Microsoft’s implementation uses a jwt-bearer grant, only works for user principals, and can mint SAML assertions for legacy integrations, but the resulting token must never be relayed back to the client. For AI agents, neither OBO nor Token Exchange handles explicit user delegation, so integrators must log act claims, scope tokens to specific tasks, issue per-agent credentials, and build audit trails. The post notes the confused deputy problem resurfaces with agents, and regulatory transparency requirements around automated decision-making are already in effect.
Scaling Radar: Fighting fraud with agent-assisted machine learning
Stripe Radar’s Shield model detects transaction fraud using network-wide signals. To improve recall, Stripe expanded training from roughly 800 million to 11 billion transactions, requiring optimizations that cut each epoch from 24 to 4.8 hours through streaming data loading, torch.compile, lower-precision arithmetic, concurrent execution of ResNeXt branches, and memory reductions. The larger dataset initially improved performance, but delayed fraud reports caused label immaturity, forcing a rollback because the model learned late-reported fraud as legitimate. Stripe built Agentic MLE, enabling AI agents to autonomously investigate failures, implement features, train models, and evaluate results using model explanations and prior experiment data. Using these agents, Stripe identified a training configuration change combining stochastic weight averaging at epoch 0 and shortening training to eight epochs, improving Shield’s recall by over 8% and estimating tens of millions in additional fraud prevention annually.
MCP standardized tools. Now we need the infrastructure around them.
MCP standardized how AI models connect to tools, with clients like Claude Code and Cursor adopting it and SDK downloads approaching half a billion monthly. However, production use reveals that the protocol solves only the interface problem, not the operational concerns around authentication, rate limiting, idempotency, and observability. Teams repeatedly build duplicate infrastructure for deployment, secret handling, health checks, and access control because the protocol does not address these. Context efficiency also remains a challenge: a benchmark showed reducing context from 220,393 to 27,352 tokens (87.6%) while maintaining test pass rates, highlighting the need for deliberate context selection. The author argues that MCP’s success forces the question of building a production-grade infrastructure layer, similar to how HTTP led to CDNs and API gateways.
How Meta Built Forum With AI-Native Engineering
Meta built Forum using AI-native engineering, treating an AI agent as a development participant rather than a faster typing tool. The team shifted from human-in-the-loop to human-on-the-loop, where the agent autonomously plans, implements, builds, tests, and corrects its work while the engineer sets goals and approves outcomes. Success was measured by verified, production-ready results, not code volume, with automated verification signals like build status and unit tests filtering output before review. Meta adapted the codebase for legibility, gave agents tools to inspect live view hierarchy directly instead of descriptions, and created a separate sandbox build to isolate prototype code from production. This approach helped Forum reach core feature parity with Facebook Groups in eight weeks and caught a memory issue during development that roughly halved memory use and page faults.
NVIDIA Nemotron 3.5 Super VL Powers Specialized Agents with Multimodal Reasoning
NVIDIA released Nemotron 3.5 Super VL, an open 120B-parameter multimodal model for specialized enterprise agents. Its mixture-of-experts architecture activates 12B parameters per token, balancing capacity and inference efficiency. The model combines reasoning, instruction following, tool use, and understanding of text, images, documents, and video for tasks including coding, web research, document intelligence, and cybersecurity. On a single GPU, it achieves up to 5x higher throughput for agentic tasks than competing open models, and it scores higher than the larger Nemotron 3 Ultra on Hermes Bench and LangChain evaluations. Early adopters report cost reductions of 40x for credit processing and 10x lower latency for receipt parsing, and organizations can post-train the model with NVIDIA NeMo for domain-specific workflows and deploy it with NVIDIA NIM and Dynamo, which serves up to 8x more users with 85% lower first-token latency.
What is agentic identity? Securing AI agents in 2026
AI agents are shifting from passive copilots to autonomous actors that book tickets, update calendars, and send messages without step-by-step human intervention. This shift introduces operational risks because traditional security controls designed for deterministic software cannot handle non-deterministic agent behavior, leading to over-permissioned agents, rogue behavior, and lack of real-time monitoring. Agentic identity is proposed as a governance layer built on three pillars: authentication (cryptographic keys), authorization (contextual permissions), and context (delegated link to end user). The framework includes short-lived session tokens, user context binding via token exchange, hard operational bounds on tool calls, human-in-the-loop gateways for high-risk actions, verified communication endpoints, and centralized logging with kill switches. By implementing these controls, organizations can deploy autonomous agents safely while maintaining visibility, containment, and auditability across all agent actions.
Three layers, one repo: a tour of google/adk-recipes
The google/adk-recipes repository serves as the single source of truth for ADK content across Google Cloud’s Agent Platform, including the Agents CLI, Agent Garden, and Gemini Enterprise app. It is organized into three top-level folders: core/ with reference patterns curated by the Agents CLI and DevRel teams, plugins/ with installable vertical skills packaged as Plugin Recipes conforming to the Agent Plugins v1.0.0 spec, and contrib/ with end-to-end deployable services in five languages. Every recipe ships a validated manifest.yaml and an AGENTS.md written primarily for AI coding assistants, and CI enforces the standards on every pull request. The core/ layer features Horizon, a reference harness for long-horizon memory agents that handles cross-session memory, per-user sandboxing, guardrails, and multi-step task orchestration. The retail Plugin Recipe includes product-search and virtual-tryon skills using Vector Search 2.0 and Gemini models, with deployable counterparts in contrib/ that can be surfaced on five deployment personas.
Evaluating AI agents: moving past the vibe check
Manual vibe checks for AI agents miss silent failures like retry loops, token waste, and hallucinated parameters while plausible final answers mask them. The post outlines a structured evaluation pipeline using the open-source agent-eval toolkit, starting with critical user journeys (CUJs) that define success in concrete, testable clauses. Synthetic user simulations (via ADK) generate multi-turn scenarios for initial trace collection, which developers grade with a ‘red pen’ before automating checks. Four layers of verification are recommended: unit tests, deterministic metrics, LLM-as-a-judge with boolean rubrics (avoiding unreliable 1-to-5 scales), and integration tests, all standardized on OpenInference/OpenTelemetry traces. The rollout progresses from Day 0 manual review through Day 1 automated checks to Day 2 CI/CD gates and shared dashboards, with real production traces fed back into the golden dataset.
Everyone's adopting AI agents. Almost no one can prove the ROI. Here's why
Many organizations are quickly adopting AI agents, yet almost none can convincingly demonstrate the return on investment due to a mismatch between purchasing decisions and actual usage. This gap arises because executives buy AI out of fear of being left behind, not from validated ROI studies, and teams measure productivity using speed metrics that miss the broader picture. True productivity from agents is about automating routine, schedulable tasks so human experts can devote energy to judgment calls and creative work, provided quality is maintained alongside efficiency. Without rich business context like institutional knowledge, local regulations, and historical data, an AI agent cannot deliver meaningful work, no matter how fast it executes generic instructions. The most frequent mistake is scaling prematurely trying to roll out broadly after a few promising demos, without ensuring the necessary iteration, infrastructure, and readiness for reliable, quality outcomes at scale.
Why AI at Work Needs a Rethink
A survey of over 6,000 knowledge workers across the UK, France, and Germany, commissioned by Notion, reveals that daily AI users report significantly more benefits than occasional users. For example, 59% of daily users in the UK say AI agents are changing team collaboration, versus 37% overall, and 48% say AI helps them demonstrate more value, nearly double the overall 25%; similar patterns hold in France and Germany. Gen Z workers are especially likely to use AI to expand their responsibilities, but they also express higher concern about job security, notably in Germany where concern was 21 points above the national average. However, AI use remains largely individual: only about 20% of respondents embed AI agents in team-wide workflows. The post argues that the next step is rebuilding AI around shared workflows and company context, as demonstrated by companies like Pennylane and Brainlabs.
Optimizing Agent Reliability and Tool Calling Efficiency for Chip Design Using NVIDIA NeMo Gym
AI agents in chip design often produce plausible but incorrect artifacts, making reliability a key barrier to production adoption. NVIDIA NeMo Gym, an open library for evaluating models and agents using environments, solves this by diagnosing failure modes in multistage workflows through verification of final outputs against reference artifacts. Applied to the Siemens Fuse EDA AI Agent for standard-cell characterization, NeMo Gym uses a verifier that checks coverage, validity, relative validation, integrity, and accuracy of generated Liberty files against known references. After refining the agent’s skills and MCP tool descriptions based on trajectory analysis of failures, the composite benchmark score improved from approximately 55% to 95%, while agent turns fell from 155 to 53 and output tokens dropped from ~81K to 29K. This method generalizes to other engineering domains by emphasizing evaluation of final artifacts and domain-specific verifiers.
How Cloud-Based Agent Sandboxing Works in Air
AI agents require sandboxing to restrict file, network, and system access, preventing unintended modifications and data leakage. The post categorizes five agent execution modes into local (workspace, git worktree) and remote (SSH, Docker, Cloud), with remote modes providing stronger isolation by default. In JetBrains Air, each cloud agent task runs in its own VM with the agent inside a Docker container, and all network connections are routed through a proxy that allows only trusted domains by default. Secrets are stored encrypted and exposed as environment variables, and the agent operates within the developer’s repository permissions. Cloud-based execution reduces local setup requirements and gives organizations control over network access policies, with cloud agents currently available to organizational users via Air in IDEs and Air Teams.
Related topics
All topics →Weekly digest
The best engineering reads, once a week.