Inside the Decision Layer: How Kontexity Decides What Deserves Your Attention

Most of what we've written so far has been about why — why product judgment became the scarce resource once AI made execution cheap, why decisions need to be continuous rather than reconstructed every quarter. This post is about how. Not a marketing description of the product, but a look at the actual system underneath it, and why we built it the way we did.

The problem with "connect everything and summarize"

We hear a version of this often enough that it's worth answering properly: why not just connect an LLM to the tools you already use, and prompt it to tell you what matters? We didn't build it that way, and it's worth explaining why.

A single large prompt can produce something that sounds like a decision. It can't reliably show its work, it can't be improved in one place without risking a regression somewhere else, and it can't distinguish between "this seems interesting" and "this is worth interrupting your week for." For a system whose entire job is to be trusted with judgment calls that affect a roadmap, that's not a good enough foundation. A CPO acting on a bad recommendation from a black box doesn't get a second chance to trust it.

So Kontexity is built as a pipeline of 20 specialized agents. A signal doesn't go to one model asked to "tell you what matters." It runs the same five-stage loop — most agents span more than one stage, rather than sitting in a single layer:

Detect — watches connected signal sources (customer conversations, CRM activity, delivery tools, market and competitive moves) for something that changed.

Inform — pulls in the related context around that signal, including signals that arrived days, weeks or months earlier: what's been said before, what's already on the roadmap, what else is connected to it.

Decide — weighs the assembled context against what actually matters right now, and determines whether this rises to something worth a person's attention.

Act — surfaces it, in the right place, with the right framing — a new item in the inbox, a flag on an existing roadmap bet, a note on a decision already in motion.

Explain — attaches the evidence trail, so the recommendation isn't a black box. You can see why the system thinks this matters, not just that it does.

That's slower to build than a single clever prompt, and it was the less exciting engineering decision to make early on. But it means each stage can be tested, measured, and improved independently — and it means every recommendation that reaches you carries its reasoning with it, rather than asking you to trust a conclusion you can't inspect.

Walking a real example through the loop

Here's what that looks like end to end, using a real shape of signal our system surfaces (details anonymized):

A customer — call them Brightline Corp — has an upcoming renewal. Detect notices two things days apart: a support thread where their ops team asks about workflow automation guardrails, and a CRM note flagging the renewal as at-risk pending that capability. Individually, neither is urgent. Inform connects them — pulls in that this maps to a roadmap theme already being discussed, and that the same request has surfaced from another account recently. Decide weighs it: a renewal at risk, tied to a request with cross-account pattern, tied to existing roadmap work — that combination clears the bar for attention. A lone support ticket with no renewal risk and no second account is dropped here; it never reaches the inbox. Act surfaces it as a flagged item against the relevant roadmap theme, not a new unlinked item in a queue. Explain shows exactly why: the renewal note, the support thread, the pattern across accounts — the evidence, not just the conclusion.

That's the difference between a system that tells you something changed, and one that tells you why it's worth deciding something about it.

What's built, and what's still being built

Detect → Inform → Decide → Act is how the system runs today. Explain on the card — the source, the related context, why it cleared the bar — already ships with the recommendation. What we're still building out is the longer memory: whether a past call paid off, so the next one can be sharper.

Why this matters more than it might seem

It's harder to build than a prompt. But every recommendation carries inspectable reasoning — and, over time, memory of whether the last call paid off.