Institutional Knowledge: Grounding an Answer Without Citing It

A while back we shipped inline citations: every answer our agents give can point back to the exact source it came from — a datasheet, a manual, a standards document. In technical industries that traceability isn’t a nicety, it’s the point. “Here’s the answer, and here’s exactly where it’s documented” is a different sentence than “trust me.”

So it’s a little strange to write a post about deliberately not citing a source.

But the two ideas are closer than they look. Once you can attach a citation to a claim, you have to decide, for every source, whether that citation should be shown. And the answer is: not always. Some of the most useful things a team knows aren’t in polished, publishable documentation. They live in support notes, internal write-ups, a Slack thread someone turned into a wiki page, the accumulated tips that make a good sales engineer good. You want the agent to learn from that material. You just don’t want it presented to a customer as if it were the official spec.

We call that institutional knowledge: a source of truth that isn’t official documentation. This post is about the feature we built to support it, and the one distinction underneath it that did most of the work.

The distinction: grounding is not citation

The instinct, when someone says “don’t show this source,” is to keep it out of the agent’s reach entirely. That’s the wrong move. If the content is good enough to improve the answer, you want it in the model’s context. What you don’t want is the attribution.

So the feature rests on splitting one thing most retrieval systems treat as inseparable:

• Grounding — the content reaches the model, shapes the answer, and is checked for faithfulness like any other evidence.
• Citation — the source document is surfaced to the user: a citation badge, a clickable link, a title.

Institutional knowledge keeps the first and drops the second. Concretely, for a source marked institutional:

• Its content does reach the LLM as grounding. Its images still render in the answer.
• Its source document is withheld — no citation entry, and no URL the model could paste as an inline link.

Think of it as a per-source permission split: the agent has retrieval rights over the content, but the user is never shown where it came from.

That framing sounds clean. Making it true across a production agent platform is where the work lives, because “the source document” leaks into an answer through more paths than you’d expect.

Marking a source

The control is deliberately boring. A source is institutional when its configuration carries the tag institutional_knowledge. That’s it. It applies to any source type — a URL list, a Google Drive folder, a SharePoint site — and it takes effect on the very next answer, with no re-ingestion.

Boring is the point. The behavior is opt-in per source and identical to a normal source unless the tag is present, so there’s no new mode to reason about and nothing to break for the sources you don’t tag.

One tag, true at every layer

The tag looks like a one-line change. It wasn’t, and the reason is worth pausing on: a feature like this has to be true at every layer or it isn’t true at all.

The data model needed a place to hold the tag. The API had to actually persist it — and here we found a quiet bug: the dashboard was already sending the tag on save, but the write path silently dropped it before it ever hit storage. You’d set the tag, refresh, and it was gone, with no error to show for it. And then the agent itself had to read the tag at answer time and change its behavior. None of these layers is hard on its own. What’s hard is keeping one small idea consistent as it passes through a schema, an API contract, and an inference-time decision — each of which can drop it on the floor independently.

There’s an ordering to it, too. The write path has to ship before the read path means anything; a tag the agent respects but the API won’t save is just a bug with good intentions. It rhymes with something I wrote about in keeping our MCP server synced with a moving API: the hard part is rarely the idea, it’s keeping the idea consistent across the layers it passes through.

Withholding a source is harder than it sounds

Suppressing a citation is harder than “filter the source out of the citation list,” and the reason is structural. Our agents run in several different modes, and they don’t all assemble citations the same way — a simple question-and-answer flow builds its references differently from a mode where the agent decides for itself when to search and when to pull a document. So there’s no single place you can stamp “don’t cite this.” There are a couple of places, plus a leak that isn’t obvious until you go looking.

The two citation paths were the expected work: in each one, institutional documents get held back from the citable list at the moment references are assembled — but only after they’ve been recorded as grounding evidence. That ordering is the whole point. The document is barred from the citation, and still fully available to the answer and to the faithfulness check.

