DEV Community: Patrick Bot

Why the AI arms race missed the point, and what we built instead.

Sajjad Heydari — Tue, 17 Feb 2026 15:04:48 +0000

The Model Isn't the Product. The Context Is.

There's a seductive narrative in AI right now. It goes like this: bigger models produce better results. More parameters, more training data, more compute — more intelligence. The logical conclusion is that the companies with the largest models win, and everyone else is just waiting for the next release from OpenAI or Anthropic or Google to make their product incrementally better.

This narrative is wrong. Not because large models don't matter — they do — but because it confuses the engine with the vehicle. The model is the engine. What determines whether you arrive anywhere useful is everything else: the steering, the suspension, the road, and critically, the map.

We learned this the hard way.

The Lossy Compression Problem

Every time a human writes a prompt, they're performing lossy compression. They're taking the full, messy, interconnected reality of what they know — their context, their constraints, their history — and flattening it into a string of text. The model never sees the original signal. It only sees the compressed version.

This is the real bottleneck of AI adoption, and almost nobody talks about it.

Consider a founder trying to decide which feature to build next. The "right" answer depends on which customers are waiting, what the engineering team's capacity looks like, which partnerships are in motion, what the competitive landscape just did, and how all of those things relate to each other. No human can hold all of that in working memory at once. And if they can't hold it, they certainly can't type it into a prompt.

So what happens? They ask the model a simplified question. They get a simplified answer. They walk away thinking AI is "pretty good but not quite there yet." The model was fine. The context was broken.

What If You Fixed the Input Instead of Chasing a Better Engine?

This is the question that led us to build Patrick.

We're a small medtech company. At any given time, we're managing relationships with over 40 organizations across four provinces, tracking 25+ product features in various stages of development, coordinating 120+ tasks across a team of fewer than ten people, maintaining five distinct products, and navigating a regulatory environment that changes faster than we can document it.

That's not a prompt. That's an ecosystem.

No spreadsheet captures it. No CRM models the actual relationships between a customer's stated need, the feature that addresses it, the tasks required to build that feature, and the strategic initiative that justifies the investment. These connections exist — they're just trapped in meeting notes, Slack threads, email chains, and people's heads.

Patrick is a graph-based intelligence layer that makes those connections explicit and queryable. It captures relationships between entities, performs semantic search across them, and is exposed via MCP (Model Context Protocol) so that any LLM can access the full graph through natural conversation.

The key insight: we didn't build a better model. We built better context.

When someone on our team asks "what should we build next?", the answer doesn't come from a model's general knowledge about product strategy. It comes from Patrick traversing actual dependency chains — from customer needs, through feature requirements, down to implementation tasks — and surfacing the highest-ROI path based on real data. The model is the reasoning engine. Patrick is the map.

The Architecture of Context

Patrick's design reflects a simple thesis: the unit of useful knowledge isn't a document or a data point. It's a relationship.

Our graph tracks organizations, products, features, needs, tasks, and prospects — and the edges between them. Yours might look completely different. The specific entities don't matter. What matters is that you're modeling the connections that drive decisions, not just the objects.

An organization has needs. A need requires features. A feature is enabled by tasks. A product has features. These aren't arbitrary associations. They're the actual decision-making structure of a company, made explicit.

This means Patrick can answer questions that no single data source could:

"If we deprecate this feature, which customers are affected and which prospects does that jeopardize?" That's an impact analysis that spans the CRM, the product roadmap, and the sales pipeline simultaneously.

"Which customer needs have no features mapped to them?" That's a coverage gap analysis — unmet requirements hiding in plain sight.

"Who on the team is overloaded, and what would shift if we deprioritized this initiative?" That's a capacity analysis that accounts for actual task ownership and effort estimates, not just calendar slots.

None of these questions require a more powerful model. They require structured context that the model can traverse. The intelligence was always there in the LLM. What was missing was the map.

Why This Matters Beyond Us

The pattern we stumbled into is generalizable. Every organization that uses AI has the same fundamental problem: the context that would make AI useful is scattered, implicit, and relational. The model can reason. It just can't see.

CRMs store customer data but don't model how a customer's needs connect to your product roadmap. Project management tools track tasks but don't link them to strategic initiatives. Business intelligence platforms visualize data but don't capture the why behind decisions. The relationships between these systems — the connective tissue of actual decision-making — lives nowhere.

