Skip to content

HYOAI: an AI chat client with no backend, in the browser

HYOAI (Host Your Own AI) is an open source AI chat client developed by Zenetys. A 100% static application: the browser talks directly to the inference server, and conversations remain stored locally.

Sylvain Lambert, , 11 min read
HYOAI icon

HYOAI does not rely on any application server: the browser talks directly to the inference server (Mistral, Claude, ChatGPT, Gemini, Ollama, llama.cpp, vLLM or any OpenAI-compatible API) and conversations are stored locally in the browser, compressed, without passing through an intermediate server.

Principles

Most AI chat interfaces rely on an application server that has to be deployed, maintained and secured, and through which conversations pass. HYOAI takes a different approach:

  • No HYOAI server. The application is a set of static files that can be dropped on any hosting, including next to the inference server. Nothing to deploy, nothing to maintain, no database.
  • The browser talks directly to the model. Each request goes from the user's machine to the configured endpoint, and nowhere else. With a self-hosted backend, exchanges never leave the infrastructure.
  • Data stays local. Conversations, titles, settings, branches, pins: everything is kept in the browser's local storage, compressed (roughly twice as much content in the same space). No third-party service, no telemetry, no account to create.
  • No per-user license. The project is published under the Apache 2.0 license: deployment costs only the infrastructure, for one person or for a whole team.
  • Read-only reasoning. The model's internal reasoning is kept for reading only: it is never sent back to the model in later exchanges.

The online demo

The public demo⁠ (opens in a new tab) lets you try the interface without installing anything. It relies on a demonstration server with predefined answers and sources; the interface says so itself: "Demo: predefined answers and sources, not real generation". By choosing one of the example questions, you can watch the pipeline unfold: the search and its steps, the thinking, the Markdown answer, the sources with their scores.

Free-text input is deliberately disabled there, and once again the interface explains why instead of refusing silently. Everything else is functional: themes, skins, languages, branches, compare mode, export, settings. The model menu also acts as a guide: the "Example" entries (Ollama, llama.cpp, vLLM, Mistral) show the exact command to connect the same tool to your own infrastructure.

Getting started

On opening, the home screen shows the input field and, when the backend provides them, a collapsible panel of example questions; one click on any of them sends the question straight away. These suggestions are not hard-coded in the application: they are supplied by the backend, in the language of the interface.

Choosing a model

The model selector is a pill placed to the right of the input field. The menu lists all configured models, local and remote:

  • a server that hosts several models (llama.cpp, llama-swap) is shown as a group: each automatically discovered model becomes selectable, and the list is refreshed every time the menu is opened;
  • an unreachable model is flagged with a warning triangle, with the explanation on hover;
  • an "i" button on each row opens the model card: its configuration and, when the server exposes them, its runtime characteristics (context size, number of parameters, vocabulary size).
The model menu: model choice, effort level and thinking switch.

Reasoning and effort level

For models that support it, the model menu offers two controls:

  • a "Thinking" switch, which turns the model's internal reasoning on or off;
  • an effort level choice (for example Low / Medium / High): a higher effort gives more complete but slower answers. The active level is shown on the model pill.

These controls only appear when the model declares them: the interface adapts to the real capabilities of each backend.

During generation

Answers arrive as a continuous stream, token by token, with smoothed display. The send button turns into a stop button during generation: one click interrupts the request, and the text already produced is kept, marked "Generation stopped".

Above the input area, a context bar shows how full the model's window is. On hover, it details the figures (context used, output in progress, speed in tokens per second) and gives access to the compaction actions (see below).

Background generation

Switching conversation does not interrupt a generation in progress: it continues in the background and is saved automatically. In the sidebar:

  • the conversation concerned shows a stop button on its row;
  • hovering over the row shows the text being written, live;
  • once the answer is complete, a green check mark appears ("Generation complete — click to view") and disappears when the conversation is opened.
A generation finished in the background: green check mark and conversation preview on hover.

Reading an answer

Answers are rendered in Markdown: headings, lists, tables, blockquotes, links (opened in a new tab) and code blocks with syntax highlighting, the language name and a "Copy" button.

Reasoning, displayed

When the model reasons before answering, its reasoning is shown: a "Thinking" block opens automatically above the answer and fills in live. Once the answer is complete, it collapses into a "Reasoning" block that can be consulted at any time. A setting keeps it permanently open.

The model's reasoning and the search steps, shown above the answer.

Per-message statistics

