---
library_name: sle
tags:
- saccadic-liquid-engine
- cognitive-resonance-artifact
- cpu-runtime
---
# SLE-V2.1-Ω12K-LX

Saccadic is a deployable Cognitive Resonance Artifact from OkeyMeta Ltd. It is built for people who want to run a portable AI system, connect their own tools, and host it anywhere without cloning the private architecture repository. No private repository checkout is required.

## Mission

SLE is a CPU-first path toward artifact-native intelligence: learned state that can move across machines, run close to users, and use external tools without turning the host application into a hidden model. The goal is simple for builders: ship `model.cra`, start Spark, and let Saccadic expose what it selected, argued, remembered, and generated from loaded artifact state.

## Saccadic Highlights

- SLE replaces parameter-count thinking with portable cognitive state. The artifact is the model.
- No tokenizer. No Transformer stack. No private repo checkout.
- `model.cra` carries learned state: memory, liquid ODE coefficients, instruction surfaces, response policy, speech transitions, stream state, facts, and tool/action state.
- Spark is a runtime boundary, not a hidden second model. It loads the artifact, executes declared modes, and returns loaded-state evidence.
- Raw text and raw acoustic input are processed through predictive stream dynamics instead of BPE tokenization or speech-to-text.
- Host tools are executable boundaries. Saccadic selects learned tool paths, emits arguments, consumes returned values, and speaks through artifact state.
- SLE names releases by cognitive capacity notation, not parameter count.

Saccadic is designed for personal assistants, workflow agents, private services, edge systems, desktop apps, and embedded hosts that need a portable AI boundary.

## What You Can Build

- Conversational assistants that carry recent chat history into the artifact runner.
- Workflow agents that select learned tool names and emit auditable argument maps.
- Private customer, operations, research, or device copilots that keep host services as executable boundaries.
- Edge, desktop, and container deployments where `model.cra` and Spark move together.
- OpenAI-compatible chat services for teams that already use SDK-based application code.

## Model Overview

| Field | Value |
| --- | --- |
| Release | `SLE-V2.1-Ω12K-LX` |
| Hugging Face slug | `SLE-V2.1-Omega12K-LX` |
| Model name | `Saccadic` |
| Architecture | Saccadic-Liquid Engine (SLE) |
| Public artifact | `model.cra` |
| Spark runtime | `sle_spark.py` |
| Metrics | `sle_v2_1_release_metrics.json` |
| Requirements | `requirements.txt` |
| Selected training rows | 502,000 |
| Curation failures | 0 |
| Deployment targets | `cli, service, edge, desktop, container` |

This package includes `model.cra`, Spark, requirements metadata, release metrics, the release manifest, and generated host boundaries. The private source repository is not required to run Saccadic.

## Quickstart

Download this Hugging Face model package and keep the files together. The public runtime is OpenAI SDK-compatible: start Spark, point the SDK at the local service, and call `client.chat.completions.create`.
Spark exposes `POST /v1/chat/completions` behind the local `/v1` base URL.

```powershell
python -m pip install -r requirements.txt
python -m pip install openai
python .\sle_spark.py serve-artifact --artifact model.cra --host 127.0.0.1 --port 8765
```

Create one `chat.py` beside `model.cra` and `sle_spark.py`:

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:8765/v1",
    api_key="not-needed",
)

messages = [
    {"role": "system", "content": "Reply naturally and use the latest user turn."},
    {"role": "user", "content": "Hello! Tell me about yourself."},
]

stream = client.chat.completions.create(
    model='SLE-V2.1-Ω12K-LX',
    messages=messages,
    stream=True,
    extra_body={"max_speech_steps": 18},
)

answer = []
evidence = {}
for event in stream:
    piece = event.choices[0].delta.content or ""
    print(piece, end="")
    answer.append(piece)
    extra = getattr(event, "model_extra", {}) or {}
    evidence = extra.get("saccadic", evidence)
print()