The leak was the part that’s easy to miss. Dropping a source from the citation list isn’t enough, because the retrieval tools also hand the model the source’s raw URL in their results — and a model that has a URL will happily paste it inline as a link, entirely outside the citation machinery. So the tools had to be taught to withhold the URL for institutional documents while still returning their content and images. Content in, attribution out.

And then there’s the third leak. Suppressing the citation list turns out not to be enough, because the retrieval tools hand the model a per-document result that includes the source url — which the model can paste inline as a markdown link, entirely outside the citation machinery. So the tools scrub it: for institutional docs, they return the title, the content, and the image placeholders, but leave out the URL. Content in, attribution out.

The bug that actually taught us something

In our most agentic mode — the one where the agent decides for itself when to search and when to pull a full document — building this surfaced a bug that had been sitting there quietly for months. It’s the part of the project I’d actually tell a colleague about over coffee.

In that mode, every search result carried a single number. That number did double duty: it was the citation number the user sees, and the handle the agent uses to ask for the document’s full text. One number, two jobs — and for months there was never a reason for those two jobs to disagree.

Institutional knowledge was the reason. An institutional document has no citation number, so it was emitted with no number at all — and with no number, the agent had no handle to pull its full content. The document showed up in search, but the agent couldn’t open it. On a source set where everything is institutional, that meant the “open the full document” tool was quietly dead for the entire conversation.

The fix was to stop making one number do two jobs: give every result a private handle the agent can always use to fetch it, and keep the citation number as a separate thing that only citable results get. Institutional documents became fetchable but not citable — the agent can open them for grounding, it just never gets a number to cite or a link to paste.

The lesson isn’t really about that one mode. When you collapse two concepts into one identifier because they happen to line up today, you’ve written a bug that stays invisible until the day they diverge. Institutional knowledge was that day. Grounding and citation were the two concepts; one overloaded number was the accidental coupling; separating them was the fix. It’s the same “grounding is not citation” split from the top of this post, showing up one layer down in the plumbing.

Fail-safe by construction

One design rule ran through all of this: figuring out which sources are institutional must never break answering. Every mode resolves that set the same way, and the resolution is fail-safe — if anything goes wrong, it returns an empty set and the turn proceeds as normal. The worst case is that a source gets cited when it shouldn’t have been, not that the agent fails to answer. Answering always wins.

The other invariant is that grounding is preserved everywhere. Institutional documents always reach the model, and they always reach the faithfulness check. Suppressing a citation never starves the answer or its evaluation of evidence — it only changes what the user is shown, not what the agent understands.

What we didn’t build (yet)

A few edges worth naming, because scope discipline is part of the story:

• Whole-source granularity. You tag a source, not individual documents. Per-document institutional knowledge is a natural next step, but it’s not here yet.
• New answers only. The behavior applies going forward; it doesn’t retroactively rewrite conversation history.
• The tag is the interface, for now. A dedicated dashboard control is on the way. In the meantime it’s a tag on the source’s configuration — which is exactly why getting the save path right mattered.

The richer model waiting behind all of this is a full display × linkage citation matrix — sources you show but don’t link, link but don’t show, and so on. Institutional knowledge is one important cell of that matrix, shipped first because it’s the one customers kept asking for.

The takeaway

The feature is small from the outside: tag a source, and the agent learns from it without citing it. What made it worth writing about is the distinction it forced us to make sharp. Grounding and citation are different permissions, and a good retrieval system should be able to grant one without the other.

Most systems couple them by default — you cite what you retrieve — and the coupling is invisible right up until you need it not to be. For us it showed up twice: once as a product feature (know-how that should inform answers without being surfaced), and once as a bug buried in a single overloaded integer. Same distinction, two very different places.

If you’ve got a body of internal knowledge that’s too good to ignore but not ready to publish, that’s exactly what this is for. Talk to us — we’ll help you put it to work.