← al-taher.os

WRITING · notes & essays

Writing

Notes on design, motion, and building software.

Multimodal Agents: Building AI That Sees, Not Just Reads

A model that has read every document your company ever produced still cannot tell you whether the shelf in aisle four is empty. Most of what matters was seen, not written. A practical tour of vision-language agents: how models actually see, the token bill for resolution, video, multimodal retrieval, injection through pixels, and what to build first.

Data Privacy for AI Agents: What Leaves the Building, and What Never Should

Every read was authorized and the aggregate was still a disclosure. Agents compose personal data faster than any review process can watch. A practical tour of privacy engineering for agentic systems: minimization, redaction, memory, traces, tools, deletion, and what to build first.

Knowledge Graphs for AI Agents: The Structure Vectors Cannot Give You

Vector search finds passages that resemble your question. It cannot tell you what is connected to what, count anything, or notice an absence. A practical tour of building knowledge graphs for agents: ontologies, extraction, entity resolution, provenance, time, traversal tools, and evaluation.

Document Intelligence: How AI Reads Contracts, Forms, and Invoices at Scale

Most commercially important information still lives in scanned PDFs, forms, and contracts. A tour of why documents resist automation, what layout-aware and vision models changed, and the pipeline of schemas, validation, confidence, grounding, and review that makes them actionable.

Agentic Commerce: How AI Agents Buy, Pay, and Get Paid

When the shopper is a model holding a mandate and a scoped payment credential, checkout stops being a page. A tour of payment mandates, virtual cards, x402 micropayments, agent-ready storefronts, and who pays when the agent gets it wrong.

Caching for LLM Applications: The Art of Not Paying Twice

Most tokens a production LLM system processes are tokens it has processed before. A layer-by-layer guide to KV caches, prompt caching, semantic caches, and the invalidation discipline that keeps them honest.

Synthetic Data: How AI Systems Learn From Examples That Never Happened

Real data is scarce, expensive, and privacy-encumbered. A practical guide to generating training and eval data with models — and keeping it diverse, verified, and honest.

Data Agents: How AI Learns to Query, Analyze, and Explain Your Data

Text-to-SQL looks solved in the demo and fails in the warehouse. A practical guide to building data agents people can actually trust: semantic layers, guardrails, evaluation, and the engineering that prevents the plausible wrong answer.

On-Device Agents: Running AI Where the Data Lives

Cloud models get the headlines, but a quiet shift is underway: small language models running agent loops directly on phones, laptops, and edge hardware. A practical guide to when local inference makes sense, what the hardware and runtimes can actually do, and how to architect hybrid agents that keep private data on the device.

Fine-Tuning for AI Agents: When Prompting Isn't Enough

Prompts and context carry you far, but some gaps only close in the weights. A practical guide to SFT, LoRA, preference optimization, reinforcement fine-tuning, and distillation — and the data, evaluation, and operational discipline that decide whether any of it pays off.

Structured Outputs: Getting Reliable Data Out of Language Models

Language models speak prose, but software speaks data. A practical guide to schemas, constrained decoding, validation and repair loops, and the design decisions that make model output trustworthy enough to build on.

Agent UX: Designing Interfaces for AI That Acts

Chat was the demo, not the destination. A practical guide to designing interfaces for agentic AI: showing the work, previewing intent, asking for approval without exhausting the user, and building the calibrated trust that delegation depends on.

Coding Agents: How AI Went From Autocomplete to Autonomous Software Engineering

Software development is the first profession being rebuilt by the tools it built. Here is how coding agents actually work — the loop, the harness, the feedback signals — and what they change about how software gets shipped.

Voice Agents: Building AI That Listens, Thinks, and Speaks in Real Time

Voice is the oldest interface humans have and the newest one models have learned to operate. Here is what it actually takes to build a voice agent that listens, reasons, and answers fast enough to feel like conversation.

Shipping AI Agents to Production: Deployment, Rollouts, and Reliability Engineering

Building an agent is the easy part. This is a practical guide to the deployment machinery — versioning, staged rollouts, gates, rollback, and monitoring — that determines whether a change to an agent is safe to ship.

The Economics of AI Agents: Token Costs, Latency, and the Price of Autonomy

Everyone talks about what an agent can do. Almost no one talks about what it costs to let it try. A practical tour of agent economics: token costs, latency, and the compounding loop structure that makes autonomy expensive when nobody is watching.

Human in the Loop: Designing Approval, Escalation, and Trust Boundaries for AI Agents

Autonomy is not a single switch you flip once. It is a set of decisions about which actions an agent can take alone, which need a person to sign off first, and which need someone paged immediately. This is a field guide to making those decisions deliberately instead of by accident.

Model Routing: Picking the Right Model for Each Step of an Agent

