FALCON

A zero-server, browser-native research agent that runs a real iterative loop — fanning 21 public APIs, filtering every result through a deterministic 512-dim embedding, and posting the answer as a threaded comment that builds on the one before it.

"Ask a question. FALCON iterates. Each iteration references the last. Nothing leaves your tab."

What is FALCON 5.0?

FALCON 5.0 is a single-file HTML/JS research agent that behaves like a browser-resident researcher. Give it a task in plain English and it will:

1. Pick a research angle — overview, definitions, mechanism, examples, comparisons, history and context, trade-offs and pitfalls, open questions.
2. Fan out across 21 wings — Wikipedia, Wikidata, DuckDuckGo, arXiv, OpenAlex, Crossref, Semantic Scholar, GitHub, Europe PMC, Stack Exchange, Hacker News, Open Library, Nominatim, REST Countries, USGS, Reddit, Lobsters, Wiktionary, Dictionary API, Datamuse, World Bank — with per-host rate limits and a 4.5 s per-wing deadline.
3. Score everything with JEV — a 512-dimension deterministic embedding that ranks candidates by relevance and, crucially, by novelty against everything already in the thread.
4. Synthesize a coherent paragraph — either through a locally-loaded LLM (via Transformers.js), or through a deterministic extractive fallback when no model is loaded.
5. Audit the answer — every sentence is checked against the retrieved sources, producing a groundedRatio you can trust.
6. Post the result as a threaded reply, showing its angle, its sources, its confidence, its novelty, and how well it stayed grounded.
7. Loop back — the next iteration re-reads the task and every prior reply, picks a different angle, filters harder for novelty, and posts again. The thread looks like a comment section, not a chat log.
8. Loop stops on plateau (3 consecutive low-novelty iterations) or iteration cap (16), and you can stop it any time with Enter or Esc.
9. Export a Karpathy-style JSON table of every run — its queries, sources, response, confidence, novelty, groundedness, and timestamp.

No API keys. No accounts. No telemetry. No server. One HTML file.

Quick start

1. Open the Space.

2. Type a question, e.g.:

   how does kernel bypass networking work and what are the trade-offs?
   
   

3. Press Enter — the auto loop starts.

4. Watch iterations stream in. Each iteration is a threaded post with:

   • The angle it chose
   • Its sources (top 3)
   • Confidence, novelty, groundedness percentages
   • Total source count

5. Press Enter again (or Esc) to stop.

6. /export json to download the run table. /runs to see it inline.

7. Ask a follow-up in the same conversation — it uses the thread as context.

The research wings

FALCON fans 21 public API wings in parallel each iteration. Every wing is rate-limited independently, timed out at 4.5 s, and fails gracefully — the loop never stalls because one wing is throttled.

Conditional wings

Some wings only fire when their topic keywords are present in the query:

• europepmc — health, medical, biology, medicine, clinical, biolog, genom
• usgs — earthquake, quake, seismic, tremor
• worldbank — gdp, economy, inflation, population, unemployment, growth

This keeps irrelevant wings from consuming rate-limit budget.

JEV — the embedding engine that makes it all work locally

Every piece of text — a source title, a snippet, the user's task, the current iteration's answer — is embedded into a 512-dimension Float32 vector using a deterministic, dependency-free algorithm.

How JEV works:

• Position-weighted unigrams — every non-stopword token contributes 1 + 0.5·exp(-i/30) at its hashed slot, so early tokens count more.
• Bigrams and trigrams — bg_ and tg_ prefixed hashes at 0.45 and 0.22 weight, capturing local phrase structure.
• Character 3-grams — for tokens ≥ 5 chars, at 0.06 weight per trigram, catching subword texture.
• L2 normalisation — all vectors are unit-norm, so dot(a, b) is cosine similarity.

Why this matters:

• Novelty scoring — every candidate is compared against everything the loop has seen. Anything with 1 - max(cosine(candidate, seen)) < 0.28 is rejected before it reaches synthesis. This is what prevents the loop from re-answering the same question 16 times.
• Relevance scoring — the top 12 novel candidates by 0.4·novelty + 0.6·relevance become the material for this iteration.
• Groundedness audit — every sentence of the generated answer is checked against every sentence of the retrieved sources. Anything below 0.42 cosine similarity is flagged as ungrounded, and the groundedRatio is reported to the user.
• Determinism — the same text always produces the same 512-dim vector. You can replay an exported JSON run table exactly.

No model. No download. No server. Just math.

The thread UI

Every iteration appears as a threaded post underneath the original task, exactly like the reply tree of a Twitter/X thread:

you · task
└─ falcon #1 · overview
       [answer paragraph]
       [1] wikipedia — ...
       [2] arxiv — ...
       conf 62% · novelty 84% · grounded 71% · 8 sources

   └─ falcon #2 · definitions
       [answer paragraph]
       [1] wiktionary — ...
       [2] openalex — ...
       conf 58% · novelty 71% · grounded 82% · 6 sources

       └─ falcon #3 · mechanism
           ...

The dashed left border and ↳ glyph make the reply-to-reply relationship visually clear. Each post shows the specific angle it addressed, so you can read the thread as a progressive, multi-dimensional investigation.

Scroll behavior

• The terminal sticks to the bottom when you're at the bottom.
• If you scroll up to read a prior post, autoscroll is paused.
• A floating down-arrow button appears with an unseen-count badge.
• Click it (or scroll to bottom) to re-pin the terminal.

No jitter, no forced scrolls.

Commands

The export format

/export json — a Karpathy-style run table you can feed to a script, diff two runs, or build a downstream evaluation set:

{
  "task": "how does kernel bypass networking work...",
  "startedAt": "2026-01-01T00:00:00.000Z",
  "completedAt": "2026-01-01T00:03:12.000Z",
  "version": "5.0.0",
  "runCount": 8,
  "stats": {
    "avgConfidence": 0.61,
    "lastGroundedRatio": 0.72,
    "avgNovelty": 0.44
  },
  "runs": [
    {
      "iteration": 1,
      "angle": "overview",
      "focus": "kernel",
      "queries": [
        "kernel bypass networking overview",
        "kernel overview",
        "how does kernel bypass networking work overview"
      ],
      "sources": [
        { "title": "Kernel bypass", "src": "wikipedia", "url": "...", "sim": 0.71, "novelty": 0.95 },
        { "title": "DPDK — Data Plane Development Kit", "src": "github", "url": "...", "sim": 0.68, "novelty": 0.88 }
      ],
      "response": "Kernel bypass is a technique...",
      "confidence": 0.62,
      "novelty": 0.84,
      "groundedRatio": 0.71,
      "timestamp": "2026-01-01T00:00:04.120Z"
    }
  ]
}

Fields per run:

• iteration — the sequence number
• angle — the research angle this iteration addressed
• focus — the specific focus word picked from the task
• queries — the actual search queries sent to the wings
• sources — the top novel sources that survived filtering
• response — the paragraph posted in the thread
• confidence — mean relevance of the top 3 sources
• novelty — mean novelty of the top novel candidates
• groundedRatio — fraction of response sentences that match a retrieved source above the threshold
• timestamp — when the iteration completed

Perfect for building eval sets, comparing model vs. extractive runs, or diffing two independent investigations.

Privacy & hosting

• No backend. FALCON runs entirely in your browser tab.
• No telemetry. No analytics, no error reporting, no fingerprinting.
• No accounts. Everything is local.
• Persistence:
  • Runs, memory vectors, wiki cache, attachments, and input history live in IndexedDB (falcon-v50, falcon-mem-v50, openwiki-v1).
  • Query cache and input history mirror into localStorage for fast startup.
  • The loaded LLM is cached by the browser's Cache API.
• Network traffic is limited to the 21 wings + cdn.jsdelivr.net (Transformers.js) + huggingface.co (model weights). Nothing else leaves the tab.

Browser support

Tested on: Chrome 122, Firefox 123, Safari 17.

Technical deep-dive

Rate limiting

Every wing has its own token bucket (HOST_BUCKETS) with a per-minute budget:

When a bucket is empty, the wing throws ThrottledError and the iteration continues with whatever came back from the others. The loop never stalls on a single host.

Timeouts

Novelty state

Persisted in-memory only (cheap to recompute):

• seenVectors — last 500 JEV vectors from accepted novel candidates
• seenTitles — normalised title set for fast deduplication
• seenHashes — quick hash set for exact-duplicate rejection
• plateau — consecutive iterations below the novelty floor

When plateau ≥ 3, the loop stops and reports "plateau reached — task complete".

Caches

/forget clears memory vectors. /forget-wiki clears the wiki cache. /clear wipes the thread and all runs.

Determinism

JEV is fully deterministic — the same text always produces the same 512-dim vector. This means:

• You can replay an exported JSON run table exactly.
• Two collaborators running the same task on the same inputs will see the same scores.
• The novelty floor is stable across browsers and OSes.
• The groundedness audit is reproducible.

What FALCON is not

• Not a chatbot. Replies are threaded research posts, not conversations.
• Not a search engine. It synthesizes across 21 sources, not just one.
• Not a knowledge base. Every run is fresh — FALCON doesn't cache answers to questions (it caches source pages, which is different).
• Not a code executor. Nothing runs in a sandbox.
• Not a bundled model. You get the extractive fallback for free; the LLM is a /model load away.

Attribution & license

• Author: webXOS
• Version: 5.0.0
• License: MIT
• Model library: Transformers.js (Apache 2.0)
• Source APIs: Wikipedia (CC BY-SA), Wikidata (CC0), DuckDuckGo (ToS), arXiv (various), OpenAlex (CC0), Crossref (CC0), Semantic Scholar (various), GitHub (ToS), Europe PMC (various), Stack Exchange (CC BY-SA), Hacker News (MIT), Open Library (various), Nominatim/OSM (ODbL), REST Countries (MIT), USGS (public domain), Reddit (ToS), Lobsters (MIT), Wiktionary (CC BY-SA), Dictionary API (various), Datamuse (MIT), World Bank (CC BY 4.0)

You are free to fork this Space, remix the UI, swap the wings, or embed FALCON in another tool. See LICENSE in the repo for the full text.

Additional files to ship alongside falcon.html

LICENSE (MIT)

MIT License

Copyright (c) 2026 webXOS

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Changelog

[5.0.0] — 2026-01-01

Added

• Thread-native UI — every iteration posts as a threaded reply with ↳ markers
• Infinite-iteration auto loop (16 cap, plateau-stop at 3 low-novelty iterations)
• 8 research angles: overview, definitions, mechanism, examples, comparisons, history and context, trade-offs and pitfalls, open questions
• JEV novelty filtering (NOVELTY_THRESHOLD = 0.28) so iterations don't repeat
• Groundedness audit per iteration, reported as groundedRatio
• /export json — Karpathy-style run table with queries, sources, scores, timestamp
• /runs — inline run table
• Local model support (tiny / small / large via Transformers.js 3.0)
• Full off-thread scroll behavior — floating down-arrow with unseen-count badge
• Welcome card rendered inline in terminal (no popup)
• Enter = start / stop toggle
• Wiki cache (openwiki-v1) — 24-hour TTL, batch summary fetches
• Query cache (6-hour TTL) in localStorage
• Memory index (LSH-bucketed JEV vectors) in falcon-mem-v50
• Drop .txt / .md attachments — FALCON answers from them directly
• /forget, /forget-wiki, /stats, /history, /g commands

Fixed

• Removed the initial popup that used to appear on boot
• Enter no longer requires a non-empty input to stop the loop
• Scroll position no longer fights the user when reading prior posts
• Wiki summaries are now batched (20 per request) to reduce API calls
• Rate limits now use token buckets per host, no global stall
• Model generation is queued (max 5 in flight) to prevent pipeline overload

[4.3.0] — 2025-12-01

• Paragraph answers with /expand into essay
• 22 API wings, /find infinite scroll, Wikipedia expand
• Weather via Open-Meteo
• Export: json, csv, tsv, md, html, txt