For many years, organizations have relied on large documentation platforms to manage internal knowledge. Tools such as Confluence became the default location for everything from architecture documentation and operational runbooks to meeting notes and project knowledge.

However, as documentation grows, organizations often encounter the same challenges: information becomes fragmented, documents become difficult to locate, and valuable knowledge ends up scattered across multiple systems.

At the same time, advances in artificial intelligence have opened a new possibility: AI-assisted knowledge discovery.

Rather than storing everything in a single platform, many teams are now exploring how multiple specialized systems can be connected and made searchable through AI.

This approach creates a modular knowledge architecture where documentation, code, and files remain in their natural environments while AI provides a unified search interface.

The Core Idea

Instead of relying on one monolithic documentation system, knowledge can be distributed across several tools that each serve a specific purpose.

For example:

• a knowledge base for structured documentation
• a code repository for technical material
• a collaboration platform for files and documents

An AI assistant can then search across all of these sources using Retrieval Augmented Generation (RAG) and present relevant answers to users.

Conceptually, the architecture looks like this:

Users interact with an AI assistant, which retrieves information from multiple systems and generates responses based on internal documentation.

Typical components might include:

• BookStack for structured documentation (European alternative: XWiki, developed by a French company; strong enterprise wiki option)
• GitHub for code and technical documentation (European/self-hosted alternative: Gitea or GitLab CE; using GitHub is typically not a major concern if repositories are public documentation or contain non-sensitive material)
• Nextcloud for file storage and collaboration (European project headquartered in Germany, making it a strong option for organizations concerned about data sovereignty)
• AI models and vector search to enable semantic search across documentation

Together, these systems form a flexible knowledge ecosystem.

Structured Knowledge: The Documentation Layer

Structured documentation works best in a dedicated knowledge platform.

Tools such as BookStack provide a clear hierarchy for organizing knowledge:

Shelf → Book → Chapter → Page

For example:

Shelf: AI Strategy
Book: AI Governance
Chapters: Risk, Compliance, Model Lifecycle

Shelf: Application Management
Book: Robotics
Book: Incident Management
Book: Operational Runbooks

This structure makes it easy to maintain documentation such as:

• architecture overviews
• governance frameworks
• operational procedures
• onboarding documentation
• internal standards

BookStack is lightweight and easy to maintain. However, if an organization prefers a clearly European vendor ecosystem, XWiki is a strong alternative with enterprise-grade capabilities.

Technical Documentation and Code

Technical documentation often evolves alongside the codebase.

For this reason, many teams keep technical documentation directly in their code repositories.

A typical repository structure might look like:

/docs
architecture.md
ai-agent-architecture.md
sdlc-process.md

/src
/scripts
/config

This approach, often referred to as “documentation as code”, offers several benefits:

• version control
• transparent change history
• collaboration via pull requests
• easy automation through CI/CD pipelines

Many organizations use GitHub for this purpose (European/self-hosted alternatives include Gitea or GitLab CE; GitHub is often considered acceptable if repositories do not contain sensitive operational data and the organization values its ecosystem and developer tooling).

Files and Collaboration

Not all knowledge belongs in documentation pages.

Presentations, diagrams, spreadsheets, datasets, and reports still play an important role in everyday work.

A file collaboration platform such as Nextcloud works well for storing and sharing this type of content.

Typical folders might include:

AI
presentations
diagrams
datasets

Projects
project documents
meeting notes

Nextcloud is particularly interesting because it is an open-source platform developed in Europe and can be self-hosted, allowing organizations to maintain full control over their data.

For document editing within Nextcloud, tools such as Collabora Online (European alternative: ONLYOFFICE, developed by a company based in Latvia; Collabora itself is UK-based but widely used in sovereignty-focused deployments) can be integrated.

The AI Layer: Retrieval Augmented Generation

The key component that ties everything together is the AI search layer.

Using Retrieval Augmented Generation (RAG), an AI assistant can index content from multiple sources such as:

• documentation pages
• repository documentation
• file storage systems

