Introducing Arlong AI: search that thinks, then shows its work

Most AI search is a trick. A chatbot trained on old text, bolted on top of an ad machine, answering from memory and hoping you never check the sources. Arlong AI works the other way around. The live web is the source of truth. The model is just the interpreter, and every claim points back to a page you can open.

What Arlong AI is

Arlong AI is a private, cited chat built on top of live web results. You ask a question, we search the real web first, then compose a grounded answer from the top results, with the sources shown alongside instead of hidden in small print. It lives at /ai, it is free, and it never trains on your conversations.

Under the hood it is not one model doing one thing. It is a small pipeline: search, re-rank, ground, compose, cite. Each stage is deliberate, visible, and replaceable. That is the whole point. When an AI answer can be audited stage by stage, it stops being a black box and becomes a tool you can trust.

   ┌─────────┐     ┌───────────────┐     ┌──────────────┐     ┌───────────────┐
   │  your   │ ──► │  live search   │ ──► │   evidence   │ ──► │   answer +    │
   │ question │     │  multi-engine  │     │  top results │     │    sources    │
   └─────────┘     └───────────────┘     └──────────────┘     └───────────────┘
                         │                    │
                         ▼                    ▼
                  backup server          the model reads
                  steps in if the        only this context,
                  primary source         never its own
                  hiccups                memory

How it works, in detail

1. The search layer: live first, always

Every question triggers a real web search before any AI runs. We query multiple public web indexes at once, merge the results, and de-duplicate them. No cached guesses, no knowledge-cutoff answers. If today's web does not mention it, today's answer will not either.

This layer is also fault tolerant. If the primary engines return nothing, or a connection drops, a backup search server automatically takes over and runs the same query. The UI shows a small notice whenever that happens, so you always know exactly which source produced your data.

2. The re-ranker: transparent scoring

Raw results do not get sent straight to the model. They first pass through a re-ranker that scores every result with eight weighted signals, the same system arlong search uses on the main page:

   title match      ████████████████████   24%
   snippet rel.     ████████████████       18%
   domain auth.     ██████████████         16%
   quality          ██████████             12%
   freshness        ████████               10%
   category         ██████                  7%
   reddit boost     ██████                  7%
   url quality      █████                   6%

Domain authority is backed by a curated trust list plus a Tranco-ranked list of the top 1,000,000 domains, so a brand-new spam site cannot buy its way up. The reverse also happens. Software portals, warez sites, APK mirrors, and file lockers are flagged as risky and demoted, and a warning appears when a risky site would otherwise rank. Nobody is blocked silently. Everything is either shown with context or excluded with a reason.

3. Grounding: evidence before prose

Only the top results become the model's context. This is the grounding step, and it is strict. If a fact is not present in the live results, the answer cannot contain it. The model reasons over the evidence that search actually returned, which is what makes the output verifiable instead of merely plausible.

The evidence block is also token-budgeted so it stays sharp. Roughly 1,000 to 5,000 tokens of high-quality results feed each answer, enough context to write a good reply and small enough to stay fast and cheap.

4. The model: compose from evidence, hold no memory

A Groq-hosted LLM reads the evidence and writes the answer. The model is stateless. It does not remember you between requests, it does not learn from other users, and it is not trained on your data. Each answer is rebuilt from scratch using the live evidence plus your own conversation history. No cross-user bleed, no profile, no retention.

5. Citations: show the work

Every answer turn renders source cards: favicon, domain, title, and snippet for each supporting page. On top of that, a short per-link relevance evaluation is generated for the top sources, so you can judge each one before you click. The answer is not complete without them.

   your question
   ─────────────►  [answer summary]
                    │
                    ├─► source 1   arlong.dev      "why we cite everything"
                    ├─► source 2   en.wikipedia    "grounded generation"
                    └─► source 3   docs.example    "context window limits"

   every source has a relevance tag: strong / partial / weak

6. Context: the conversation keeps itself

Follow-up questions append to the same chat, so you can ask "what about the pricing?" and the assistant still knows what you were comparing. Conversations are stored per account, which is why recent chats resume instantly from the sidebar, even after you close the tab.

Long conversations hit a context budget (see below). Instead of dropping older turns, the system compresses them automatically: the older parts of the thread get summarized while recent turns stay verbatim. You keep the thread, you lose the clutter, and the model never runs out of room mid-answer.

7. Privacy and limits: the boring, important part

Arlong AI runs on two rolling fair-use limits instead of a paywall:

   messages   40  per 12 hours   (rolling)
   context  10k  tokens per 6 hours (rolling)

   both counters show live in the chat UI
   both reset automatically, no credit card

Zero tracking. No training on your chats. Titles and messages are scoped to your account and nobody else's. The limits exist to keep the free service fast for everyone, and they are the opposite of a hidden throttle: you can always see exactly where you stand.

What we do differently

Three choices define Arlong AI, and each one is a deliberate rejection of how the big players build AI search.

First, the web is searched on every question. Google's AI Overviews run inside an ad-driven page and answer from a blend of trained knowledge and thin citations. ChatGPT answers from a static knowledge cutoff and only searches the web when you ask it to, so claims quietly age. Arlong AI never answers from memory. Live results arrive first, the model reads them, and the answer traces to a page published today.

Second, the evidence is shown, not hidden. Most assistants treat sources as an afterthought. Here the sources are part of the answer, each one evaluated for relevance, so verification takes one tap instead of a research project.

Third, it is private by architecture, not by promise. No training on your chats, no cross-user memory, no profile built from your questions. The model holds no memory, and the service holds no excuse to keep your data.

How it is different from Google AI

Google's AI Overviews are injected into an ad-driven results page. They are hard to turn off, they are built on your search activity, and the citations are thin, often a single link at the bottom. Arlong AI is a separate, opt-in space: no ads around the answer, no profile built from your chats, sources on every turn, and a visible fair-use limit instead of a hidden one.

How it is different from ChatGPT

ChatGPT answers from a static knowledge cutoff. It does not fetch the live web for every question, so claims can silently age, or silently hallucinate. Arlong AI fetches the web on every question, which means the answer traces back to a verifiable page published today, not a pattern learned from a training set years ago. When you want the current state of the world, that difference is the whole product.

The honest comparison

What is next

Short-term, we are working on deeper per-claim citation spans, side-by-side comparison answers, and optional voice input. Long-term, the goal does not change: the answer should always be traceable to a real page. If an AI answer cannot be checked, it is not an answer. It is a guess with good punctuation.