OkeyMetaLtd/SLE-V2.0-Omega10K-LX

SLE-V2.0-Ω10K-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.0-Ω10K-LX
Hugging Face slug	SLE-V2.0-Omega10K-LX
Model name	Saccadic
Architecture	Saccadic-Liquid Engine (SLE)
Public artifact	model.cra
Spark runtime	sle_spark.py
Metrics	sle_v2_release_metrics.json
Requirements	requirements.txt
Selected training rows	500,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, keep the files together, install the public runtime dependencies, then run the shipped Spark boundary:

python -m pip install -r requirements.txt
python .\sle_spark.py run-artifact --artifact model.cra --mode autonomous --text "Saccadic notices curiosity." --avoid-replay --diverse-speech-limit 4

The command returns JSON from loaded artifact state: generated text, selected route or tool path when relevant, emitted arguments, final values, stream dynamics, Speech Cortex slot transfers, learned punctuation or emoji symbols, and replay evidence.

Deployment

• HF repo slug: SLE-V2.0-Omega10K-LX
• The release name remains SLE-V2.0-Ω10K-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
• container: Containerfile
• desktop: python desktop_host.py
• edge: python edge_host.py
• service: ./sle_spark.py serve-artifact --artifact model.cra --host 0.0.0.0 --port 8000

Included Host Boundaries

• container: Containerfile
• desktop: desktop_host.py
• edge: edge_host.py

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.

Operating Modes

Autonomous learned speech:

python .\sle_spark.py run-artifact --artifact model.cra --mode autonomous --text "Saccadic notices curiosity." --avoid-replay --diverse-speech-limit 4

Response stream with a system instruction:

python .\sle_spark.py run-artifact --artifact model.cra --mode response --text "System: Reply directly without visible thoughts. User: Name one calm color."

Conversation history context:

python .\sle_spark.py run-artifact --artifact model.cra --mode history --text "User: Name one calm color. Assistant: Blue is cool. User: Who created you?"

Repeated autonomous turns write and reload the artifact between turns. Inspect autonomous_self_talk_unique_text_count, autonomous_self_talk_distinct_punctuation_symbols, per-turn Speech Cortex usage counts, emitted exact-row replay evidence, and blocked replay evidence:

python .\sle_spark.py run-artifact --artifact model.cra --mode autonomous --text "Saccadic notices curiosity." --turns 2 --diverse-speech-limit 4 --punctuation-floor 2 --output-artifact saccadic_after_self_talk.cra --avoid-replay --avoid-text "I am ExampleModel, created by Example Lab."

Full Python Examples

These examples use only the shipped Spark runtime and public model.cra. They do not import the private SLE package; the Python process is only a host boundary that sends text, receives JSON, and prints loaded-artifact evidence.

System Instructions

Pass a system-instruction turn and inspect success, selected instruction, cognition value, slot transfers, stream dynamics, error state, and replay evidence:

from __future__ import annotations

import json
import subprocess
import sys
from pathlib import Path

RUNTIME = Path(__file__).with_name('sle_spark.py')
ARTIFACT = Path(__file__).with_name("model.cra")


def spark_command() -> list[str]:
    if RUNTIME.suffix.lower() in {".py", ".pyz"}:
        return [sys.executable, str(RUNTIME)]
    return [str(RUNTIME)]


def run_saccadic(mode: str, text: str, *extra: str) -> dict[str, object]:
    completed = subprocess.run(
        spark_command() + [
            "run-artifact",
            "--artifact", str(ARTIFACT),
            "--mode", mode,
            "--text", text,
            *extra,
        ],
        check=False,
        capture_output=True,
        text=True,
        encoding="utf-8",
    )
    output = completed.stdout or completed.stderr
    payload = json.loads(output)
    payload["returncode"] = completed.returncode
    return payload


payload = run_saccadic(
    "response",
    "System: Reply directly without visible thoughts. User: Who created you?",
    "--avoid-replay",
)

for key in (
    "success",
    "returncode",
    "error",
    "text",
    "instruction_record",
    "arguments",
    "final_value",
    "slot_transfers",
    "stream",
    "emitted_replay_evidence",
    "blocked_replay_evidence",
):
    print(key, json.dumps(payload.get(key), ensure_ascii=False))

Reasoning Evidence

Saccadic exposes reasoning as artifact evidence: selected tool paths, emitted arguments, cognition values, stream dynamics, slot transfers, and replay checks. The host executes a declared tool only after the artifact selects the learned tool name and arguments.

