Learn more about the following beqom products
Picture a manager staring at a screen during a comp cycle. She types, in plain English: "Why is Marco's merit increase capped this year?"
She wants a clear, correct, defensible answer. Get this right, and HR teams have an agent that can answer questions like this in seconds, at the scale of a workforce spanning continents, holding up to a works council, an auditor, or an employee asking why. Get it wrong, and you're explaining to that auditor why your AI invented a salary band that never existed.
Here's the counterintuitive thing we learned building this for real, at enterprise scale: the most useful AI in a comp platform is the one that never sees the actual data. Not "doesn't store it." Not "isn't supposed to look." Structurally cannot. And far from making it dumber, the blindfold is exactly what makes it trustworthy enough to put in front of HR teams managing pay for hundreds of thousands of people.
Here's why — and why it's a far more interesting engineering problem than "wire up a chatbot."
Why can't you just hand an LLM your compensation data?
Compensation is a stress test for LLM applications, because three independent forces all push against the naive approach at once.
Wall one: regulation. Pay is one of the most scrutinized domains there is — equal pay law, the EU Pay Transparency Directive, internal audit, works councils. "The AI suggested it" is not a defense anyone wants to give under oath. Decisions here need to be explainable, reproducible, and traceable to a formula, not a vibe.
Wall two: context. Even if you wanted to show the model everything, you can't. Shoving 100,000 employees' worth of compensation data into a context window torches your token budget, balloons latency, and loses the model halfway through the thread. A naive "give the LLM all the data" architecture doesn't just leak. It doesn't even work.
Wall three: arithmetic. LLMs cannot reliably do math. Ask one to compute a merit increase across a few business rules and currencies, and you're one plausible-looking hallucination away from telling a manager the wrong number. A single fabricated digit here isn't a demo failure. It's a real person's paycheck.
Three walls, one door: don't give the model the data, and don't let it do the math. That sounds like a crippling restriction. It turns out to be a liberation.
What does it mean for AI to be "exact" if it never sees the numbers?
There are two completely different things people casually call "being right," and a good architecture refuses to let them touch.
- Exactness of reasoning — how to answer the question. Which policy applies, what the cap means, how to walk a manager through the logic, what to show and in what shape. This is language, structure, domain semantics. It is exactly what an LLM is freakishly good at.
- Exactness of computation — what the numbers are. The cap value, the prorated amount, the currency conversion. This is arithmetic and business rules. It is exactly what an LLM is dangerous at.
A naive design fuses these and hopes for the best. A data-blind design splits them by construction: the model owns the reasoning, a deterministic engine owns the numbers, and the two never swap jobs. The model decides how to think about the answer. It never decides what the value is. Once you internalize that line, the whole architecture falls out of it.
This separation isn't new. Hiding data from the planning model traces back to Simon Willison's "dual LLM" pattern; the reasoning-versus-deterministic-execution split has been formalized in the research literature; "don't let the model do the arithmetic" is quietly becoming received wisdom. What's new is making it hold in production, under real authorization, regulation, and payroll, across some of the largest workforces on earth. That's a different problem from proving it on a benchmark.
Where does the blindfold get hard?
It would be selling you a brochure to stop here, so here's where this gets genuinely difficult, because pretending it doesn't is how you lose a technical reader's trust.
Metadata is information. Strip every name and you're still not home. The names of objects, datasets, and analyses you expose can themselves be revealing. The mere existence of a certain analysis can hint at intent. Drawing the line between metadata the model needs to reason and metadata that quietly leaks is ongoing, deliberate work, not a box you tick once.
Even shapes can whisper. Tell the model "this view returned two people" in a compensation context, and you've potentially handed it a re-identification risk: small-population k-anonymity, the classic trap. Structural feedback is powerful precisely because it carries information, and information about very small groups can identify them. We run heuristics that suppress cardinality on the endpoints where this bites, and we're still actively working on it. Anyone who tells you this problem is solved is either not in a regulated domain or not paying attention.
These edges aren't a knock against the approach. They're the point of it: a mature AI system is one that knows exactly where its own boundaries sit. The sophistication isn't in claiming the model can do everything. It's in the precision of what you deliberately don't let it touch.
How beqom builds this, in production
The reflex in agentic AI right now is to measure power by how much you hand the model: more autonomy, more access, more tools, more rope. The data-blind approach points the other way. The agent is more capable, more reliable, more trusted in a room where trust is regulated, precisely because we were ruthless about its degrees of freedom. Constrain what the model is allowed to decide, and you don't weaken it. You aim it. The maturity of an enterprise AI application isn't measured by how much it delegates to the model. It's measured by the sharpness of the line it draws.
This is exactly how the AI agent inside beqom's compensation platform is built. It reasons over your comp policies, your cycle rules, your calibration logic, and never touches a real salary, bonus, or name directly. Every number a manager sees comes from a deterministic engine, traceable back to a formula, running under that manager's own permissions. It's why HR teams can put it in front of live comp cycles at some of the largest organizations on earth, and why it holds up under audit rather than around it.
If you'd like to see how this works in practice, book a demo with our team.
