cognis-opal

Cognis Opal

Bring your own open model. Opal makes it punch far above its parameter count — privately, on your own hardware.

Cognis Opal is not another set of weights. It is a model-agnostic on-device intelligence system: a commodity open GGUF + Aleph O(N) memory + hybrid retrieval + native tool-use + adaptive test-time compute, wired so a small local model beats the frontier on the axes an on-device system can actually own — privacy, cost, persistence, uncensored operation, long-context efficiency, and your private corpus that Claude/GPT/GLM structurally cannot see.

The honest thesis (this is the moat): a 4–14B model will not beat GPT-5.5 / Claude / GLM 5.2 on closed-book novel reasoning — that's a capacity wall, and physics, not marketing. Opal doesn't try to. It offloads knowledge to retrieval and computation to tools + test-time compute, so effective capability lands far above the parameter count on the tasks that matter locally. No fabricated benchmarks. That honesty is why it's worth running.

What makes it a breakthrough

• Aleph memory (O(N²) → O(N)). The Aleph fabric turns the quadratic attention/prompt cost of long context into linear retrieval. Measured: ~43× fewer prompt tokens at ~100% needle recall on NIAH, where stock models hit the context wall.
• 100% grounded recall@3 over 200 trials (hybrid semantic ⊕ IDF-lexical retrieval with a rare-token guarantee).
• Test-time compute that scales with difficulty — draft→critique→revise, multi-lens expert panels, and an adaptive router that spends compute only on hard questions.
• Persistent, private memory across sessions — your corpus never leaves the machine, never trains a vendor model.
• Vectorized recall: 1.5s → 7ms over 74k chunks; embeddings persisted (no recompute on load).

Bring your own model (attributed backends)

Opal is a layer, not a lock-in. Point it at any open model — each used as an attributed backend, never rebranded:

The reference build ships on the pristine, uncensored OmniCoder-Qwen3.5-9B GGUF (never fine-tuned by us). Swap the base freely — the memory, tools, and reasoning layer are what make it Opal.

Get it — one place

This repo is the canonical home of Cognis Opal (system + card + docs).

• Weights (GGUF): cognis-digital/cognis-opal-gguf — the recommended base (a quant of OmniCoder-Qwen3.5-9B, Apache-2.0, attributed). Drop the .gguf in model/ or pull the Ollama tag.
• Benchmarks: real, sampled, reproducible — see BENCHMARKS.md (honest scores + the long-context/memory results that are the actual differentiator).
• The breakthrough: Aleph memory (O(N²)→O(N)).

Multimodal (text + image + audio in)

Opal accepts images and audio, fused with your text and memory via a unified ask(text, image, audio):

• Vision — LLaVA (default, local via Ollama) or Qwen2.5-VL (Apache-2.0, 3B/7B/72B), or any vision endpoint (SYNTHOS_VISION_*).
• Audio — Whisper via faster-whisper (MIT) or a whisper.cpp / OpenAI-compatible transcription endpoint.

python -m synthos see chart.png "what's the trend?"
python -m synthos hear memo.m4a
python -m synthos ask "answer the spoken question about this chart" --image chart.png --audio q.wav

Honest design: it's describe-then-reason — the reasoner reasons over the VLM's description + the transcript + your memory (inspectable, guarded, degrades gracefully), not an end-to-end VLM. Backends are attributed open models; Opal orchestrates them, it doesn't retrain or redistribute weights.

Speed

Opal supports speculative decoding for the Qwen3 family via JetSpec-style causal parallel tree drafting — up to ~7–9× faster decoding on Qwen3-8B with identical output quality (speed, not a capability change — stated honestly).

Install & Run

Opal is a small stdlib Python system that orchestrates a local model backend. You bring the backend; Opal brings the memory, retrieval, tools, and test-time compute.

Prerequisites (all platforms)

• Python 3.10+
• A model backend: Ollama (easiest) or a llama.cpp / LM Studio server exposing an OpenAI-compatible endpoint. Opal itself ships no weights.
• git (used once to fetch the Aleph memory fabric).
• numpy is installed by the setup scripts. faster-whisper is optional (only for synthos hear).

