Skip to main content

Knowledge Base Overview: Governed Context for Grounded AI Responses

Grounded AI is not just a retrieval problem. It is an operations problem. Teams need a controlled way to decide which documents can influence responses, when new content becomes eligible for runtime use, and how to prove that a model actually relied on approved material. Keeptrusts Knowledge Base is built for that job. It turns reference material into governed assets that move through a lifecycle, bind to agents, and leave behind citations when the gateway uses them.

That matters because most hallucination and compliance failures do not start with a broken model. They start with unmanaged context. A stale refund policy, an unreviewed runbook, or an overly broad prompt attachment can quietly shape production answers. Knowledge Base gives you a stronger control surface than prompt stuffing or informal document upload habits.

Use this page when​

  • You want a practical overview of how Keeptrusts grounds AI responses with governed context.
  • You need to explain Knowledge Base to engineers, reviewers, or platform owners before rollout.
  • You are replacing ad hoc prompt attachments with a versioned and auditable workflow.

Primary audience​

  • Primary: Technical Engineers
  • Secondary: Technical Leaders, knowledge owners, AI operations teams

The problem​

Most organizations start grounding in an unmanaged way. Someone copies a policy excerpt into a system prompt. Another team uploads a document to a separate tool. A third team updates the canonical source in Git or a file workspace, but the assistant keeps answering from an older snippet because nothing in production was actually refreshed.

That creates several predictable failures.

  • The source of truth and the runtime prompt drift apart.
  • Draft content can influence live answers before anyone reviews it.
  • Multiple teams end up grounding the same workflow with different copies of the same document.
  • When an answer is challenged, nobody can prove what source the model used.

Traditional retrieval tools solve only part of that. They may help find relevant text, but they do not necessarily impose a promotion lifecycle, preserve immutable versions, or restrict which agent can use which asset. They also do not always produce a clear audit trail for downstream review.

Keeptrusts treats the context itself as a governed asset. That is the key design choice. Instead of asking, “Can the model search our documents?” you ask, “Which approved version of which asset was allowed to influence this response, and can we prove it?”

The solution​

Knowledge Base stores reference material as org-owned, ABAC-controlled assets that the gateway can recall at runtime. Assets can be created as static, upload, git_sync, or learned_session content. Each asset has immutable versions, a lifecycle, and an explicit relationship to the agent that is allowed to use it.

In the documented workflow, assets start in draft, can move through reviewed, become active, and eventually end in archived. Only active assets with an agent binding are eligible for gateway recall. That single rule is what keeps the feature governable. Content exists in the system long before it is eligible to shape model output.

Knowledge Base also connects authoring, runtime use, and verification:

  • Authors create or update the asset.
  • Reviewers promote only the versions that should be live.
  • Operators bind approved assets to the right agent.
  • The gateway recalls those assets during request handling.
  • Citations are recorded in History and Events when the asset is used.

The feature is broader than a single upload form. The console Knowledge Base workspace supports file-based organization, preview and provenance details, and folder sharing for collaboration. In the chat workbench, Keeptrusts can suggest relevant active assets while a user is composing a message, and users can pin a suggested asset into the next request. That gives teams a practical balance between managed defaults and explicit operator intent.

Implementation​

The cleanest rollout is to start with one high-value knowledge asset and wire it end to end.

# Create an asset from approved content
kt kb create \
  --name "refund-playbook" \
  --scope org \
  --kind static

# Upload or sync the content into the asset
kt kb sync --source ./knowledge/refund-playbook/ --asset-id kb_refund_playbook

# Promote the reviewed version so it can be recalled
kt kb promote --id kb_refund_playbook --to active

# Bind the active asset to the support agent
kt kb bind --id kb_refund_playbook --target-type agent --target-id agent_support_prod

After the asset is active and bound, send a representative request through the gateway path that uses that agent. Then inspect the result in History or Events to confirm the citation record is present. This is the important point: success is not only that the answer looks better. Success is that the answer is better and its source is traceable.

For larger estates, combine the same flow with git_sync or local mining and upload. For conversation-derived knowledge, Keeptrusts can also create learned_session assets from history, which then follow the same promotion and binding rules before they are allowed into production recall.

Results and impact​

When teams adopt Knowledge Base as their grounding layer, the immediate improvement is answer quality. The more durable improvement is operational control. Engineers can update source content without guessing which hidden prompt fragment also needs editing. Reviewers can stop a draft from becoming production context. Leaders can ask why an answer happened and get evidence instead of inference.

The feature also simplifies collaboration. Product documentation, compliance guidance, support policies, and learned operational knowledge no longer live in separate grounding mechanisms. They all become assets that share the same structure: versioned, promoted, bound, recalled, and cited.

This is what makes grounded AI sustainable. You are not relying on model memory or prompt folklore. You are operating a governed context system.

Key takeaways​

  • Keeptrusts Knowledge Base turns reference material into versioned runtime assets, not informal prompt text.
  • Only active assets with an agent binding are eligible for gateway recall.
  • Suggestions, pinning, citations, and immutable versions make grounding observable instead of opaque.
  • The same lifecycle works for manually curated content, uploaded files, Git-synced material, and learned session outputs.
  • Grounded AI becomes easier to review, safer to update, and easier to explain to auditors.

Next steps​