Patrick is one implementation of a broader idea: the next wave of AI value won't come from bigger models. It will come from structured context layers that give existing models the information they need to reason well.

The companies that figure this out — that invest in the map instead of perpetually upgrading the engine — will extract disproportionate value from AI. The companies that keep waiting for the next model release will keep writing the same underspecified prompts and getting the same mediocre answers.

This Isn't a Replacement. It's a Multiplier.

To be clear: this isn't an argument against any particular approach to AI. If you've built a RAG pipeline, great — it gets better when the retrieval layer understands relationships, not just document similarity. If you're fine-tuning models on domain data, great — that model becomes dramatically more useful when it has structured context to reason over at inference time. If you're running agents with tool access, great — a graph of your actual business state is one of the most powerful tools you can hand them.

The point isn't that existing approaches are wrong. The point is that they're all operating on incomplete context, and the returns from fixing that are larger than the returns from any single model upgrade.

Every approach to AI gets better when the model can see the full picture. Patrick is how we built that picture for ourselves. The specific implementation matters less than the principle: structure your context, and the models you already have become the models you were waiting for.

What We're Building Toward

Patrick started as a scrappy internal tool to help a small team make better decisions. Internally, it's grown into something far more powerful — a full business intelligence layer that touches every decision we make, from which prospect to prioritize to which feature to deprecate to how to prepare for a meeting next Tuesday. It knows our organizations, our pipeline, our strategic initiatives, our capacity constraints, and the thousand invisible threads between them.

We're not releasing all of that. But we are releasing the core of it — a subset that captures the pattern: a graph-based context layer, exposed via MCP, that any team can deploy to give their LLM the structured context it's been missing. Enough to prove the thesis. Enough to build on.

We've detailed the origin story and architecture in a companion post: How We Built Patrick. But the bigger claim here isn't about Patrick specifically. It's about where AI value actually lives.

The model race will continue. Models will get bigger, faster, cheaper. And that's great — a better engine is always welcome. But the teams and organizations that will win with AI are the ones that figure out the context problem first.

Build the map. The engine will follow.

We used Patrick to make Patrick. No this is not another LLM story.

Sajjad Heydari — Thu, 12 Feb 2026 00:21:13 +0000

Well, that’s a partial lie. But let me set the scene.

My colleagues and I are working on our medtech solution. There are only a handful of us, and every iteration of the software, every client interview and every new partnership opens up tens of possible directions.

Should we chase the hospital pilot or the telehealth integration? Do we build the mobile UX first, or lock down compliance? That clinic in Saskatchewan wants something slightly different from the research hospital in Winnipeg - do we fork the roadmap or find the overlap?
We were keeping track of all of this the way most startups do: scattered notes, shared docs, the occasional spreadsheet that someone updates heroically for a week and then abandons. It worked until it didn't. One day we sat down for a strategy meeting and realized we had forty-plus organizations in our orbit, five product lines at various stages, over a hundred open tasks, and no coherent way to see how any of it connected.
So we built Patrick.

What Patrick actually is

Patrick is not a dashboard. It's not a CRM. It's not a project management tool, though it can behave like all three when you need it to.
At its core, Patrick is a structured summary, and a knowledge graph. Patrick doesn’t summarize things for the purpose of getting the word count down or making it faster to read, Patrick summarizes documents with purpose; “how would this task’s development contribute to this initiative?” or “how does this organization’s need justify this development task, and are they aligned with the priorities set in the shareholders meeting?” are just examples of how Patrick looks at things. Concepts connect to each other in meaningful ways, and the connections are the point.

When we ask “what happens if we delay this feature?” Patrick doesn’t just show us a Gantt chart turning red. It traces the impact upstream and downstream, which customer needs go unmet, which prospects are affected, which tasks become orphaned. When we ask “what should we build next?” it doesn’t just sort by priority, it weighs value against effort against risk and tells us where the quick wins are hiding and where the strategic bets live.

The thing that makes it different from a spreadsheet, a Notion board or an Obsidian vault is that Patrick understands relationships.

The problem nobody's talking about