Below each answer, a pill shows the model used (with a dedicated icon if thinking was active) and, if the setting is enabled, statistics that can be switched with a click:

  • Reading: prompt tokens, processing time, speed;
  • Generation: tokens produced, duration, tokens per second;
  • Pipeline: for RAG backends, the latency of each step (intent, decomposition, embedding, vector search, reranking, generation);
  • Storage: the weight of the conversation in the browser.

These measurements make it possible to compare models or servers without any additional tooling.

RAG transparency: the search behind the answer

With a RAG or agentic backend, HYOAI shows not only the final answer but also how it was built.

Above the answer, a "Search" panel opens during generation and unfolds the pipeline:

  • the "Sub-queries": the backend's reformulations of the question;
  • the "Dense search" and the "Lexical search", each collapsed behind its count of candidate documents;
  • the "Reranking", the final step that keeps the best documents.

By expanding a step, you see the numbered list of documents with their score: the pipeline casts a wide net, then converges on the right sources.

Below the answer, the "Sources" block lists the documents selected: a title linking to the knowledge base, a two-line excerpt, a relevance score. Duplicates are merged. With a standard (non-RAG) model, the same block is built from the links that the answer itself cites.

The Sources block below the answer, with relevance scores, statistics and message actions.

Message actions

Each message carries an action bar (on hover on desktop, by long press on mobile):

  • Copy the message;
  • Reply: quote the answer to anchor the next question. You can also select a specific passage in an answer; a "Reply" button appears above the selection and only the excerpt is quoted;
  • Edit, including AI answers: an answer can be corrected without being regenerated. Editing a user message reopens the full editor, attachments included;
  • Regenerate an answer, without losing the previous one (see branches below);
  • Create a new conversation from this message: start again from that exact point in a new conversation, without touching the original;
  • Delete this message and what follows;
  • Rate the answer, if the deployment has enabled it: feedback buttons (good / bad answer, with an optional comment) send the rating to an internal feedback collector.
Quoting an excerpt of an answer to anchor the next question.

Branches: a conversation is a tree

In HYOAI, a conversation is not a list of messages but a tree. Editing a message or regenerating an answer replaces nothing: it creates an alternative version, and the old one stays accessible.

A "1/2" indicator framed by two arrows then appears on the message: navigating between versions switches the whole conversation thread to the chosen branch. You can explore one avenue, go back, try another, without losing anything. Branches are saved like everything else and survive a page reload.

Attachments and system message

The "+" button in the input area opens the attachments menu; drag and drop and pasting from the clipboard also work:

  • Images: resized in the browser before sending (adjustable maximum size), which reduces the volume transmitted and the storage space used;
  • Audio files: mp3 and wav, for models that accept them;
  • Text files: their content is attached to the message;
  • PDF files: either text extracted page by page, or pages converted to images for vision models ("PDF as images" setting).

The interface takes each model's capabilities into account: if the active model does not process images, the entry is disabled with the explanation "Image processing requires a vision model".

The same menu lets you define a system message specific to the conversation. Once defined, it is visible: a pill above the input area reminds you of it, a click edits it, a cross removes it.

The attachments menu: entries the model does not support are greyed out, with the reason.

Compare mode

The "Compare" button in the top bar splits the screen into side-by-side panels (up to four). Each panel is a complete, autonomous conversation, with its own model, its own thinking switch and its own effort level: you can pit two different models against each other, or the same model at two effort levels.

At the bottom, a single input area with an "All / Active" selector: ask the same question to all panels at once, or write in the active panel only. Each panel keeps its own context bar and can be stopped independently.

The "Analyze" button opens an additional panel that asks a model to compare the other panels' answers: key differences, strengths and weaknesses, conclusion. The synthesis is produced by an LLM, but it speeds up the evaluation considerably.

When only one panel remains, compare mode closes and the conversation becomes a simple conversation again.

Two panels, two effort levels, one shared input and the Analyze button.

Managing conversations

The sidebar groups conversations, pinned first and then recent. Each conversation receives an automatic title taken from the first message, which can be renamed with a click on the title. A few details:

  • search is not limited to titles: it also covers the content of messages, shows an excerpt with the matched term highlighted, and takes you directly to the message concerned;
  • the command palette (Ctrl/Cmd + K) offers the same search from the keyboard, plus quick actions (new conversation, settings);
  • hovering over a conversation shows a preview with its last modification date;
  • each conversation has a shareable address: "Copy link" produces a URL that reopens that conversation;
  • several tabs open on the application synchronize automatically;
  • deletion asks for confirmation (Shift + click skips it).