messages.append({"role": "assistant", "content": "".join(answer)})
print("tool path:", evidence.get("tool_path"))
print("final value:", evidence.get("final_value"))
```

Expected shape: normal streamed chat text first, then optional loaded-artifact evidence. For arithmetic, tools, facts, and system-instruction turns, the `saccadic` evidence shows selected tool paths, emitted arguments, final values, slot transfers, and replay evidence.

To bind your own tool, keep the same OpenAI SDK call and add `extra_body={"host_tools": ["artifact.tool_name=your_module:your_function"]}`. Spark executes that callable only if `model.cra` selects the learned tool name and emits arguments from artifact state.

## Deployment

- HF repo slug: `SLE-V2.1-Omega12K-LX`
- The release name remains `SLE-V2.1-Ω12K-LX`.
- Declared deployment targets: `cli, service, edge, desktop, container`.
- Do not upload the source repository to run Saccadic.
- Spark runtime can be embedded behind CLI, service, edge, desktop, or container hosts.
- Deployments may bind OS, network, database, browser, robotics, or private business tools by learned artifact tool name.

### Deployment Entry Points

- `cli`: `./sle_spark.py run-artifact --artifact model.cra`
- `service`: `./sle_spark.py serve-artifact --artifact model.cra --host 0.0.0.0 --port 8000`
- `edge`: `python edge_host.py`
- `desktop`: `python desktop_host.py`
- `container`: `Containerfile`

### Included Host Boundaries

- `edge`: `edge_host.py`
- `desktop`: `desktop_host.py`
- `container`: `Containerfile`

## Install

Place `model.cra`, `sle_spark.py`, `SLE_RELEASE.json`, and any declared metrics or requirements metadata in one directory. Then run `python -m pip install -r requirements.txt` from that directory. The runtime command below is the public boundary; users do not install this private repository.

## Direct CLI

Most applications should use the OpenAI-compatible service above. The direct CLI remains available for diagnostics and returns the same loaded-artifact evidence from `model.cra`.

### Edge And Desktop

Use the generated host files when included:

```powershell
python edge_host.py
python desktop_host.py
```

Both read JSON payloads from stdin, forward declared host tools to the shipped runtime, and print loaded-artifact evidence.

### Raw Acoustic Input

Raw acoustic runs pass waveform samples directly; there is no speech-to-text or tokenizer layer:

```powershell
python .\sle_spark.py run-artifact --artifact model.cra --mode acoustic --audio-samples "[0.0,0.17,0.34,0.17,0.0,-0.13,-0.30,-0.13,0.0]" --audio-symbol-score-floor 0.25 --diverse-speech-limit 2
```

## Best Practices

- Keep `model.cra`, Spark, `requirements.txt`, `SLE_RELEASE.json`, and any metrics files in the same deployment directory.
- Use `--avoid-replay` for public demos so exact source-row echoes are surfaced as evidence instead of mistaken for intelligence.
- Bind host tools with `--host-tool artifact.name=module:function`; the host executes tools, while Saccadic selects paths and emits arguments from loaded artifact state.
- Spark includes documented portable primitives for `math.add` and `math.power`; external tools still use explicit host bindings.
- Pass recent conversation as raw text in history mode when you want Saccadic to respond to prior turns.
- Inspect returned JSON fields such as selected tool paths, emitted arguments, final values, stream dynamics, punctuation symbols, slot transfers, and replay evidence.

## Trust And Evidence

Saccadic is an artifact-first release: supported response, history, autonomous, action, acoustic, and system-instruction paths return loaded-state evidence rather than hidden host-written answers. Evidence includes tool paths, emitted arguments, final values, autonomous route records, context transfers, punctuation symbols, Speech Cortex usage counts, system-instruction records, fact attributes, slot transfers, emitted exact-row replay evidence, and blocked replay evidence.

## Training And Selection

- Selected rows: 502,000
- Curation failures: 0


### Training Domains

- arts: 20,080
- biology: 20,080
- chemistry: 20,080
- constitution: 20,080
- conversation: 20,080
- economics: 20,080
- emoji: 20,080
- geography: 20,080
- history: 20,080
- language_es: 20,080
- language_fr: 20,080
- language_ha: 20,080
- language_ig: 20,080
- language_yo: 20,080
- language_zh: 20,080
- law: 20,080
- math: 20,080
- medicine: 20,080
- philosophy: 20,080
- physics: 20,080
- safety: 20,080
- stories: 20,080
- system_instruction: 20,080
- technology: 20,080
- world: 20,080

## Citation

```bibtex
@software{sle_saccadic,
  title = {Saccadic-Liquid Engine: Saccadic Cognitive Resonance Artifact},
  author = {OkeyMeta Ltd},
  version = {SLE-V2.1-Ω12K-LX},
  note = {CPU-first Cognitive Resonance Artifact with Spark runtime}
}
```