Get the files once:

git clone https://huggingface.co/cognis-digital/cognis-opal
cd cognis-opal

Windows (PowerShell)

# from the cloned folder — creates .venv, installs numpy, fetches Aleph, checks for Ollama
powershell -ExecutionPolicy Bypass -File .\install.ps1
# (optional audio backend)
$env:OPAL_WITH_AUDIO = "1"; powershell -ExecutionPolicy Bypass -File .\install.ps1

ollama pull qwen3          # or any open GGUF from the table above
.\run.cmd                  # == python -m synthos chat --adaptive

macOS / Linux

chmod +x install.sh run.sh
./install.sh               # venv + numpy + Aleph + backend check
OPAL_WITH_AUDIO=1 ./install.sh   # optional: include audio (faster-whisper)

ollama pull qwen3
./run.sh                   # == python -m synthos chat --adaptive
# or with make:  make install && make run   (make test for a no-backend smoke test)

Docker

The image ships only the Opal system (no weights). Run a model backend on the host and point the container at it via SYNTHOS_ENDPOINT:

docker build -t cognis-opal .
# host is running Ollama on :11434
docker run --rm -it \
  -e SYNTHOS_ENDPOINT=http://host.docker.internal:11434 \
  -v opal-mem:/root/.synthos \
  cognis-opal
# one-shot instead of interactive chat:
docker run --rm -e SYNTHOS_ENDPOINT=http://host.docker.internal:11434 cognis-opal ask "hello"

(On Linux add --add-host=host.docker.internal:host-gateway. SYNTHOS_ENDPOINT / OLLAMA_HOST also work for native installs when your backend is not on 127.0.0.1:11434.)

Run it — text and multimodal

python -m synthos chat --adaptive          # interactive; spends compute proportional to difficulty
python -m synthos ask "explain X"          # one-shot, with memory + refine
python -m synthos remember "a durable fact"
python -m synthos stats                     # memory + backend status

# multimodal (needs the matching backend up)
ollama pull llava                                       # vision backend
python -m synthos see chart.png "what's the trend?"     # image -> describe -> reason
python -m synthos hear memo.m4a                          # audio -> transcribe -> reason (needs faster-whisper)
python -m synthos ask "answer the spoken question about this chart" --image chart.png --audio q.wav

GPU path: serve the base via llama.cpp (Vulkan) or LM Studio and point Opal at it (SYNTHOS_ENDPOINT / the commander profile). On-device profile: uncensored Qwen3-4B @ Q5 on an Intel N150 class device (~7 tok/s, bandwidth-bound).

Measured results (raw, including the negatives)

• NIAH long-context: ~100% recall at ~43× fewer prompt tokens; stock models hit the ctx wall (llama3 33% @ 8k).
• GGUF-only, no tools, on CPU: a small reasoner scored 2/5 on computable questions and was slow — proof that GGUF-only-in-head does not beat frontier. Tools fix computation, retrieval fixes knowledge; that's the design.
• Full record and reproduction: BENCH_NIAH.md, BUILD_STATUS.md.

Honest scope

• We claim: on-device, private, uncensored, free, persistent memory; ~43× long-context token efficiency; 100% grounded recall; beats frontier on your private corpus (which closed models can't access).
• We do not claim: a small GGUF beats GPT-5.5 / Claude / GLM 5.2 closed-book on GPQA/AIME/SWE-bench. No fabricated scores, no open-book-relabeled-as-closed-book.

Attribution & license

The Opal system (Synthos + Aleph integration) is Cognis Digital, released under Apache-2.0. Backend models are the property of their creators and used under their respective licenses (linked above) — Opal does not modify or redistribute their weights; it orchestrates them. Cite the base model you run.

The Cognis breakthroughs behind it

• Aleph memory — substrate-agnostic O(N) memory fabric (the core innovation).
• Syntheon — the local-AI full-stack app builder (own every line).
• More at cognis.digital · built by Cognis Digital.

_{Local. Private. Uncensored. Yours. If Opal earns its keep on your hardware, a ⭐ helps others find it.}