Data and the browser

The "Data" tab of the settings gives a complete view of what the application stores:

  • a storage gauge with a conversation-by-conversation breakdown, sorted from heaviest to lightest;
  • conversations are compressed: roughly twice as much history in the same space;
  • if storage nears saturation, an alert flags it once and takes you in one click to the right place; if a write fails, nothing is lost silently: the application retries and informs the user;
  • selective export as JSON, in the native format or in the llama.cpp webui format; import of both formats, which adds to existing conversations without overwriting anything;
  • a "Clear everything" button permanently deletes all browser data, after confirmation.

As for what actually travels: only the necessary request goes to the configured inference server (messages, attachments, any system message). Titles, pins, settings, branches and statistics stay local, and the model's reasoning is never sent back.

Long conversations and context management

Every model has a limited context window. HYOAI manages it in the browser, automatically.

Compaction

When the conversation nears the limit (adjustable threshold, 80% by default), the oldest exchanges are condensed into a summary by the model itself, preserving facts, decisions, figures and important excerpts. The latest exchanges remain intact. The operation is invisible and non-destructive: on screen, the conversation does not change; only what is sent to the model is lightened. Compaction is also triggered if the server reports a context overflow: the request is then compacted and retried without intervention. It can also be started manually ("Compact conversation") from the context bar.

An additional, voluntary step, "Free storage", replaces the old summarized messages with a collapsible "Conversation summary" block, to recover local space.

Splitting into chapters

When an input (message and text or PDF attachments) exceeds the model's window, HYOAI splits it into chapters, respecting paragraphs and sentences. Each chapter is analyzed one after the other, visibly: the thread shows collapsible "Chapter 3/12 · Excerpt" and "Chapter 3/12 · Analysis" lines, then a final synthesis that becomes the answer. Two strategies are offered, switchable during the analysis: Map-reduce (each chapter analyzed independently, then combined) or Rolling (a summary enriched chapter after chapter).

The estimate of text size corrects itself by querying the server when possible, and the raw document is never sent back in later questions: only the consolidated analysis remains in the context.

Settings and appearance

The settings fit in four tabs: General, Generation, Data and Config.

  • The Generation tab exposes the sampling parameters (temperature, top-k, top-p, repetition penalties) with a simple principle: an empty field is not sent at all, and the server applies its own default values (the field shows "Server default"). The technical name of each parameter is adapted automatically to the server type.
  • The Config tab lets you edit the list of models directly from the application: changes are saved in the browser as a local override of the deployed file, applied immediately, flagged by an "Override active" pill, and selectively reversible.
The Config tab: the model list can be edited directly from the application.

As for appearance: light, dark or system theme; six skins that change the whole interface (Soft, Flat, Contrast, Warm, Forest, Dim); three chat widths; a compact input layout; an interface available in French and English: the language is passed on to RAG backends, which can answer in the interface language. Fonts are bundled in the application: no call to an external service.

Mobile and accessibility

The interface is designed for touch:

  • menus open as bottom drawers, with a handle and closing by swiping;
  • a long press on a message opens the action sheet; scrolling never triggers an accidental opening;
  • an unavailable action states its reason in plain words, rather than a disabled button with no explanation.

On the accessibility side: every button carries a label for screen readers, the stream of answers is announced as it arrives without interrupting the current reading, navigation is fully possible by keyboard, focus is returned to the right place after each interaction, and decorative animations are disabled if the system asks to reduce motion.

On mobile, the model menu opens as a bottom drawer.

Keyboard shortcuts

  • Ctrl/Cmd + K: command palette and search;
  • Ctrl/Cmd + B: show or hide the sidebar;
  • Ctrl/Cmd + Shift + O: new conversation;
  • Enter: send; Shift + Enter: new line (can be inverted in the settings);
  • Up / Down arrow in the empty field: recall previous messages;
  • Ctrl/Cmd + Enter: confirm a message edit;
  • Esc: cancel the edit.

Conclusion

HYOAI applies to the AI chat client the principles expected of an infrastructure tool: local, transparent and under control. No application backend to maintain, no per-user license, no data leaking out: the browser, the model, and an interface that shows what the AI is actually doing.

HYOAI is developed and published under the Apache 2.0 license by Zenetys, a services company specializing in audit, architecture and managed services for infrastructure.

More on this topic

All news