AI Agents

Agent Pattern Design: From Tool Use to Planning, Parallelism, HITL, and Reflection

Compose bounded control flows instead of building one giant autonomous loop

A plain-Python guide to tool use, parallel orchestration, planning, HITL, retry, and reflection—and to the boundary between LLM judgment and deterministic code.

LangGraph Is Not Architecture: Where the Runtime Actually Belongs

Separate graph state from application state to assign responsibility across workers, Redis, databases, and browsers

A close look at LangGraph's graph.astream(), updates, custom streams, reducers, and checkpoints—and the boundary between an agent runtime and backend architecture.

Let the Agent Speak While It Works: SSE, Generators, and Redis Streams

Safely stream snapshots and events over an HTTP connection with async generators

Build an agent streaming endpoint from iterators and async generators through SSE framing, Redis Stream replay, heartbeats, disconnects, and backpressure.

Can an Agent Tool Execute Exactly Once? Approval, Idempotency, and Retries

Linking user intent to side effects so a transfer tool does not run twice

For side-effecting agent tools such as transfers and payments: human approval, action fingerprints, idempotency keys, queue redelivery, and unknown outcomes.

State Is Not an Event: Designing Real-Time Agent UIs

Restore the screen from a snapshot, then keep its timeline complete with cursors

Lay out current state and an event timeline in an agent run screen, then implement bootstrap, SSE cursor replay, and snapshot resync for safe reconnects.

Where Does Agent State Live? Redis, PostgreSQL, and Checkpoints

Durable records, hot projections, and resumable snapshots survive different failures

Separate agent state into durable run records, hot projections, execution checkpoints, and process-local state, then place each by its failure and recovery requirements.

A Worker Is Not a Thread: Why Agent Execution Should Leave the API Server

Separate concurrency primitives from ownership of the execution lifecycle

Why a worker is not another name for a thread or process, and when a long-running agent run should move from an API request to a queue and worker.

Async, Threads, and Processes: What to Know Before Agent Workers

Waiting, blocking SDKs, and CPU-bound computation require different execution tools

Classify agent-backend work as non-blocking I/O, blocking I/O, or CPU-bound computation, then choose among async, threads, and processes.

Why Agent Systems Need Async: Making Waiting Time Useful

Turn time spent waiting on LLMs, databases, and search APIs into concurrency

Why agent backends need async, explained through blocking, coroutines, tasks, the event loop, await, and structured concurrency.

Why Serve Open-Source LLMs with vLLM on Internal GPUs?

Deciding internal open-model serving for security, data control, cost, and performance

When internal GPU serving and vLLM make sense: compare external APIs, adoption trade-offs, batching and prefix caching in plain terms, and a pre-flight checklist.

Agent Backend Architecture at a Glance: How APIs, Queues, Workers, State, and SSE Fit Together

Execution architecture boundaries — mental model, failure modes, optional deep dives

How API, queue, worker, PostgreSQL, Redis, and SSE divide responsibility in an agent backend. Implementation detail lives in follow-up articles.

Why I Keep Research as an Archive, Not a Feed

Why I keep questions, evidence, assumptions, and revision conditions with the conclusion, so research can be revisited and reused.

From Retrieval Engineering to Task Engineering

What changes when retrieval becomes part of an end-to-end task?

AI engineering is moving from optimizing retrieval pipelines to specifying, constraining, and evaluating end-to-end enterprise tasks.

Who Disappears First: The AI Team or the Business Teams?

As agents take on more work, which team changes first? A task-level view of how enterprise AI may reshape both builders and business practitioners.

Why Enterprise AI Transformation Should Start Narrow

General-purpose AI is a Swiss Army knife; enterprise AX is a purpose-built blade. A Market Intelligence case shows why transformation means redesigning work, not automating it.

What is vLLM tuning?

Serving LLMs when GPUs are scarce

A practical guide to serving LLMs on limited on-premises GPUs: diagnose prefill, decode, KV cache, queues, and tail latency to tune vLLM for sustainable throughput.

Build with Gemini Notes: Google Cloud Is Taking the Agent Era Seriously

How the number-three cloud is using agents as its next enterprise entry point

Notes from Build with Gemini on Google Cloud's agent governance, Gemini Enterprise as a sticky entry point, and its distribution challenge in Korea.

Why Our Agent Platform Got Off to a Rocky Start

From a convincing demo to a predictable production system

Our agent platform worked in demos but stumbled in production. A retrospective on predictability, trust debt, and earning abstractions through deployment.

Do Agents Have to Be Graphs? Why I Am Removing LangGraph from My Default Stack

From prescribing every route to designing the environment and boundaries around an agent

After building a multi-agent research system with LangGraph, I am rethinking where explicit graphs belong as models choose more of their own execution paths.