Here's the thing everyone gets wrong about AI tools. The conversation is always about the model. Which one is smarter, which one is faster, which one hallucinates less. But the model isn't the bottleneck anymore. You are.
Or more precisely, what you tell it is.

Think about the last time you asked an LLM to help you make a decision about your business. You probably spent ten minutes writing a prompt that tried to capture the full picture - who your clients are, what you're building, which deals are in play, what's blocking what. You gave it a slice of the truth, and it gave you a confident answer based on that slice. Maybe it was useful. Maybe it missed the thing you forgot to mention.

Now think about the best executive you've ever worked with. When they sit down to think through a problem, they're not working from a prompt they typed in five minutes ago. They're working from a mental model of the entire organization - every relationship, every dependency, every half-finished initiative, every promise made to a client six months ago. That context is what makes their judgment good.

Patrick is that context, externalized and structured so an AI can use it the way a great executive uses institutional memory.

How it actually works

The insight that led to Patrick isn't technical. It's this: the people who get the most out of AI aren't the ones with the best prompts. They're the ones who've figured out how to feed the AI a true and complete picture of their situation.

We studied what those people do. The executives and operators who consistently get strategic value out of LLMs, not just help writing emails. What we found is that they all do some version of the same thing: they maintain structured information about their business and inject it into their conversations with AI. Some do it with elaborate Notion setups. Some do it with custom GPTs stuffed with documents. Most do it badly, or inconsistently, because maintaining that structure by hand is a second job nobody signed up for.

So we took what works and turned it into a system. Patrick gathers information about your organization - your prospects, your products, your team's capacity, your strategic priorities, the relationships between all of it - and structures it into a graph. Then, when you ask a question, the AI doesn't get a cold prompt. It gets the full organizational picture, tuned to the specific question you're asking.

"Should we pursue this partnership?" isn't answered in a vacuum. It's answered in the context of what you're already building, who else needs the same capability, what it would cost, and whether it aligns with the direction you committed to last quarter.

The moment it got recursive

A few months in, Patrick had become the nervous system of our company. Every meeting started with "what does Patrick say?" Every new lead got entered as an organization with needs linked to features. Every week we'd run a portfolio health check and a value analysis.

Then came the question: what should we build next for Patrick itself?
We had ideas. Lots of them. A chatbot interface so non-technical teammates could query it conversationally. Better reporting templates. An evaluation framework for scoring strategic initiatives.

So we did what had become instinct. We opened Patrick, created features for each idea, linked them to the needs they'd serve, estimated the effort, and ran the analysis.

Patrick told us what Patrick needed.

It surfaced that the conversational interface would unlock the most value - not because it was the most technically impressive, but because it would let our CEO and business development lead query the system directly instead of asking me to run it. That single insight reframed our entire roadmap.

Why we're releasing it

We built Patrick for a medtech company of five people managing forty-plus relationships across four provinces. But the problem it solves isn't a medtech problem. It isn't even a startup problem.

Every knowledge worker using AI today is working with the same handicap: the AI is only as good as what you tell it, and nobody has time to tell it everything. Every prompt is a lossy compression of your actual situation. The more complex your work, the more you leave out, and the worse the output gets.

Patrick is soon to be available as a skill on OpenClaw. That means if you're already running an OpenClaw instance - your own AI assistant on your own machine - you can install Patrick and start building a structured picture of your organization that your AI can actually use.
You don't need to be technical. The skill comes with pre-built prompts crafted from patterns we've seen work - the same approaches that successful operators use to get strategic value out of AI, packaged so you don't have to figure them out yourself. Tell Patrick about your business. Feed it your meeting notes, your client list, your product roadmap. It structures it, connects it, and makes it available to your AI so that every question you ask is answered with the full picture.

The result isn't a better chatbot. It's a better-informed one. And the difference between those two things is the difference between an AI that writes nice paragraphs and one that actually helps you think.

What this means for you

If you've ever wished your AI assistant actually understood your business - not in the vague, "I'll pretend I remember" way, but in the "I know your three biggest prospects, what each of them needs, and which of your features satisfies two of them at once" way - that's what Patrick does.
We used it to build a medtech company. Then we used it to build itself. Now we want to see what you build with it.

Patrick is soon to be available as an OpenClaw skill. Install it, teach it your business, and start asking better questions.

https://patrickbot.io