Ely-Eye

Local · Multimodal · Long-context

Ely-Eyeby elydora

A gaming PC, a 9B multimodal model, a verifiable 100M-scale visual memory.

Qwen3.5-9B262K → 100M context
Explore the systemGitHub

Three tiers of context

One model reads across three orders of magnitude.

  1. 262KNative · tokens

    Qwen3.5-9B's default window. The stable workspace for live multimodal reading.

  2. 1.01MExtended · tokens

    YaRN rescaling with sparse attention and KV compression for the extreme profile.

  3. 100MMemory · token-equivalent

    A library held as a Context Cartridge — retrieved, cited, and recalled across sessions.

Working principle

A question is compiled, not just prompted.

Ely-Eye treats a question as a program to compile against a library, not a prompt to complete in one window.

The Context Compiler decomposes the question into the modalities it needs and an evidence budget, then plans how to retrieve and compress. Evidence is pulled from whichever tier holds it: the 262K active window for what sits in front of the model, parked KV for recent long context, and the 100M-token memory capsule for the wider library.

What returns is packed into the active window under a verifier contract. Qwen3.5-9B reads the packed evidence and answers evidence-first — every claim tied to a cited atom, with the page, region, or frame it came from.

Before the answer is returned, the verifier resolves each citation against the evidence it was given, grounds it to coordinates, and flags cross-version contradictions. Long-range addressing is then demonstrated with Visual HashHop rather than assumed — the same fifteen-check suite that gates every release.

What it does

It sees, it reads at length, it remembers, and it proves itself.

  1. Sees

    Images, screenshots, PDF pages, video keyframes, interfaces, charts, and tables — read as one stream.

  2. Reads long

    262K native context stays stable; the extreme profile extends physical context to 1.01M tokens.

  3. Remembers

    A whole corpus compiles into a Context Cartridge: vector retrieval, a temporal graph, and learned adapters.

  4. Verifies

    Answers carry cited evidence, and long-range addressing is measured rather than assumed.

How to use it

From a clean machine to a cited answer, end to end.

Deployment targets a Windows host with an NVIDIA GPU and CUDA. Scripts are PowerShell; the CLI is the ely-eye entry point installed into the virtual environment.

  1. Deploy

    Clone the repository

    Everything runs on your own machine — model, memory, and dashboard. Nothing leaves it.

    git clone https://github.com/ZacharyZhang-NY/ely-eye

  2. Install the toolchain

    Creates the virtual environment and installs PyTorch with CUDA, Transformers, PEFT, bitsandbytes, and the ely-eye package.

    .\scripts\install.ps1

  3. Download the models

    Fetches Qwen3.5-9B, the 0.8B context planner, and Qwen3-VL-Embedding-8B into the local Hugging Face cache.

    .\scripts\download-models.ps1

  4. Prepare the runtimes (optional)

    Sets up SGLang, vLLM, and KTransformers under WSL for the 1.01M-token extreme-context profile. The Windows Transformers backend works without this.

    .\scripts\setup-linux-runtimes.ps1

  5. Start the server and dashboard

    Launches the API on 127.0.0.1:8765; serve-frontend.ps1 opens the dashboard on 127.0.0.1:5173.

    .\scripts\serve-backend.ps1

  6. Use

    Compile a package

    PDFs, screenshots, video, and a code repository become Evidence Atoms and a portable Context Cartridge.

    ely-eye ingest .\package --cartridge-name project

  7. Ask across modalities

    In the dashboard, pose a cross-modal question. The answer returns with cited atoms, page and region coordinates, the memory layers it touched, and any contradictions found.

  8. Prove it

    Run Visual HashHop and the fifteen-check suite against the live model — long-range addressing measured, never assumed.

    ely-eye proof-suite

Architecture

A context operating system, compiled end to end.

A question flows down the spine; the Visual Memory OS and Cache Fabric feed the runtime in parallel, and every answer leaves through the verifier.

Proven, not asserted

A fifteen-check suite runs against the live model.

Visual HashHop
Non-semantic, multi-hop visual addressing across 262K context — random hash chains with no OCR shortcut.
Cited evidence
Each answer resolves its citations against the evidence it was given, with citation accuracy measured.
Contradiction lens
Cross-version drift is localized across the full taxonomy: design-token, layout, typography, copy, visual-code, temporal.
100M capsule
The memory capsule commits its segments to a reproducible Memory DNA fingerprint.