When a user asks a question, the process typically works as follows:

1. The question is converted into a vector representation.
2. A vector database retrieves relevant documents.
3. These documents are provided as context to a language model.
4. The AI generates a response based on the retrieved information.

This approach allows the AI to answer questions using internal knowledge rather than general internet content.

A typical vector database might be Qdrant (European company based in Germany) or Weaviate (European alternative founded in the Netherlands).

Language Models

The language model itself can be chosen depending on organizational requirements.

Some organizations use OpenAI models (European alternatives include Mistral AI, based in France, or open models such as Llama; OpenAI is often acceptable for experimentation or non-sensitive use cases due to its maturity and ecosystem).

In environments with stronger sovereignty requirements, models can also be self-hosted.

Identity and Access

In larger environments, it is common to integrate identity and authentication services.

Typical solutions include:

• Keycloak (open-source identity platform originally developed in Europe)
• ZITADEL (Swiss identity platform with strong focus on modern identity architecture)

These systems support standard protocols such as OIDC and SAML, enabling secure integration across all components in the architecture.

The Result: A Unified Knowledge Interface

The result of this architecture is a knowledge environment where AI acts as the primary interface.

Instead of manually navigating different systems, users can simply ask questions.

The AI assistant retrieves relevant information from documentation, repositories, and file systems and presents the answer in context.

This approach offers several advantages:

• modular architecture
• flexibility in tool selection
• strong data ownership
• easier knowledge discovery
• reduced dependency on single-vendor platforms

Knowledge Management in the Age of AI

We are still early in the transition toward AI-assisted knowledge systems.

However, a clear pattern is emerging.

Modern knowledge architectures increasingly combine:

Knowledge Bases
+
Documentation as Code
+
AI-Powered Search

Traditional documentation platforms are not disappearing, but they are being complemented by a new layer: AI that helps people find and understand knowledge across systems.

In the long run, the way we interact with documentation may change significantly.

Instead of browsing through pages and folders, we will increasingly ask questions and let AI guide us to the answers.

The post Building an AI-Searchable Knowledge Platform appeared first on [x]olsen.

One of those completely ordinary grey Tuesdays happened.

You know the kind.

You wake up.
You look outside.
The sky is grey.
You open your laptop.
The news feed is full of two things:

• companies rolling back remote work in the name of “culture” and “innovation”
• AI supposedly replacing half the workforce within the next five minutes.

At that exact moment I had to go to the office.

And I had a very practical question.

Where should I sit today?

Normally the answer is simple:

• sit where you always sit
• grab the nearest free desk
• or walk around awkwardly pretending to look for someone.

Instead, a slightly absurd idea appeared in my head:

What if an AI agent decided where I should sit every day?

Not randomly.

Not habitually.

But based on rules, fairness, social dynamics, and a little bit of chaos.

Using amazing Technology to solve a Ridiculous Problem

Right now we live in a time where AI is often presented as:

• the ultimate productivity tool
• the solution to every business problem
• the replacement for knowledge workers

Meanwhile companies want employees back in the office to “rebuild culture”.

So I thought:

What if I used AI to do something that actually contributes to culture?

Not automation.

Not efficiency.

Just something playful.

Something that makes people laugh a bit when they arrive.

Something that makes people talk.

The Idea: An AI Seating Agent

The idea became a small experiment.

I created an AI agent (LLM-based agent) that would recommend which desk I should sit at every day.

But it shouldn’t just be random.

The agent should consider things like:

• fairness
• seat quality
• colleague preferences
• social dynamics

And most importantly:

it should explain its reasoning.

This is actually one of the things modern LLM agents are very good at:

transparent reasoning (chain-of-thought style reasoning / explainability)

The agent would therefore act as:

• a decision system
• a game
• a social experiment

Version 1 – Just Rotation

The first version was extremely simple.

The agent just calculated a deterministic seat based on the date.

Why?

Because fairness requires some kind of baseline rule.

So the agent calculates Day Of Year (DOY).

Example:

4 March → Day 63 of the year

Then it maps the day to a seat number:

BaseSeat = ((DOY - 1) mod 12) + 1

This is just modular arithmetic (modulo distribution).

If there are 12 desks, the rotation will cycle through them across the year.

So every day starts with a base seat recommendation.

This is the deterministic baseline (deterministic rule system).

Version 2 – The Agent Becomes Opinionated

Rotation alone is boring.

So I added scoring rules (heuristic scoring model).

Each seat would receive a score based on different factors.

Example factors:

Rotation score

How close the seat is to the base rotation.

Window score

Some desks are simply better.

Window seats in our office:

1, 3, 7, 9, 11

Premium seats

Corner desks.

1 and 11

Colleague preferences

Some colleagues love specific desks.

For example:

• Henrik loves seat 11
• Rohan prefers 12
• Jens prefers 3
• Sus prefers 1

So if the agent gives someone their preferred seat, it increases something I called:

Team Harmony Score (social optimization heuristic).

Version 3 – Logging Everything

At this point the agent started to become more interesting.

Because it logs every decision.

Whenever I sit down I confirm with a small command:

4=ok

The agent logs:

This creates a history dataset (interaction log).

From this data the agent can calculate different indicators.

Version 4 – Social Metrics

Now things started getting fun.

Instead of only optimizing seats, the agent started tracking social indicators.

For example:

Seat Coverage Score

How many different seats someone actually uses.

SCS = unique seats used / 12

This prevents people from claiming territory.

Window Hogging Index

Measures how often someone takes attractive window seats.

WHI = window seats last 10 days / 10

Corner Premium Index

Tracks usage of the best desks.

CPI = premium seats last 10 days / 10

Neighbor Disruption Score

This one was slightly more mischievous.

If you sit in the same area repeatedly, you might annoy the same colleagues.

So the agent calculates seat zones:

{seat-1, seat, seat+1}

If you sit in the same zone repeatedly, your Neighbor Disruption Score increases.

Version 5 – The Cake Algorithm

This is where things became slightly ridiculous.

The agent calculates an Irritation Risk Score.

IRS = 3*CPI + 2*WHI + NDS + (1 - SCS)

Which roughly means:

• hog premium seats
• sit near the same colleagues
• don’t rotate enough

…and your irritation score increases.

If the score becomes too high the agent suggests:

Cake Due

Meaning:

You should bring cake.

Or snacks.

Or coffee.

This introduces something I call:

Goodwill Balance (social credit / reciprocity metric)

Certain actions increase goodwill:

cake=ok
snacks=ok
coffee=ok

These restore the balance.

Version 6 – Gamification

At this point the experiment started drifting into game design territory.

Ideas started appearing:

• bribing a colleague for a seat
• coolness points
• department leaderboards
• wellbeing rewards
• team events

Imagine:

If the whole department participates, the system becomes a tiny social game.

For example:

• points for sitting on unpopular desks
• bonus points for coming early
• bonus points for sitting during quiet hours
• bonus points for helping someone else

This is essentially lightweight gamification (behavioral incentive design).

Version 7 – Sensor Integration

Then I had another thought.

Many modern offices already know which desks are occupied.

Desk booking systems.

Seat sensors.

Badge data.

Imagine feeding that data into the agent.

Now the system could detect:

• which desks are usually free
• peak hours
• collaboration patterns

Meaning the seat agent could become a real optimization system (agentic decision system).

Prompts vs Instructions vs Agents

Along the way I learned something interesting about working with LLMs.

There are actually several layers involved.

Prompt

A single instruction you send to the model.

Example:

“Recommend a desk for today.”

System instruction

A persistent rule set describing how the model should behave.

Example:

“You are DeskRota, an office seating agent.”

Agent

A system where the model:

• maintains memory
• logs actions
• applies rules
• evolves over time

This is what DeskRota became.

A small agent-based decision system.

Which Tools Would You Use for Something Like This?

One of the slightly amusing aspects of this little experiment is that it uses very powerful technology to solve a completely trivial problem.