Example crm_tools.py:

def lookup_customer(customer_id: object) -> dict[str, object]:
    return {
        "customer_id": str(customer_id),
        "tier": "enterprise",
        "renewal_days": 19,
    }

Example reasoning_evidence.py:

from __future__ import annotations

import json
import subprocess
import sys
from pathlib import Path

RUNTIME = Path(__file__).with_name('sle_spark.py')
ARTIFACT = Path(__file__).with_name("model.cra")


def spark_command() -> list[str]:
    if RUNTIME.suffix.lower() in {".py", ".pyz"}:
        return [sys.executable, str(RUNTIME)]
    return [str(RUNTIME)]


def run_saccadic(mode: str, text: str, *extra: str) -> dict[str, object]:
    completed = subprocess.run(
        spark_command() + [
            "run-artifact",
            "--artifact", str(ARTIFACT),
            "--mode", mode,
            "--text", text,
            *extra,
        ],
        check=False,
        capture_output=True,
        text=True,
        encoding="utf-8",
    )
    output = completed.stdout or completed.stderr
    payload = json.loads(output)
    payload["returncode"] = completed.returncode
    return payload


payload = run_saccadic(
    "autonomous",
    "Look up customer CUST-42 and summarize renewal state.",
    "--host-tool", "crm.lookup_customer=crm_tools:lookup_customer",
    "--avoid-replay",
)

reasoning_keys = (
    "success",
    "returncode",
    "error",
    "route",
    "tool_path",
    "arguments",
    "final_value",
    "slot_transfers",
    "punctuation_symbols",
    "stream",
    "emitted_replay_evidence",
    "blocked_replay_evidence",
)
for key in reasoning_keys:
    print(key, json.dumps(payload.get(key), ensure_ascii=False))

Conversational Chat

Keep recent turns in the host and send them through history mode. Saccadic selects the newest parseable suffix from the supplied transcript and returns the loaded-artifact reply plus evidence.

from __future__ import annotations

import json
import subprocess
import sys
from pathlib import Path

RUNTIME = Path(__file__).with_name('sle_spark.py')
ARTIFACT = Path(__file__).with_name("model.cra")


def spark_command() -> list[str]:
    if RUNTIME.suffix.lower() in {".py", ".pyz"}:
        return [sys.executable, str(RUNTIME)]
    return [str(RUNTIME)]


def run_saccadic(mode: str, text: str, *extra: str) -> dict[str, object]:
    completed = subprocess.run(
        spark_command() + [
            "run-artifact",
            "--artifact", str(ARTIFACT),
            "--mode", mode,
            "--text", text,
            *extra,
        ],
        check=False,
        capture_output=True,
        text=True,
        encoding="utf-8",
    )
    output = completed.stdout or completed.stderr
    payload = json.loads(output)
    payload["returncode"] = completed.returncode
    return payload


history: list[tuple[str, str]] = []


def ask(user_text: str) -> dict[str, object]:
    history.append(("User", user_text))
    transcript = " ".join(f"{role}: {text}" for role, text in history)
    payload = run_saccadic("history", transcript, "--avoid-replay")
    reply_text = str(payload.get("text", ""))
    history.append(("Assistant", reply_text))
    return payload


first = ask("Who created you?")
second = ask("Use the latest chat context and say what you remember.")

for payload in (first, second):
    print(json.dumps({
        "text": payload.get("text"),
        "success": payload.get("success"),
        "returncode": payload.get("returncode"),
        "error": payload.get("error"),
        "selected_segment_index": payload.get("selected_segment_index"),
        "selected_suffix_start": payload.get("selected_suffix_start"),
        "slot_transfers": payload.get("slot_transfers"),
        "punctuation_symbols": payload.get("punctuation_symbols"),
        "stream": payload.get("stream"),
        "emitted_replay_evidence": payload.get("emitted_replay_evidence"),
    }, ensure_ascii=False))

Agentic Use

Bind host tools by learned artifact tool name. Saccadic selects the tool path, emits the argument map, consumes the returned host value, and generates the reply through artifact state.

Example crm_tools.py:

def lookup_customer(customer_id: object) -> dict[str, object]:
    record = crm_client.lookup_customer(str(customer_id))
    return {
        "customer_id": record.id,
        "tier": record.tier,
        "renewal_days": record.renewal_days,
    }

Run a custom tool-bound turn:

python .\sle_spark.py run-artifact --artifact model.cra --mode autonomous --text "Look up customer CUST-42 and summarize renewal state." --host-tool "crm.lookup_customer=crm_tools:lookup_customer" --avoid-replay

For repeated tool-backed action turns, inspect autonomous_action_unique_text_count, autonomous_action_distinct_punctuation_symbols, autonomous_action_tool_paths, autonomous_action_arguments, autonomous_action_final_values, autonomous_action_slot_transfers_by_turn, autonomous_action_transition_use_counts_before_turn, autonomous_action_transition_use_counts_after_turn, emitted exact-row replay evidence, and blocked replay evidence:

python .\sle_spark.py run-artifact --artifact model.cra --mode autonomous --text "Look up customer CUST-42 and summarize renewal state." --turns 3 --diverse-speech-limit 3 --host-tool "crm.lookup_customer=crm_tools:lookup_customer" --output-artifact saccadic_after_actions.cra --avoid-replay

HTTP Service

Start the HTTP boundary:

python .\sle_spark.py serve-artifact --artifact model.cra --host 0.0.0.0 --port 8000

Send JSON to POST /run:

{
  "mode": "response",
  "text": "System: Reply directly without visible thoughts. User: Name one calm color."
}

The service returns selected instructions, selected tool paths, emitted arguments, final values, Speech Cortex slot transfers, stream dynamics, and replay evidence.

OpenAI-Compatible Chat API

The same service exposes POST /v1/chat/completions for OpenAI SDK clients. Start the artifact service, then point the SDK at the local Spark boundary:

python .\sle_spark.py serve-artifact --artifact model.cra --host 127.0.0.1 --port 8765
python -m pip install openai

Example chat_app.py:

from __future__ import annotations

import json
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."},
]


def ask(user_text: str) -> str:
    messages.append({"role": "user", "content": user_text})
    completion = client.chat.completions.create(
        model='SLE-V2.0-Ω10K-LX',
        messages=messages,
        extra_body={
            "max_speech_steps": 18,
            "avoid_texts": [],
        },
    )
    raw = completion.model_dump()
    reply = completion.choices[0].message.content or ""
    messages.append({"role": "assistant", "content": reply})
    print(json.dumps({
        "text": reply,
        "selected_symbols": raw["saccadic"].get("selected_symbols"),
        "selected_suffix_start": raw["saccadic"].get("selected_suffix_start"),
        "tool_path": raw["saccadic"].get("tool_path"),
        "arguments": raw["saccadic"].get("arguments"),
        "final_value": raw["saccadic"].get("final_value"),
        "slot_transfers": raw["saccadic"].get("slot_transfers"),
        "replay": raw["saccadic"].get("emitted_replay_evidence"),
    }, ensure_ascii=False))
    return reply


ask("Who created you?")
ask("Use the latest chat context and say what you remember.")

Tool-bound SDK request:

tool_completion = client.chat.completions.create(
    model='SLE-V2.0-Ω10K-LX',
    messages=[
        {"role": "system", "content": "Use the declared host tool when the artifact selects it."},
        {"role": "user", "content": "Look up customer CUST-42 and summarize renewal state."},
    ],
    extra_body={
        "host_tools": ["crm.lookup_customer=crm_tools:lookup_customer"],
        "max_speech_steps": 18,
    },
)
tool_raw = tool_completion.model_dump()
print(json.dumps({
    "text": tool_completion.choices[0].message.content,
    "tool_path": tool_raw["saccadic"].get("tool_path"),
    "arguments": tool_raw["saccadic"].get("arguments"),
    "final_value": tool_raw["saccadic"].get("final_value"),
    "slot_transfers": tool_raw["saccadic"].get("slot_transfers"),
    "replay": tool_raw["saccadic"].get("emitted_replay_evidence"),
}, ensure_ascii=False))

Streaming response:

stream = client.chat.completions.create(
    model='SLE-V2.0-Ω10K-LX',
    messages=messages + [{"role": "user", "content": "Continue from the latest chat context."}],
    stream=True,
    extra_body={
        "max_speech_steps": 18,
    },
)

evidence = None
for event in stream:
    delta = event.choices[0].delta.content or ""
    print(delta, end="")
    extra = getattr(event, "model_extra", {}) or {}
    if "saccadic" in extra:
        evidence = extra["saccadic"]
print()
print(json.dumps(evidence, ensure_ascii=False))

Edge And Desktop

Use the generated host files when included:

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:

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: 500,000
• Curation failures: 0

Training Domains

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

Citation

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