Documentation as a foundation for humans and machines
Systematic knowledge work needs a reliable foundation – for humans seeking orientation, and for machines meant to answer questions.
The inside Kompendium grew out of this ambition. It's more than a user manual. It describes the conceptual foundation of inside: target groups, roles, methods, and principles.
The challenge: what's easily readable for humans isn't automatically precise enough for a language model. Vague terms, missing context, and inconsistent structures quickly become blind spots for AI.
That's why we thought about both together: clarity for humans and structure for machines. In the end, that's exactly what made the Kompendium better.
Structure
For the Kompendium to be usable by both humans and AI, it needs a clear internal structure. We settled on two levels:
1. Section types describe the function of a passage. For example: definition, goal, content, impact, or procedure. This makes it clear what job a piece of text performs within the Kompendium.
2. Semantic Groups classify content thematically. They are the thematic coordinates of the Kompendium. These include: Knowledge and Information, Semantic Layer, Governance and Standards, Collaboration and Culture, Impact and Development, and Ecosystem and Roles.
Semantic Groups are more than keywords here. They help place content within the right subject area. For the AI, they're a steering instrument: they help the RAG service search not just anywhere for a given question, but within the right area of knowledge. This creates a knowledge base that isn't just readable, but also machine-evaluable.
Linda: local AI, local knowledge
The first agent built on this foundation is called Linda. She answers questions about inside – exclusively based on the Kompendium.
Linda runs on a local language model. That means: the AI operates on its own infrastructure, without a cloud connection and without training on external data.
What might sound like a limitation at first is a strength for us: Linda only answers with the knowledge we've given her. What isn't in the Kompendium, she doesn't claim.
That builds trust. And it forces us to keep the Kompendium precise, complete, and consistent.
The technical path: from text to answer
The first step was segmenting the content into individual passages. We built a foundational editor for this, with which every entry was split into individual sections.
The idea: each section should answer as close to exactly one question as possible. This creates smaller, clearer units of knowledge.
Embeddings were then generated for these passages.
Embeddings are mathematical representations of text. They translate language into numeric values. This lets a system recognize which content is similar in meaning – even when it doesn't use the same words.
These embeddings live in a vector space.
A vector space is a mathematical space in which similar content sits close together. Content with different meaning sits further apart. This lets the AI find matching building blocks of knowledge.
The RAG service uses this vector space.
RAG stands for Retrieval Augmented Generation. Put simply: the AI doesn't just answer a question out of the language model alone. It first searches for matching content in the knowledge base and uses it as context for the answer.
To make the search work better, intent recognition also comes into play.
Intent recognition means: the system tries to understand what kind of question was asked. Is it a definition? A justification? A procedure? Orientation? The better the intent is recognized, the more precisely the RAG service can select the right passages.
The development was iterative: every improvement to segmentation, semantic groups, thresholds, and intent recognition made Linda's answers more precise.
An important tool here was the vector map. It shows how the content is positioned in semantic space. This made gaps, isolated topics, and missing connections visible.
The dialogue with Claude Code
A large part of the implementation emerged in dialogue with Claude Code.
Claude Code wasn't just a tool for generating code, but a sparring partner: it commented on architectural decisions, suggested alternatives, and helped with debugging.
This work shows how much context an AI needs to be truly useful. And at the same time, it shows how valuable structured knowledge is as input.
Open source: knowledge shared
The project is meant to be released as open source: the Rails app, the embedding service, the RAG service, and the Docker setup.
It's not a finished product, but a tool and a way of thinking.
The central question is: how can an organization prepare its knowledge so that it's usable for both humans and AI agents?
The inside Kompendium is the centerpiece here. It shows: good knowledge work doesn't become less important in the age of AI. It becomes more important.
Linda only answers with what we've given her.
That's not a shortcoming.
It's the standard we hold ourselves to.