v1.0.4 - Catch The Heals

v1.0.4 — Catch The Heals

SIMURG now catches, heals, and learns. This release adds two layers on top
of the five-detector streaming ensemble:

Self-Heal: the guard that heals

A corrupt mid-stream abort no longer wastes a full regeneration. The ladder:

1. Diagnose the fired corruption class (loop / drift / regurgitation / structural)
2. Trim the released prefix to its verified-clean boundary
3. Send a pathology-specific continuation request at slightly warmer sampling
4. Guard the continuation with a fresh sentinel, stitch prefix + verified tail

result.healed = True, zero-leak guarantee preserved, verified by
verify_final on the stitched answer.

Pulse: the deep-learning detection tier

A 2-layer streaming transformer (345K params, 1.3 MB safetensors) reads the
recent 600 characters and emits a calibrated corruption probability. Trained
on 40 live answers from wahoo-1.5-preview + 240 CorruptBench corruptions;
held-out AUROC 0.925. Runs ~4 ms per window on Apple Silicon. Optional by
contract: without torch the numpy-only core behaves exactly as before.

Train it on YOUR hallucinations

SIMURG_LIVE_URL=http://your-endpoint/v1/chat/completions \
SIMURG_LIVE_MODEL=your-model \
python3 -m simurg.deep.train_pulse --clean 40 --corrupt 240 --epochs 8

Fabricated citations, number drift, prompt echo, domain garbage — collect
examples, retrain in seconds on CPU, ship via SIMURG_PULSE_WEIGHTS.

Links

• Weights on Hugging Face: MergenAI/SIMURG
• Paper: https://ssrn.com/abstract=7451269
• Install: pip install "simurg[deep]"

v1.0.3 — SIMURG Search

SIMURG Search — free web search for AI agents, no hallucinations

SIMURG Search gives your agent a free internet. It is an extra layer the
model uses to re-check information on the web before it answers, so it stops
confidently making things up.

Powered by the TinyFish Search API. It ships a bundled free-tier key, so it works the
moment you pip install simurg — no setup.

What it does

• fetch ranked, structured web results ({title, snippet, url, site_name}) and
  feed them into the model's context
• ground() returns a verdict — attested (subject confirmed on the web +
  Wikipedia), thin (weak/generic evidence, treat with caution), or
  no_record (nothing anywhere → likely fabricated → abstain)
• the same engine now powers Monolith's L4 grounded verification

Use it separately

# right after: pip install simurg
python3 -m simurg.websearch "when was the Y2K bug"          # ranked results
python3 -m simurg.websearch "Y2K bug" --ground              # verdict + evidence
python3 -m simurg.websearch "some query" --json --k 5       # machine-readable

from simurg import websearch

hits  = websearch.search("HAL-X AI")          # [{title, snippet, url, site_name}]
text  = websearch.snippets("HAL-X AI")        # ready-to-inject context string
check = websearch.ground("HAL-X AI")          # {'verdict': 'attested'|'thin'|'no_record', ...}

Set TINYFISH_API_KEY for dedicated limits, or TINYFISH_API_KEY="" to opt
out. Stdlib HTTP only — zero new dependencies. Every failure degrades to an
empty result, never an exception.

New contributor

Big thanks to first-time contributor @0xsyntho for the TinyFish integration. 🎉

Install: pip install --upgrade simurg · PyPI: https://pypi.org/project/simurg/1.0.3/

v1.0.2 — SIMURG Monolith

SIMURG Monolith — real-time learning + grounded factuality

SIMURG Monolith is the new layer on top of the base decode guard. In the
spirit of the Monolith recommender, it keeps learning while it serves: every
👍 / 👎 a user gives an answer is one online SGD step (serving loop == training
loop), so the hallucination model adapts in real time with no batch-retrain gap.

Added

• SIMURG Monolith terminal — python3 -m simurg.veritas_dashboard
• online hallucination-risk model (simurg.veritas.monolith) that trains from
  live like/dislike feedback
• white-box fact-uncertainty from decoder top-k logprobs (entropy, margin,
  competing-fact detection)
• grounded verification against real evidence (Wikipedia + web): catches a
  fabricated subject and a wrong detail on a real subject, and abstains
  instead of asserting when a claim contradicts the sources
• multilingual bootstrap dataset + trainer (EN / RU / AZ), shipped bootstrap
  model at held-out AUROC 1.0
• full "SIMURG Monolith" readme section with the terminal screenshot, launch
  instructions, and how to wire likes/dislikes from your own platform

Install: pip install --upgrade simurg · PyPI: https://pypi.org/project/simurg/1.0.2/

simurg v1.0.1

small patch on top of the v1.0.0 release.

fixed

• readme figures and the paper link now use absolute github raw urls, so the images render on PyPI and not only on GitHub

added

• the full technical report: paper/simurg_paper.pdf (13 pages, F. Aghayev and E. Ahmadbayli, HAL-X AI)
• a paper section near the top of the readme
• both authors in the citation block

pip install -U simurg

the paper: https://github.com/doofzoff/SIMURG/blob/main/paper/simurg_paper.pdf?raw=true

simurg v1.0.0

first public release, now on PyPI.

SIMURG catches LLM decoding corruption while the answer is still being generated: repetition loops, cross lingual drift, regurgitation, structural garbage, template leakage. It holds the opening of every stream, releases it only when verified clean, re checks at every checkpoint, and aborts within a few hundred characters of the moment the model goes bad.

what is in v1.0.0

• zero leak protocol: hold, release, re check, abort, with conformal calibrated thresholds and onset localization
• five detector ensemble plus a 15 weight online learning tier that keeps learning in production
• GuardedLLM: wraps any OpenAI compatible endpoint (vLLM, Ollama, llama.cpp, TGI) with an abort, retry, fallback model ladder
• fit_custom_detector: teach it your model's specific failure patterns from a few dozen examples, with an honesty gate
• live guard dashboard: real time score and 15 feature charts, session recording, replay at 128x
• live training dashboard with per epoch weight evolution
• reproducible CorruptBench benchmark: stream TPR 0.975 on the held out split, 0 false alarms on 121 real production texts

install

pip install simurg

3 lines to your first guarded stream

from simurg import GuardedLLM

llm = GuardedLLM("http://localhost:8000/v1", model="my-model", retries=1)
result = llm.chat([{"role": "user", "content": "hello"}])
print(result.ok, result.verdict)

links

• pypi: https://pypi.org/project/simurg/
• docs and benchmark: https://github.com/doofzoff/SIMURG
• live dashboard: python3 -m simurg.guard_dashboard

the research paper

the full 13 page technical report is in the repo: https://github.com/doofzoff/SIMURG/blob/main/paper/simurg_paper.pdf?raw=true