Context debt, and how Forge handles it
· Prabhu Eshwarla
Why an AI assistant is only as trustworthy as the documents underneath it, and how Forge keeps those documents honest.
What is context debt
Every organisation runs on a pile of written knowledge. Standard procedures, policies, org charts, spec sheets, past decisions. Over time, a gap opens between what those documents say and what is actually true today. A procedure gets superseded but the old version stays in the folder. A policy is quietly dropped but never removed. An org chart still lists three people who left two years ago.
That gap is context debt: the accumulated distance between your recorded knowledge and your real, current operation. Like financial debt, it builds quietly and you usually discover it at the worst possible moment, when someone acts on information that was true once and is not true now.
Most organisations never see the full size of it, because the debt is invisible until something goes wrong. Nobody reads the whole document set. People rely on the few files they know are current and mentally route around the rest. The knowledge that matters lives in a handful of experienced heads, and the written record slowly drifts out of date underneath everyone.
Why context debt is dangerous with AI
An AI assistant changes the stakes. The whole promise of a grounded assistant like Forge is that it answers from your own documents rather than making things up. That is the right design. But it has a sharp edge: if the documents themselves are wrong, a grounded answer is not safe, it is confidently wrong.
A confidently wrong answer with a citation is worse than an obvious guess, because the citation makes it look trustworthy. If an assistant answers from a procedure that was retired last year, and shows you the source, a person is more likely to act on it, not less. So for any assistant that grounds its answers in your material, context debt is not a minor data-hygiene issue. It is the thing that decides whether the assistant can be trusted at all.
How Forge thinks about it
Forge starts from one principle: it does not decide what is current. Deciding whether a document still reflects reality is a judgment that belongs to the person who owns that area of the business, not to a model. What Forge does is make that judgment small, fast, and timely, so the people who own the knowledge can keep it honest without it becoming a second job.
The claim we hold ourselves to is simple: Forge will not answer from a document until someone who owns it has confirmed it is still true, and Forge makes confirming a thousand documents a one-hour task rather than a week of work. We do not claim to keep your knowledge current automatically. We make it easy for your own people to.
Standing it up: reviewing what you already have
When you first bring your documents into Forge, the goal is not to trust everything by default and hope for the best. It is to turn a large, unread pile into a short list of decisions for the right people. Forge does this in a few steps, and only the last one needs a human.
It sets aside the obviously old
You choose a cutoff, and anything older is quarantined: kept and searchable, but held back from answers until a person clears it. Old is not the same as wrong, so nothing is deleted. A ten-year-old safety standard may still be law. But the default flips from trusted to please confirm.
It groups related documents together
Rather than asking anyone to review a thousand files one by one, Forge groups them by topic and area, so a reviewer sees categories instead. Forty documents about one procedure, a dozen about another. People confirm a category in seconds, which is what makes the whole review survivable.
It flags where documents disagree
Within each group, Forge looks for contradictions, the tell-tale sign of context debt, where an old and a new version of the same thing both still exist. It does not decide which is right. It surfaces the disagreement and points it at a person.
It routes each group to the person who owns it
Each area goes to the person responsible for it, who confirms it is current, marks it outdated, or flags it for editing. Once confirmed, the document goes live with a note of who reviewed it and when, which becomes useful provenance later.
1,000 docs uploaded
-> Date quarantine (deterministic rule)
older than cutoff -> Quarantined (excluded from answers, still needs a human)
within window -> Cluster by topic / dept (embeddings, cheap)
-> Conflict scan within clusters (LLM)
-> Route clusters to owners (ownership map)
-> Human review: confirm / outdated / edit
confirm current -> Live in knowledge base + reviewed-on stamp
mark outdated -> Marked outdated (kept, not answered from)
Bringing existing documents in: the old is set aside, the rest is grouped and confirmed by its owner before anything goes live.
Keeping it clean as things change
A one-time clean-up is only half the answer. Documents keep changing, and context debt does not stop arriving. New versions land, policies get updated, procedures get revised. If each change were treated as a fresh pile to review from scratch, the effort would never end and people would stop responding. So Forge treats ongoing change differently from the initial load.
New documents are checked against what you already have
When a document arrives, Forge compares it to the knowledge already in place, not just to the other new arrivals. An updated policy most often conflicts with the older policy already live, so that is exactly where Forge looks.
New versions replace old ones, they do not pile up
Most updates are new versions of something you already have. Forge recognises when a document is a newer version of an existing one, and when its owner confirms the new version, the old one is retired. This is what stops updates from quietly adding to the debt instead of clearing it. As always, Forge proposes the retirement and the owner approves it.
Review becomes a light, regular touch
Instead of an occasional overwhelming review, owners get a small, steady stream: a few documents changed in your area this week, confirm or flag. Each decision takes seconds, and the knowledge base stays current as a matter of routine rather than a periodic scramble.
New docs arrive (200, then a trickle)
-> Date quarantine (rule)
older than cutoff -> Quarantined (excluded until cleared)
within window -> Match against existing corpus (nearest cluster)
-> new topic -> Conflict scan: new doc vs its existing cluster (LLM)
found near-match -> Supersession check: is this a new version of a live doc?
-> Human review (trickle): "a few docs changed in your area"
confirm current -> New doc live + reviewed-on stamp
approve supersession -> Old version retired (kept, not answered from)
As documents change: new arrivals are checked against existing knowledge, superseded versions are retired on approval, and review stays a light regular touch.
What you get
- Answers you can trust. Forge does not answer from a document until an owner has confirmed it, so grounded answers stay genuinely reliable.
- Debt that clears instead of growing. Superseding old versions on update means the knowledge base gets cleaner over time, not messier.
- Judgment stays with your people. Forge surfaces what needs attention and routes it to the right owner. It never overrules a person on what is true.
- A visible record. Every document carries who confirmed it and when, so you can always see how current your knowledge really is.
In one line. Context debt is the gap between what your documents say and what is actually true. Forge does not pretend to close that gap on its own. It makes the gap visible, keeps unconfirmed knowledge out of its answers, and makes it easy for the people who own the knowledge to keep it honest, both when you start and as things change.
