# Hamed Taheri

> I build AI products and take them to production: memory for agents, personalization at scale, and agents that hold up in the enterprise. This site hosts The AI Personalization Handbook and my writing on building AI products.

## The AI Personalization Handbook

A practitioner's reference for AI personalization, from the first decision to production. Every chapter ends with a "For your AI" block of structured YAML: concepts, decision rules, assessment questions, patterns and anti-patterns.

- [Full text, one file](https://hamedtaheri.com/handbook/full.md): every chapter and playbook in reading order
- [Introduction: Hi {first_name}](https://hamedtaheri.com/handbook/md/introduction.md): Why this handbook, and how should I read it?

### Part I. The Case

- [1. What Personalization Is, and What It Is Worth](https://hamedtaheri.com/handbook/md/what-personalization-is.md): What is personalization, and why should a leader care now?
- [2. The First Era](https://hamedtaheri.com/handbook/md/the-first-era.md): How did we personalize before language models, and what did it teach us?
- [3. What Designers Knew](https://hamedtaheri.com/handbook/md/what-designers-knew.md): What did UX research and HCI learn about adapting interfaces to people, and what does it teach AI personalization?
- [4. Shallow to Deep](https://hamedtaheri.com/handbook/md/shallow-to-deep.md): Why was deep personalization always limited to a few people, and what does "deep" actually mean?
- [5. The New Era](https://hamedtaheri.com/handbook/md/the-new-era.md): What exactly changed with AI, and where is it going?

### Part II. Where to Start

- [6. Choosing Your First Decisions](https://hamedtaheri.com/handbook/md/choosing-your-first-decisions.md): Where is the highest-ROI personalization in my company?

### Part III. Customer Data

- [7. Getting the Data](https://hamedtaheri.com/handbook/md/getting-the-data.md): What data can we use, where does it come from, and are we allowed to use it?
- [8. Preparing It](https://hamedtaheri.com/handbook/md/preparing-it.md): How do we clean, enrich, and use unstructured data?
- [9. One Customer, Many Systems](https://hamedtaheri.com/handbook/md/one-customer-many-systems.md): How do we unify a customer across CRM, warehouse, and tools without merging two people?

### Part IV. Unified Customer Memory

- [10. Memory Built for Agents](https://hamedtaheri.com/handbook/md/memory-built-for-agents.md): What changes when the main reader of our customer data is an AI agent, not a person at a dashboard?
- [11. Keeping Memory True](https://hamedtaheri.com/handbook/md/keeping-memory-true.md): How does memory stay accurate, fresh, and traceable?
- [12. The Cost of Remembering](https://hamedtaheri.com/handbook/md/the-cost-of-remembering.md): How do we keep memory affordable at scale without losing accuracy?
- [13. Agents That Run for Weeks](https://hamedtaheri.com/handbook/md/agents-that-run-for-weeks.md): How do long-running agents use and maintain memory?

### Part V. Deciding and Acting

- [14. The Decision Layer](https://hamedtaheri.com/handbook/md/the-decision-layer.md): What should happen next for this person, including nothing?
- [15. Writing for One](https://hamedtaheri.com/handbook/md/writing-for-one.md): How do we generate for each person without inventing?
- [16. Beyond the Message: Generative Experiences](https://hamedtaheri.com/handbook/md/generative-experiences.md): What happens when the page, the app, and the notification, not just the message, are composed for one person?
- [17. Now or Later](https://hamedtaheri.com/handbook/md/now-or-later.md): When must personalization be real-time, and when is async better?

### Part VI. Trust

- [18. Governance](https://hamedtaheri.com/handbook/md/governance.md): How do we govern what the AI says and does, at the level of the organization and at the level of each customer?
- [19. Privacy and Regulation](https://hamedtaheri.com/handbook/md/privacy-and-regulation.md): What should we never know, keep, or use, and what does the law require?
- [20. Accuracy and Quality](https://hamedtaheri.com/handbook/md/accuracy-and-quality.md): How do we achieve and keep accuracy at scale?

### Part VII. Proof and Deployment

- [21. Did It Work?](https://hamedtaheri.com/handbook/md/did-it-work.md): How do we prove personalization caused the result?
- [22. Deploying It](https://hamedtaheri.com/handbook/md/deploying-it.md): How does a company actually build and roll this out?

- [Closing: The Generative Experience, and Your Plan](https://hamedtaheri.com/handbook/md/closing.md): Where is this going, what will still be true when it gets there, and what do I do on Monday?

### Playbooks

- [Marketing: Inbound and the Website](https://hamedtaheri.com/handbook/md/inbound-and-the-website.md): They came to us. What should they see and receive next?
- [Marketing: Accounts, Ads and Events](https://hamedtaheri.com/handbook/md/accounts-ads-and-events.md): We chose them. How do we reach them as individuals?
- [Marketing: The Physical Channel](https://hamedtaheri.com/handbook/md/the-physical-channel.md): When each touch costs real money, who deserves one and what should it say?
- [Sales: New Customers](https://hamedtaheri.com/handbook/md/new-customers.md): How do we open a relationship without sounding like every other AI message?
- [Sales: Growth and Return](https://hamedtaheri.com/handbook/md/growth-and-return.md): What do we already know, and how do we use it to go deeper or win them back?
- [Customer success: Customer Success](https://hamedtaheri.com/handbook/md/customer-success.md): How does customer success personalize onboarding, adoption and renewal for each account and each user?
- [Support: Support](https://hamedtaheri.com/handbook/md/support.md): How do we stop asking customers what we already know?
- [Product: Product](https://hamedtaheri.com/handbook/md/product.md): How does the product adapt to each user, and what does the team learn?
- [Software: Software Companies](https://hamedtaheri.com/handbook/md/software-companies.md): How does a software company personalize when its richest signal is how people use the product?
- [Research: Research and Strategy](https://hamedtaheri.com/handbook/md/research-and-strategy.md): How does understanding individuals roll up into strategy?
- [Across teams: One Customer, One Conversation](https://hamedtaheri.com/handbook/md/one-customer-one-conversation.md): How do we stop marketing, sales, support, product, and our agents from contradicting each other, or exhausting the same person?

## The 20× Developer Playbook

My experience building and using AI agent systems with Claude Code, Codex, and governed team memory to work toward 20× software delivery capacity per developer. The implemented systems connect Personize team memory, preparation, execution, review and accounting. October 2026 is the benchmark month, a measure of how far the system can be pushed rather than a monthly run-rate: 2,155 merged PRs, 16× DX's Q1 2026 median for daily Cursor users at September's PR size (119× as counted, not used). That is PR volume against a dated cohort, not productivity; activity per calendar day ran about 3× the April–September average. 20× targets comparable accepted parent tasks per developer-week; acceptance and human effort are not established yet. Preserve dated earlier studies and the Agentic Kanban working draft for onboarding and community trials.

- [AI starting guide](https://hamedtaheri.com/playbook/latest/agent/start.md): start here (always the latest release); routes by role (CTO, PM, tech lead, developer) and says how to answer
- [The short version](https://hamedtaheri.com/playbook/v0.2.0/summary.md): seven practical lessons, scoped results and a prompt to try it
- [The full playbook](https://hamedtaheri.com/playbook/v0.2.0/playbook.md): seven sections plus glossary and limits
- [Team Memory: governed operational memory](https://hamedtaheri.com/playbook/v0.2.0/reference/operational-memory.md): memory around entities, events, decisions and ongoing work; distinguish purpose from duration, selective sharing from action authority, and positioning from novelty claims
- [Agentic Kanban working draft](https://hamedtaheri.com/playbook/v0.2.0/framework/summary.md): the evolving practice for onboarding developers and coordinating people and agents
- [Agentic Kanban AI guide](https://hamedtaheri.com/playbook/v0.2.0/agent/framework.md): how an AI applies the framework, with the machine-readable contract
- [FAQ](https://hamedtaheri.com/playbook/v0.2.0/agent/faq.md): direct answers on results, method, fit, security and access
- [Pilot guide](https://hamedtaheri.com/playbook/v0.2.0/agent/pilot.md): test three tasks with an agreed total budget covering review and retries
- [Build or use](https://hamedtaheri.com/playbook/v0.2.0/agent/build-or-use.md): how to hold shared memory for a team of agents, with criteria
- [Evidence and limits](https://hamedtaheri.com/playbook/v0.2.0/evidence/README.md): how every number was counted
- [Measured results and why 20×](https://hamedtaheri.com/20x-developer-playbook/metrics/): calculated metrics, denominators, proxies, data gaps and title explanation

## Writing

- [One Developer, About 16× the Benchmark: How I Normalized October](https://hamedtaheri.com/articles/one-developer-16x-the-benchmark/): In October my account merged 2,155 pull requests: 119× DX's median for developers who use Cursor every day. I didn't trust that number, so I tried to shrink it. Normalized for PR size two different ways, it lands at about 16×. The film, the method, and what the number does not mean.
- [Agent-Run Customer Success: How We Make It Work](https://hamedtaheri.com/articles/agent-run-customer-success/): How we turn client emails, API tickets, and monitoring alerts into coordinated action, verified resolutions, and client reports, using agents, runbooks, scripts, and bounded recovery.
- [Ten Layers Between a Question and Its Context: Anatomy of a Unified Retrieve Call](https://hamedtaheri.com/articles/anatomy-of-a-retrieve-call/): When an agent asks one question about one customer, the vector search is only one of ten layers that decide what it gets back. Most of the quality lives in the layers around it: identity, section selection, access control, one shared budget, and what happens when a step fails. A walk through a production retrieve call, the thresholds we tuned, and five ways it was silently losing evidence.
- [How I Build an Enterprise Personalization Engine That Can Be Trusted at Scale](https://hamedtaheri.com/articles/building-enterprise-personalization-engine/): A production personalization engine is not a prompt that writes custom copy. It is a governed system that resolves identity, builds trusted context, decomposes content into specialized jobs, generates across channels, validates every important boundary, recovers failed work, and learns from real populations under human supervision. This is the architecture I use.
- [The Model Is Not the System: How I Build Enterprise AI That Can Fail Safely](https://hamedtaheri.com/articles/the-model-is-not-the-system/): Enterprise AI fails in layers: bad inputs, wrong identity, hallucinated facts, malformed output, lost delivery, silent backlogs, and weak operating decisions. This is the defense-in-depth architecture I use to make generative systems observable, recoverable, human-supervised, and safe to improve over time.
- [Enterprise-grade accurate personalization at scale](https://hamedtaheri.com/articles/accurate-personalization-at-scale/): Accurate personalization at scale is an architecture, not a prompt. Built on governed memory as the single source of truth, it enriches and cross-validates what you know, breaks the work into specialized zones tuned across many records, and wraps the model in deterministic guardrails and self-review, so every claim is either specific and true, or honestly general. Here is the framework, and why it holds at enterprise scale.
- [Trust Is the New Payload](https://hamedtaheri.com/articles/trust-is-the-new-payload/): CrowdStrike's 2026 report says 82% of attacks now carry no malware and calls the pattern 'trust exploitation.' The number is real and the label is too small. What the telemetry is measuring is personalization: a machine that models a human and acts on the model faster than anyone can check.
- [Agentjacking: When Read Access Quietly Became Execute Access](https://hamedtaheri.com/articles/agentjacking-read-and-execute/): A public error-reporting key, a fake bug report, and a coding agent that runs the attacker's code with your credentials. Agentjacking is not a Sentry bug. It is proof that 'read this' and 'act on what you read' have fused into one permission, and almost no one is looking at the gap.
- [Why Coding Agents Forget, and What a Real Memory Layer Must Do](https://hamedtaheri.com/articles/why-coding-agents-forget/): Your coding agent does not remember your codebase; it re-perceives it every session, greps and reads its way back to a mental model, then throws that model away. That re-perception is a line item, and the fix is not a bigger context window. It is a persistent, governed model of the codebase the agent writes to and reads from under a budget.
- [Modeling the World for Agents](https://hamedtaheri.com/articles/modeling-the-world-for-agents/): There is a new modeling discipline emerging, the way relational schema design emerged in the 1970s. This time the reader is a stochastic model with an expensive context window, and the objective flips from saving bytes to maximizing signal per token.
- [Wiki Memory Is the Right Idea. A Person Is Not a Codebase.](https://hamedtaheri.com/articles/wiki-memory-person-is-not-a-codebase/): LangChain's wiki-memory pattern validates the core lesson of agent memory: synthesize at write time, don't rediscover structure at query time. It also names its own limit. The moment the wiki is about a person, files stop being enough.
- [AI-Native Is Not AI-Enabled](https://hamedtaheri.com/articles/ai-native-is-not-ai-enabled/): The firms getting leverage from AI are not just adding models to existing workflows. They are redesigning the work around what the model can do. That distinction is the whole game.
- [The Lean Agentic Company](https://hamedtaheri.com/articles/the-lean-agentic-company/): AI startups are not just hiring fewer people. They are pointing at a new company shape: smaller teams, flatter coordination, more machine work, and a much higher burden on memory and systems.
- [Why AI ROI Looks Bad Until the Org Changes](https://hamedtaheri.com/articles/why-ai-roi-looks-bad-until-the-org-changes/): AI ROI often looks weak because companies measure tool adoption while leaving the production system untouched. The gains appear when the organization redesigns the workflow, memory, and decision rights around agents.
- [Agents Are Eating the Hour-Long Task](https://hamedtaheri.com/articles/agents-are-eating-the-hour-long-task/): The shift from chatbots to delegated, long-horizon work is already here, and the productivity is real. What the vendor and independent data actually show, and why now is the moment to lean in.
- [Where to Start With Agents](https://hamedtaheri.com/articles/where-to-start-with-agents/): Most agent pilots stall, and the few that pay off share a copyable pattern. A practical on-ramp: which task to pick first, how to set it up so it actually learns your work, and how to get a real result this month.
- [154 subagents: feature or smell?](https://hamedtaheri.com/articles/154-subagents-feature-or-smell/): A curated collection of 154+ specialized Claude Code subagents is impressive and also a tell. Specialization has a coordination cost, and one of the ten categories is managing the other nine.
- [Agents Don't Need Your Database. They Need Your Ontology.](https://hamedtaheri.com/articles/agents-dont-need-your-database-they-need-your-ontology/): The raw schema was built for a query planner, not an agent. In 2026 every major data platform admitted it and shipped the same fix: a semantic layer, and above it, an ontology. Here's the difference, and why it's the whole game.
- [Headroom, and the context window as a budget](https://hamedtaheri.com/articles/headroom-context-window-is-a-budget/): Compressing tool outputs before they reach the model is becoming standard tooling. The interesting part isn't the percentage, it's the shift from treating context as a bucket to treating it as a budget.
- [On-machine vs hosted agents: goose and Foundry answer different questions](https://hamedtaheri.com/articles/on-machine-vs-hosted-agents-goose-foundry/): goose runs on your machine; Microsoft Foundry runs your agent for you. The real axis isn't open vs closed, it's control and locality vs managed scale. Each wins a different job.
- [Portable agent memory is table stakes, not a moat](https://hamedtaheri.com/articles/portable-agent-memory-table-stakes-not-moat/): EverOS carries an agent's memory across Claude Code, Copilot, Gemini, and OpenCode. Portability is the half that's commoditizing. The defensible half is governance, and it's harder.
- [The Retrieval Explosion: The Economics of AI Agents in Your CRM](https://hamedtaheri.com/articles/the-retrieval-explosion/): AI agents now work for hours and make dozens of retrievals per task. As each customer gets worked by tens to hundreds of agents a month, the cost of letting them know your customers scales exponentially — unless a memory layer sits between the agents and your CRM.
- [Agent Spawn: Dispatching Thousands of Subagents in the Database](https://hamedtaheri.com/articles/agent-spawn-subagents-in-the-database/): Every provider now spawns subagents at scale. Spawning was never the hard part. Running the same job correctly and affordably across a hundred thousand database rows is. Here is what changes when the unit of agentic work becomes one subagent per record, grounded in governed memory.
- [Personize Governed Memory vs. the Alternatives](https://hamedtaheri.com/articles/governed-memory-vs-alternatives/): My team asked me to compare Personize against Pinecone, Mem0, Zep, Supermemory, and AWS's native memory. So I wrote the honest version: where each tool is genuinely the right choice, where it stops, and why memory for a fleet of agents over a database of entities is a different problem than memory for a chatbot remembering one user.
- [Who's Running Your CRM: You, Your Agents, or Your Agents' Agents?](https://hamedtaheri.com/articles/whos-running-your-crm-human-human-agent-or-agent-agent/): Three architectures are reshaping revenue operations. A human clicking dashboards. A human directing agents. Agents directing agents. Only the third changes what's possible, and two companies just built the door.
- [From Relational Schemas to a Memory Model for Agents](https://hamedtaheri.com/articles/relational-schemas-to-agent-memory/): A work-in-progress framework. The relational model and entity-relationship design gave software a way to model a world so a machine could use it. Agents need an equivalent, and it is not a table. This is the memory model I have been building toward, in stages, and how it applies to our own engineering team.
- [65% Off Memorization: How Batch APIs and Prompt Caching Change the Cost Per Memory](https://hamedtaheri.com/articles/65-percent-off-memorization/): Provider batch APIs cut LLM extraction cost in half. Prompt caching cuts another fifteen to twenty percent off. Combined, customers who can wait 1-24 hours pay roughly a third of what they would on the sync path. Here is the architecture that makes that discount actually reach the customer, and why writes are the right place to spend the latency budget you saved at retrieval.
- [Agent Dispatch is Live: One Script, Hundreds of Subagents, All Governed](https://hamedtaheri.com/articles/agent-dispatch/): A code-capable agent reads your records, decides what work each one needs, and places hundreds of trigger-bound subagents in a single script run. Some fire now. Some fire when conditions are met. All governed, all observable, all on the same per-minute rate. Here is what we shipped, the use cases we are exploring with early users, and what you already get.
- [Documents Are Memories Too: The Claude-Markdown-File Pattern in a Governed System](https://hamedtaheri.com/articles/documents-are-memories-too/): AI agents need a place to write sectioned markdown notes they can later read, append, or rewrite. The same shape Claude uses for its memory files, but inside a governance and retrieval layer that everything else uses. When to save as a document, how the section-update pattern works, and what flipping the aiExtraction switch does to your modality picture.
- [Instructions, Not Prompts: How We Run 1,000 Agents Per Minute Without the Bill Going Sideways](https://hamedtaheri.com/articles/instructions-not-prompts/): Per-token pricing punishes you for using AI at scale. Per-minute pricing forces you to design agents like production systems. Here is the pattern we converged on, the trade-offs of one big chain versus a forest of small agents, and what changes when the models themselves are designed for workflows.

## Optional

- [About](https://hamedtaheri.com/about/)
- [Papers](https://hamedtaheri.com/papers/)
- [Built](https://hamedtaheri.com/labs/)