Not every step in an agent's loop deserves your best, most expensive model. Model routing is the discipline of matching each decision to a model that is just capable enough for it — and it is one of the highest-leverage things you can do to an agent's cost, latency, and reliability at once.

Prompt Injection: The Security Problem Built Into Every AI Agent

Any agent that reads text from outside its system prompt is reading instructions from a stranger. Here is why prompt injection is the hardest unsolved security problem in agentic AI, and what actually reduces the risk.

Long-Running Agents: Designing AI Systems That Work While You're Away

An agent that answers in a single turn is easy to reason about, because the whole exchange happens inside one process's lifetime. An agent that runs for hours or days has to survive its own duration — crashes, stale facts, duplicate retries, and long silences from the humans it was built to serve. This is the engineering that makes survival possible: checkpointing, idempotency, crash recovery, asynchronous approval, and the failure modes that appear once a task outlives a single sitting.

Identity and Access for AI Agents: Who Is This Agent Allowed to Be?

Every agent that acts on your behalf is, underneath the prompt, also a credential: something that authenticates as someone and is authorized to do something. Most teams building agents today have not actually decided who that someone is.

Computer-Use Agents: Teaching Models to Operate Screens, Apps, and Interfaces

Every major AI lab has now shipped a model that can see a screen and operate it directly. Here is what actually goes into making that reliable, safe, and worth the cost.

Sandboxing for AI Agents: Letting Models Run Code Without Losing Control

Code execution is one of the most useful capabilities an agent can have, and one of the easiest to get badly wrong. A close look at how containers, microVMs, and WebAssembly actually contain what a model decides to run, and why the boundary that fails is usually the one nobody thought to check.

Agent Interoperability: How MCP and Open Protocols Let AI Systems Talk to Each Other

Every agent needs to reach tools, data, and other agents, and for years that meant a bespoke integration for every pair. A practical look at MCP, A2A, and the protocols standardizing how agentic systems connect, what they fix, and what they don't.

Planning and Reasoning: How AI Agents Decide What to Do Next

Before an agent acts, it has to decide what to do. This is a practical guide to how agents plan: reactive step-by-step decisions, upfront plans, decomposition, replanning, self-reflection, and search over reasoning paths, plus when each is worth its cost.

Observability for AI Agents: Seeing Inside Systems That Act

An agent you cannot see inside is an agent you cannot trust, because every system that acts in the world eventually does something you did not expect — and observability is how you find out what, and why.

Guardrails for AI Agents: Keeping Autonomy Inside the Lines

An agent that can act is an agent that can act wrongly, and the more capable it becomes the more its mistakes cost. Guardrails are the engineering that lets you grant autonomy without surrendering control — the constraints that keep a system free to act inside the lines you can live with.

Multi-Agent Systems: When to Split One Agent Into Many

A single agent can carry a surprising amount of work before it buckles, and the instinct when it does is to split it into many — but a crowd of agents is not automatically smarter than one. The difference between a multi-agent system that compounds capability and one that compounds confusion lies almost entirely in how the work is divided and how the pieces talk to each other.

Tool Design for AI Agents: How Models Act on the World

A language model on its own can only ever produce text, which means that without help it can describe an action perfectly and perform none of it. Tools are how a model reaches past its own output and touches the world — and the difference between an agent that reliably gets things done and one that flails convincingly is almost entirely in how those tools are designed.

Retrieval-Augmented Generation: Grounding Language Models in Reality

A language model knows an enormous amount and remembers almost none of it reliably. Retrieval-augmented generation is how you put the right facts in front of it at the right moment, and the engineering around that is what separates a system that cites reality from one that invents it.

Memory Systems for AI Agents: How Agents Remember, Forget, and Stay Coherent

The context window is not memory. A practical look at how agents store, retrieve, write, and forget — the taxonomy, the architectures, the failure modes, and where to start.

Evals: How to Actually Measure LLM Application Quality

You can't improve what you can't measure, and 'it looks good' doesn't scale. A practical guide to building evaluations that catch regressions and drive real progress.

Loop Engineering: Designing Reliable Agent Loops

The agent loop is where autonomy actually happens — and where it most often breaks. A deep look at designing loops that terminate, recover, and stay on task.

Agentic AI: Architecting Systems That Act

An agent is more than a model with a clever prompt. A practical look at the components, patterns, and failure modes of systems that plan, use tools, and act on their own.

Context Engineering: The Real Bottleneck in LLM Applications

Prompts are only part of the story. The harder, higher-leverage problem is deciding what information enters the model's context window — and what stays out.

Prompt Engineering in Practice: Techniques That Actually Move the Needle

A practical field guide to the prompting techniques that reliably improve LLM output — structure, examples, decomposition, and testing against real failures.

Writing — Monir Al-Taher