Agentic AI
How to Evaluate Agents Locally with Arize Phoenix
A hands-on guide to running Phoenix locally: trace an agent over OpenTelemetry, then score it with LLM-as-judge and code evaluators.
7 min read
Building, coordinating, and shipping AI agents.
22 articles
A hands-on guide to running Phoenix locally: trace an agent over OpenTelemetry, then score it with LLM-as-judge and code evaluators.
AgentOps is the practice of running agents in production: observability, evaluation, guardrails, cost governance, and human oversight.
Most agents fail for boring, fixable reasons. Here are the practices that make an agent reliable: fewer LLM calls, tools that explain themselves, and a debugging ladder to climb when it misbehaves.
smolagents ships two agent classes that act in completely different ways: one writes Python, one emits structured JSON. Here is how each works, what each is good and bad at, and when to reach for which.
An agent is a stateless model wrapped in a loop. Here is the ReAct pattern built from scratch: the message list as memory, the exact algorithm, and the rule that generate calls equal tool rounds plus one.
Anthropic's Claude Tag drops a shared, persistent agent into Slack channels. The interesting part is not the model, it is the move from one-off chats to a teammate that remembers.
How to choose how to structure an agent: the plain while loop, the explicit state machine, and the full graph. What each gives you, what each costs, and when to move up.
How to stream LLM tokens, tool progress, and state updates from a LangGraph agent using the v2 stream API, with the custom writer pattern most people miss.
Autonomy is great until the agent deletes the wrong file or emails the wrong list. Here is how DeepAgents pauses on sensitive tool calls and waits for a human, in TypeScript.
Skills give an agent deep, reusable capability without paying for it on every turn. Here is how DeepAgents loads them in layers, and how to write ones that get picked.
DeepAgents treats long-term memory as files the agent reads and writes, with backends deciding where they live. Here is how scoping, episodic memory, and consolidation actually work.
Subagents are the main lever for stopping a long task from drowning in its own context. Here is how DeepAgents implements them in TypeScript, and the mistakes that make them useless.
A tour of how DeepAgents assembles, compresses, and isolates context, with the TypeScript config for each layer. The framework does a lot automatically; this is what is happening and where you steer it.
What state, checkpoints, and threads actually are in LangGraph, how to pick a checkpointer, and how persistence powers memory, resume, and human-in-the-loop.
A practical guide to keeping production agents safe: where to put input and output rails, how to contain tools, and why prompt injection needs layers, not a fix.
A deep, hands-on tour of Vercel's Eve framework for durable agents: the filesystem-first model, every core capability, a complete TypeScript research agent, and an honest comparison with LangChain's Deep Agents.
A clear split between an agent's working memory and its cross-session memory, with LangGraph code for checkpointers, stores, and the semantic/episodic/procedural breakdown.
Deep Agents bakes planning, context management, subagents, and human approval into the agent loop. Here is why it exists, every main feature, and a production-grade customer support agent built with it.
You cannot improve an agent you cannot measure. A deep, practical guide to evaluating agents with LangSmith: tracing, datasets, evaluators, experiments, and what makes agent evaluation different.
A hands-on guide to building MCP servers with FastMCP, drawn from two I actually shipped: the anatomy, the rules, stdio vs remote HTTP, the pitfalls, and how to test and deploy.
An agent with no tools is just a chatbot. Here is how tool calling really works, what makes a tool the model can use reliably, and how MCP lets you plug in tools you did not write.
Agents, explained without the hype: what they are, when one is enough, when you need several, and how to build a working multi-agent system with LangChain.