And that’s actually part of the point.

Most people meet AI through grand narratives:

• enterprise transformation
• massive productivity gains
• autonomous systems
• replacing entire job categories

But the best way to understand these tools is often to play with small, harmless problems.

Like deciding where to sit in the office.

So if you look at something like the DeskRota example, it’s actually a nice mental model for understanding what different AI tools are good at.

Not academically.

But practically.

ChatGPT / OpenAI

In my case the entire experiment was built using the paid version of ChatGPT with a Custom GPT.

That means:

• I created a persistent system instruction (system prompt)
• The model keeps a memory of the conversation (session context)
• It behaves like a small agent with rules

This is probably the simplest way to experiment with AI agents today.

You don’t need infrastructure.

You don’t need APIs.

You don’t need code.

Just a good instruction.

And curiosity.

If you wanted to extend this in the OpenAI ecosystem you could imagine:

• OpenAI Assistants / Agents API
  (for building a persistent agent with structured memory)
• Function calling / tool use
  (for connecting the agent to systems like desk booking)
• RAG (Retrieval Augmented Generation)
  (for letting the agent read company policies or seating maps)

But for experimentation, a Custom GPT is perfectly sufficient.

Which is exactly what I used.

Microsoft AI Ecosystem

If you look at the same idea from the Microsoft ecosystem, different tools would play different roles.

Copilot Studio

Copilot Studio is essentially designed for building conversational agents (low-code AI agents).

A DeskRota agent could easily live here.

Typical uses would be:

• creating a chat-based office assistant
• integrating with Microsoft Teams
• connecting to Power Platform data
• retrieving desk availability from internal systems

In other words:

Copilot Studio is perfect when you want to turn an idea like this into a real workplace tool.

GitHub Copilot

GitHub Copilot is something very different.

It’s primarily a coding assistant (AI pair programmer).

So in the DeskRota example it would be useful if you wanted to:

• write the backend service
• build a seat allocation API
• connect to sensor systems
• integrate with desk booking systems

In short:

Copilot helps you build the system, not run it.

Copilot for Tasks / Automation

Another interesting direction would be task agents (AI task automation).

For example:

An agent that:

• checks desk availability
• assigns seats
• sends a Teams message
• updates a log

This is the kind of scenario where tools like Copilot for automation workflows or Power Automate with AI become useful.

Here the AI is not just answering questions.

It is triggering actions across systems.

Why Playing With Small Ideas Matters

The interesting thing about AI is that the learning curve is often backwards.

People think they need a big idea.

A big project.

A big transformation.

But in reality the best way to learn is to start with something slightly ridiculous.

Something small.

Something playful.

Because once you understand how these tools behave in a small system, you can suddenly see:

• where Copilot Studio fits
• where GitHub Copilot fits
• where automation agents make sense
• where LLM agents like ChatGPT are sufficient

And you begin to think differently.

Not just about what AI can replace.

But about what AI can make slightly more interesting.

Even something as simple as:

deciding where to sit on a grey Tuesday morning.

The Unexpected Insight

What started as a joke actually revealed something interesting.

We talk a lot about AI replacing workers.

But many of the things that make workplaces work are deeply human:

• humor
• fairness
• shared rituals
• small acts of generosity

Ironically, AI can help facilitate those things.

Not by replacing us.

But by creating small structures around social interaction.

The Final Agent

The current version of DeskRota now:

• calculates a daily seat
• logs every seating decision
• tracks multiple social indicators
• detects overuse of premium desks
• recommends social initiatives
• supports multiple participants
• evolves through prompts and rules

And most importantly:

It makes a completely ordinary office morning slightly more interesting.

Try It Yourself

If you want to try building your own seating agent, I’ve published the full instruction set here:

Copy it into any AI agent system and start experimenting.

Who knows.

Maybe the next time someone asks you:

“Where should I sit?”

The answer will be:

“Let’s ask the agent.”

The post The AI That Decided Where I Should Sit appeared first on [x]olsen.