one of my favorite things to do with claude code, apart from letting it quietly do my actual job, is deep research. and the thing i research most is founders.
founder stories are everywhere and nowhere.
some live on podcasts, some in a linkedin post from 2019, some buried in a biography nobody finished.
to actually understand how naval ravikant or tobi lütke got from nothing to where they landed, you have to assemble the story yourself, across a dozen tabs.
the bottleneck was never the source material, it was my own attention spread thin.
so i built a pipeline that assembles it for me. one command in, one coherent story out, with a visualized timeline at the end.
btw if you're a founder, drop your name below and i'll send you yours. it beats your wikipedia page, i promise.
how it actually works
the workflow is straightforward:
i say: yo claude, research naval ravikant.
claude first makes sure it knows which naval we mean, and asks if it doesn't. then it starts spawning agents.
four websearch agents go out in parallel, each with its own beat: wiki, biographies, news, social. i get noticeably better results pointing them at the parallel.ai mcp instead of the built-in websearch tool. each one writes its findings to files/{founder}/source\_research.
full workflow: https://younesaeo.com/research
four analysis agents pick up those findings, cross-check references against each other, and each owns one aspect of the life: financials, personal development, career. they write to files/{founder}/analysis.
a context enhancer agent reads the analysis and layers historical, cultural, and economic context onto the significant events, so a funding round in 2008 reads against 2008. that goes to files/{founder}/enhancement.
an integration agent then structures everything into one chronological timeline, clustered into life phases, which quietly makes the next agent's job easier.
full workflow: https://younesaeo.com/research
a visualization planner reads the integrated timeline, splits it by life phase, and writes a plan for how to orchestrate the image generation. claude spawns as many image generator agents as that plan calls for (generally 2 to 6 frames) handing each one its own list of events.
claude can't generate images natively, so i wrote a small image-generation skill that calls the ai sdk under the hood with whatever model you prefer. gemini and gpt image work best. if you'd rather skip the skill and the scaffolding entirely, you can point it at the higgsfield mcp instead.
images generated, timeline built. last step: an executive report that pulls it all together into a plausible, readable story of the founder, illustrated by the timeline.
full workflow: https://younesaeo.com/research
three primitives, any harness
strip the pipeline down and there are only three things in it: subagents, mcps, and skills. that's the whole toolkit for a deep research agent. and because all three are general standards, none of this is married to claude code. the same workflow runs on codex, openclaw, hermes, cursor, or whatever agent is trending next month.
why subagents, not skills
my pipeline has fourteen subagents in it. they do almost all of the heavy lifting.
that might read as a strange choice, because in theory you could run the exact same workflow out of the most hyped word of the last six months: skills. i don't, for two reasons.
the first is context flooding:
when claude activates a skill, every token that skill generates stays in claude's context for the rest of the session.
the window grows and grows, and a model with a bloated window gets dumber, loses the thread of the original task, and starts leaving work unfinished.
a subagent has its own isolated context that never leaks back. a skill is not a free helper, it is a tax you pay in context on every token it emits.
that's what lets the main agent stay an orchestrator instead of a researcher, keep track of the whole process, and hand off the final output without rotting its own window.
the second is parallelism:
whole stretches of this workflow are completely parallel (websearch, analysis, image generation). skills can't run side by side. subagents can.
the right model for the right agent
an isolated context is only half of what a subagent buys you.
the other half is that each one is a place to pick the cheapest model that can actually do the job. so i match the model to the task.
the websearch agents run on haiku.
it's fast and cheap, and because it's working from factual data that search hands it, it's far less likely to hallucinate, which is usually the risk with small models when you leave them to reason on their own.
grounded in search results, haiku is plenty.
the analysis and integration agents run on sonnet. its reasoning is close to opus, but it's quick enough that i can fan out seven of them at once without the pipeline crawling, which is exactly what running them on opus would do.
the final report runs on opus. it's the best creative writer of the three, and the report's whole job is to read like a well-told story about the founder, not a data dump. that's the one place i'll happily pay for the slowest, smartest model.
dreaming is the next layer
the workflow i just described is static. the subagents don't learn and the skills don't sharpen.
ship a bug in the visualization planner and it ships in every run after that, silently, until you happen to notice it yourself.
anthropic's managed agents has a feature called dreams.
the rough idea: an agent reads a batch of past sessions, finds the failure patterns that keep repeating, and proposes fixes.
you can run the same loop on the primitive side. a meta-skill that:
- reads the session transcripts from your last n runs.
- clusters the failures by which subagent owned them.
- reasons about whether the cause was the prompt, the tool list, or the model choice.
- proposes a concrete edit to the offending markdown file.
the part that breaks
that last section is still an idea. everything in the pipeline above has 120 runs behind it.
dreaming has a workshop and a docs page.
i'll experiment with it in the upcoming days and probably share my findings in another post.
---
i shared the whole pipeline in a github repository. fork it and run one founder end to end or make it yours and create your own research pipeline about whatever topic you're curious about.
i hope this was helpful, let me know if you have any questions.