“ai-agents”
Retry Strategies That Respect Model and Rate Limits
Design LLM retries that respect rate limits: LiteLLM Router backoff, RetryPolicy, cooldowns, and why naive retry loops make 429s worse.
Threading Model of the OpenAI Agents SDK: Sessions, Resumptions, and Re-Runs
How the OpenAI Agents SDK threads conversation state: sessions, interrupted-run resumptions, compaction, and the SQLite trust boundary.
Monitoring for Anomalous Tool Sequences: Detecting Exfiltration
Detect agent data exfiltration by tracing tool calls as OpenTelemetry spans and flagging anomalous tool sequences per trace.
Container Sandboxes for Tool Execution: Images, Seccomp, and Network Policies
Harden agent tool execution with container sandboxes: minimal images, seccomp profiles, dropped capabilities, and Kubernetes NetworkPolicy egress control.
Choosing an Agent Framework: A Decision Matrix for Enterprise Teams
A weighted decision matrix for picking an agent framework, built from LangChain's 2026 seven-framework comparison and enterprise constraints.
Domain Guardrails: Keeping Vertical Agents Inside Their Lane
Scope vertical agents to their domain with Microsoft Agent Framework middleware, typed tool policies, and deterministic label-based enforcement.
Compliance Monitoring Agents for Regulated Document Streams
Build agents that watch regulated document streams for violations using LlamaIndex workflows, LlamaParse extraction, and typed events with human review.
Leader-Agent Orchestration: Coordinating Specialist Sub-Agents in LangGraph
Build the leader (supervisor) pattern as an explicit LangGraph state machine: graph structure, routing, shared vs private state, failure handling and hard stopping conditions for delegated sub-agents.
Stress Testing MCP Servers Under Real Agent Workloads
Load-testing an MCP server like a REST API measures the wrong things. Model agent-like traffic - discovery bursts, chatty tool sequences, SSE subscriptions - run it with k6, and watch per-method latency, tool error rate, and first-event time.
Building an E-Commerce Cart Agent with Structured Tool Outputs
Cart tools that return free text push JSON parsing into your agent prompt. Build a Pydantic AI cart agent where add, update, remove, price, and checkout-prepare each return a validated Pydantic model, with recoverable validation errors and TestModel tests.
Agentic Subscription Management: Trials, Upgrades, and Downgrades via Tool Calls
Design a safe tool surface for agent-driven subscription changes: proration, trials, dunning, idempotency keys, confirmation gates, and reconciliation.
Compliance as an Agent Task: Automating Policy Checks with Verifier Agents
Build verifier agents that check every proposed agent action against codified policy, with fail-closed defaults, guardrail placement, and eval-backed tests.
Insurance Claims Triage Agents with Structured Classification
Build an intake agent that classifies claims with Pydantic schemas, verifiable evidence, confidence-based escalation, evals, and a full audit trail.
Retention and Egress Controls: Governing Agent Conversations at Scale
Tiered retention windows, pre-persistence redaction, deletion workflows, egress allowlists, residency, and audit evidence for agent conversation logs.
HR Onboarding Agents: Orchestrating Tasks, Forms, and Provisioning
Onboarding is a checklist across many systems. How an orchestrating agent coordinates account provisioning, form collection, and approvals — with humans in the loop.
Money Movement Agents: Designing Tool Contracts for Transfers and Payouts
Letting an agent move money means strict tool contracts: typed amounts, idempotency keys, confirmation gates, and reversible paths. Patterns that keep finance teams sane.
Audit Trails for Regulated Industries: Structuring Agent Events for Compliance
HIPAA, SOC 2, and financial regulators expect immutable records. How to structure agent events — who decided what, with which data — so audits pass.
Session Replay for Agents: Reproducing a Full Run
Logs tell you what happened; replay tells you why. Recording agent inputs, tool calls, and model responses so any run can be deterministically reproduced and debugged.
Timeouts and Deadlines: Human Fallback When Agents Stall
Autonomous agents hang: a tool call never returns, a loop never converges. How to set deadlines, detect stalls, and degrade gracefully to a human.
Grounded Agents: Citation-Anchored Answers in RAG
Users trust AI answers they can verify. How to make RAG agents return citations anchored to source passages — chunk attribution, prompt contracts, and rendering provenance.
Recruiting Agents: Resume Parsing, Screening, and Bias Guards
A resume-screening agent is a regulated decision system with an LLM in the middle. How to structure parsing and scoring — and the guardrails that keep an agent out of the headlines.
Rate-Limiting Agent Tools: 429s, Throttling, and Graceful Degradation
A 429 is the one error an agent cannot think its way out of. Where limits come from, how to honor them at the gateway with LiteLLM, and what your agent should do when the queue is full.
The Saga Pattern for Multi-Agent Transactions: Compensating Actions
Agent workflows touch payment, inventory, email, and CRM systems — and they fail halfway. Sagas give you long-running transactions with compensating actions instead of pretending rollback exists.
Legal Contract Review Agents: Extraction, Clause Risk, and Citation
Contract review is an ideal agent workload — until the agent cites a clause that does not exist. How to build extraction, risk scoring, and citation-grounded outputs with LlamaIndex-style pipelines.
Exposing Your Payment Gateway as an MCP Tool Server
MCP lets agents call tools — and payments are the scariest tools you can expose. Here is how to structure an MCP tool server over your payment gateway with two-phase approval, idempotency, and least privilege.
Feedback Loops: Turning Human Edits into Agent Improvements
Every time a human rewrites your agent's output, you throw away a training signal. A feedback loop turns those edits into datasets, evals, and measurable model improvements.
LlamaIndex Agents vs. a General-Purpose SDK: When to Reach for Which
A practical decision guide for choosing between LlamaIndex agents and framework-agnostic SDKs like PydanticAI or the OpenAI Agents SDK, based on where your leverage actually comes from.
Dashboarding Agent Fleets: From Spans to Business Metrics
A pipeline for turning OpenTelemetry agent spans into the metrics leadership actually asks about — task success, cost per task, and escalation rate — without losing the drill-down to a single trace.
Explainable Actions: Surfacing Agent Reasoning for Trust
Turn agent runs into structured, auditable action records — sessions, events, and callbacks as the backbone of explainability that users, auditors, and engineers can all read.
Versioning Tools: Backward-Compatible Function Evolution for Agents
Treat LLM function-calling tool schemas as a public API you cannot break — additive-only evolution rules, deprecation with dual registration, model behavior on schema changes, and golden tool-call fixtures that catch regressions before deploy.
Circuit Breakers for LLM and Tool Dependencies
Apply the circuit-breaker pattern specifically to LLM providers and agent tool endpoints — failure classification, per-dependency state machines, LiteLLM gateway wiring, and fault-injection tests that prove the breaker trips when it should.
Idempotency Keys in Agent Payment Loops: Retry Without Double-Charge
The full lifecycle of a payment idempotency key inside an agentic retry loop: mint it per logical intent, persist it before the tool call, replay stored results, scope and fingerprint keys, and reconcile for double charges.
A2A Agent Cards: Publishing and Resolving Agent Capabilities
Author, publish, sign, and consume A2A Agent Cards: the JSON manifest that declares an agent identity, skills, interfaces, and security requirements at /.well-known/agent-card.json, with a worked publishing and resolution example.
Hardening MCP Servers: Input Validation, Rate Limits, and Authentication
A practical hardening guide for production MCP servers: schema-validated tool inputs, payload caps, per-client rate limits with 429 semantics, OAuth 2.1 enforcement, and transport-level controls grounded in the MCP specification.
Migrating a LangChain Agent Chain to LangGraph: A Refactoring Guide
From AgentExecutor to StateGraph — a step-by-step mapping of the old LangChain agent pattern onto LangGraph concepts, with the v1 migration rules.
Review Queues: Human Triage of Agent-Produced Work
LlamaIndex Workflows implement review queues with InputRequiredEvent and HumanResponseEvent — pause, persist, and resume agent runs for human triage.
Steering Agents by Conversation: Chat as a Control Surface
CrewAI turns a chat thread into an agent control surface — routing turns, pausing for human feedback, and resuming runs mid-flight.
Secrets Handling for Agent Workflows: Vaults, Scopes, and Rotation
Keeping credentials out of model context: OWASP LLM risks, the tool broker pattern, scoped per-tool keys, Vault dynamic secrets and leases, rotation and revocation, and MCP OAuth 2.1 authorization.
Publishing Agents: From Notebook to Enterprise Registry
The path from a working agent prototype to a discoverable enterprise service: packaging, hosting options, A2A agent cards, catalog-based discovery, and the governance layer that makes it usable by other teams.
Parallel Tool Calls: Batching and Dependency Ordering in Agent Loops
How multi-tool turns actually execute in the OpenAI Agents SDK: model-side parallel_tool_calls vs SDK-side concurrency, capping fan-out, and patterns for enforcing dependency order safely.
PCI Compliance for Agentic Checkout: Tokenization and Scope Reduction
What the PCI DSS actually requires when an AI agent performs checkout on behalf of a user, how Stripe-hosted flows shrink your scope to SAQ A, and the key-handling and idempotency rules that keep retries safe.
Comprehensive Testing Guide for Flutter: Unit, Widget, E2E & Agentic Workflows
A deep dive into unit testing, E2E integration testing, and AI agentic testing workflows in a Flutter Riverpod and Drift codebase.
Building a Harness with Jev: Fast, Structured Decisions for Your Agents
Jev is TypeSafe AI's new System One model: a frontier-intelligence function call that turns unstructured state into typed probabilistic decisions in milliseconds — without hallucinating. Learn how it works and how to wire it into a LangChain harness for model routing and tool risk gating.