Blog
Writing
Life, tech, and everything in-between.
Graph Engineering Is Not a New Discipline. That Is the Point.
A new label is going around for building agentic systems as explicit execution graphs. The label is barely real. The shift underneath it is, and the evidence for and against it is more interesting than either side admits.
I Read the Code
The planner, coder, judge split is a good harness: an expensive model plans, a cheap one writes, the expensive one judges, with the budget spent where judgment lives. But an LLM judge is a filter, not an alibi; it catches the cheap model's misses, not whether the plan solved your problem or whether the edge cases the models quietly agreed on match the ones your users will find. The one step that does not delegate is the last: somebody opens the diff and reads it.
Stop Building Agent Demos. Start Building Agentic Software.
Agentic AI is in its demo phase, where a chain of prompts looks magical in a notebook but falls apart in production. The discipline that separates the two is knowing where reasoning belongs to the model and where reliability belongs to ordinary code.
The Agentic Future and the Token Economy
The agentic future is now mainstream consensus, and tokens have become the unit of account for the intelligence economy. But tokens are a unit of labor, not money; the real money between agents is stablecoins; and the most actionable move is building software agents can consume.
Thin SDK, Fat Runtime: Owning the Agent Loop in Pure Python
A provider's SDK earns its keep on six concerns: auth, request shape, transport, retries, streaming reassembly, and response parsing. Everything above that, the agent loop, planning, routing, memory, parallelism, guardrails, and workflow state, is application architecture and is better written in pure Python.
One Word, Three Jobs: What "Agent" Means at Lunch and in Production
The lunch-table conversation about AI agents and the production-engineering conversation about AI agents are both right. They are talking about three different things and calling all of them "agent."
Short-Term and Long-Term Memory for LLM Agents
An agent with no memory repeats itself. An agent with bad memory contradicts itself. Getting memory right means splitting it into kinds: short-term for the session, long-term for durable facts, procedural for how-to, episodic for what-happened.
LATS: Monte Carlo Tree Search for LLM Agent Decisions
LATS brings Monte Carlo Tree Search, the algorithm behind AlphaGo, to language agents. Reasoning, acting, and planning become a single tree that the agent navigates by balancing exploration against exploitation. Accuracy climbs, cost climbs with it.
Reflexion: Verbal Self-Critique After Failure for LLM Agents
When an agent fails a task, a separate critique call can write down what went wrong in words, store the critique as a memory, and let the next attempt condition on it. No gradient updates. A model that learns from text about its own past.
The Agent-Computer Interface: Designing Tools for LLM Agents
Anthropic reports spending more time tuning tool descriptions than tuning prompts for a SWE-bench agent. Tool design is where agentic systems actually succeed or fail, and it pays more compounding returns than almost any other investment.
Plan-and-Execute: Two-Phase Agents That Plan First, Then Act
ReAct interleaves planning with acting at every step. Plan-and-execute produces a complete plan first, then executes it. The separation trades adaptivity for token efficiency and is often the better choice when tasks have clear structure.
The Tool-Calling Agent Loop: ReAct as It Actually Ships
The 2022 ReAct paper parsed thought-action-observation from free text. Production agents today use native tool-calling, a step budget, input and output guardrails, and explicit handoff handling. The simple loop earns its hardening.