Chat Interface

The chat interface does one thing well: it gets out of the way.

You open the chat. Pick an agent. Type a question. Within seconds, a grounded answer streams in with source citations you can click to verify. No hunting through SharePoint folders. No guessing which Confluence page has the answer.

Most AI chat products look the same. A text box, a send button, a wall of generated text. I spent a lot of time making sure Knowably feels different in the one way that matters - every answer is traceable back to a real document.

The Experience

You land on a clean screen. One input field. A few suggested questions to get you started. Nothing else competing for attention.

Pick your agent from the sidebar. Each one is scoped to specific knowledge bases - the HR agent searches HR docs, the technical support agent searches product docs. You never wonder if you are searching the right content.

Type a question. Hit enter. The answer starts arriving immediately.

Not after a loading spinner. Not after a "thinking" animation. Immediately. Text flows in as the model generates it, like watching someone type a considered response. I chose streaming over complete responses because staring at a blank screen for eight seconds while the model finishes is a terrible experience. You start reading the answer while it is still being written.

If the model is working through something complex, a collapsible thinking section shows its reasoning. Open it when you want to understand how the agent arrived at its answer. Ignore it when you just need the result.

Source Citations

This is the feature I care about most.

Without citations, you are asking people to trust a language model. That is not how knowledge management works. I have seen teams adopt AI tools, get a few wrong answers with no way to verify them, and stop trusting the tool entirely. Trust, once lost, does not come back.

Every answer in Knowably shows exactly which documents it drew from. Not as a footnote buried at the bottom of the page. Inline, visible, right below the response. Colored badges with the document name. One click to verify.

External sources from SharePoint, Jira, or Confluence open in a new tab. Locally stored documents download directly - PDF, DOCX, XLSX, whatever the original format was. Your team verifies any answer in one click.

This works because of how the RAG pipeline is designed. The LLM is instructed to reference source chunks using specific IDs. Those IDs get mapped back to their source documents. If multiple chunks reference the same document, only one citation appears. No duplicates, no noise.

I made citations non-negotiable early in development. Every feature decision downstream had to preserve them. Streaming could not break them. Multi-turn could not lose them. The embed widget had to show them. If an answer cannot point to a source, something went wrong in the pipeline.

This is the difference between "the AI said so" and "here is the document, section 3, paragraph 2." That difference is everything in enterprise knowledge management.

Conversations That Remember

Ask about the vacation policy. Follow up with "what about for part-time employees?" The agent understands you are still talking about vacation policy.

When multi-turn is enabled on an agent, the chat preserves full message history. The assistant reformulates follow-up questions using previous context before searching. This sounds simple. Getting it right was not.

The challenge is that each follow-up still needs to retrieve fresh documents. "How long does it last?" by itself matches nothing useful. The pipeline reformulates it into "How long does parental leave last?" before searching, so retrieval stays sharp even in deep conversations.

Each conversation gets an automatic title. Your history is organized by time - today, yesterday, last week. Find any conversation later without remembering what you called it.

You can also set conversations to public or private. Share a good answer with your team, or keep sensitive questions to yourself.

The Feedback Loop

Below each response, thumbs up and thumbs down buttons.

Simple interaction, big impact. Every rating gets stored per message and sent to Langfuse as a numeric score. Over time, this builds a picture of answer quality across agents, models, and question types.

When a customer reports a bad answer, I can filter Langfuse traces by low feedback scores and immediately see what went wrong in the pipeline. Which documents were retrieved. How they were ranked. What the model actually received as context. The feedback loop closes the gap between "this answer was bad" and "here is why, and here is how to fix it."

Without user feedback tied to pipeline traces, improving answer quality is guesswork. With it, every thumbs down is a debugging starting point.

Why Minimal

I get asked why the interface is so stripped down. No fancy animations. No sidebar full of settings. No visible controls beyond what you need right now.

During early testing, I watched a non-technical user open the chat, hesitate for a moment, and then just type a question. No onboarding needed. No one explained the interface. She asked about a leave policy, read the answer, clicked the source citation, verified it, and went back to work. The whole interaction took about 20 seconds. That was the moment I knew the minimal approach was right.

The chat competes with the path of least resistance. When someone has a question, they can ask a colleague, search their email, dig through SharePoint, or type it into Knowably. If Knowably takes more than a few seconds to understand, they will pick one of the other options.

Every UI element I did not add is a decision I made deliberately. The suggested questions disappear after your first message - you do not need onboarding anymore. The model selector is tucked in the header - you pick once and forget about it. The chat history sidebar collapses on mobile - screen space goes to the answer, not navigation.

The chat renders full Markdown with syntax highlighting for code blocks. Tables, headings, bold, lists - all properly formatted. But the formatting is invisible until it is needed. A simple text answer looks like a simple text answer. A technical response with SQL queries and JSON payloads gets proper coloring and monospaced fonts.

The interface is minimal because the value is in the answer and its sources. Everything else should be invisible.

What This Enables

The chat is where the entire platform converges. The RAG pipeline does the retrieval. The agents define the behavior. The security layer protects the input. The observability stack traces every step.

But none of that matters if people do not use it. A pipeline that produces good answers is worthless if the interface makes people think twice before asking a question.

I built the chat to feel like a conversation, not a search engine. Ask a question. Get an answer. Verify it. Move on.