I run about 40 agents right now. Two of them know everything about me.
The other 38 run lean.
This is not an accident. It’s how I think about building a stack of agents that actually works — not just technically, but practically. Over time. At scale.
Here’s the framework I’ve landed on.
Meet Teddy and Veto
My two most important agents have names.
Teddy is my executive assistant. He handles scheduling coordination, inbox triage, meeting prep, and a dozen other things that used to eat my mornings. Veto is my task backlog clearer — he processes the queue of things I’ve accumulated and helps me decide what to actually do about each one.
Both of these agents run every single day. Both of them touch work that is high-stakes and deeply personal. If either one messes up, I feel it immediately.
So when I built them, I gave them everything. A 20-page context profile: how I think, how I communicate, what my businesses are doing, what my priorities are, who the key people in my life are, how I make decisions. The same document I use to onboard a real assistant, but this one gets loaded into an AI agent.
Loading that document costs tokens. But for Teddy and Veto, it’s completely worth it.
Why the Other 38 Run Lean
The natural question: if context makes agents smarter, why not give it to everyone?
Simple. Context costs tokens. Tokens cost money. And most agents just don’t need it.
My email sorter doesn’t need to know my 5-year plan. My social media scheduler doesn’t need my sleep patterns. My invoice processor doesn’t need my communication philosophy. Each of these agents has one job. Clear, specific instructions are enough. Loading a 20-page profile into them would be expensive and mostly irrelevant.
There’s also a more subtle reason: when an agent gets too much irrelevant context, it sometimes starts making judgment calls it shouldn’t. Specialized agents work better when they stay specialized.
The concept at play here is what I’d call centralized context — the idea that you do want shared, durable memory in your agent stack, but you have to be deliberate about which agents get access to which parts of it. Not every agent needs the same truth.
The Two Mistakes Most People Make
When I talk to people who are starting to build agent stacks, I usually see one of two patterns.
The first: they give everything to everyone. They load their full context profile into every agent they build, because more context seems like it should be better. The result is high token costs and agents that sometimes behave strangely because they’re reasoning from irrelevant information.
The second: they give nothing to anyone. Their agents run with no persistent context at all. Every conversation starts from zero. The agents feel generic, impersonal, and keep asking the same questions over and over.
The better path is just prioritization. Figure out which agents carry the most weight in your day — the ones where a mistake is costly and where personalization actually matters. Build those out properly. Give them memory. Give them context. Give them everything.
For everything else, keep it simple.
This is basically the 80-20 principle applied to agent building: invest the most in the agents you rely on most, and keep your specialized, single-task agents lean and fast.
One More Layer: The Monitor Agents
Here’s something I added that most people don’t think about until they need it.
Both Teddy and Veto have a monitor agent watching them. A lightweight agent whose only job is to check whether the primary agent completed its task. If something fails — for any reason — the monitor agent immediately sends me a Slack message.
I’ll be honest: I’m a bit of a control freak about this. When your executive assistant is handling mission-critical work, you need to know immediately if something breaks. You can’t find out three hours later when you’re wondering why no one responded to your morning emails.
The setup is simple. In Lindy, you create a second agent with a trigger that fires when the primary agent’s task doesn’t complete as expected. You connect it to Slack (or email, or SMS — whatever you’d actually see immediately). Takes maybe 15 minutes to set up.
The peace of mind is real. I know my stack is running because I’d hear about it if it wasn’t.
How to Apply This to Your Own Stack
If you’re building agents or thinking about building them, here’s the mental model I’d suggest:
First, list every agent you have or want to build. For each one, ask two questions: How often does it run? How bad is it if it messes up?
The agents that run every day and where mistakes matter — those are your Teddy and Veto. Invest in those. Give them context. Give them memory. Set up monitoring.
Everything else? Start simple. You can always add context later. It’s much easier to add than to clean up a mess caused by an agent that was reasoning from irrelevant information.
One last thing: name your important agents. It sounds silly, but it changes how you think about them. Teddy and Veto feel like parts of my team. That makes me more likely to invest in building them well, and more likely to notice when something feels off about how they’re working.
It’s a small thing. But so is the difference between a generic AI chatbot and an agent that actually knows you.
Thanh Pham is the founder of Asian Efficiency. He teaches AI fluency through workshops and the 4-Day AI Sprint — designed to take people from occasional AI use to real, running workflows.
