OkeyMetaLtd/SLE-V1.0-Omega10K-LX

Saccadic: SLE-V1.0-Ω10K-LX

Saccadic is the first public Cognitive Resonance Artifact from the Saccadic-Liquid Engine (SLE), created by OkeyMeta Ltd.

This release is not a Transformer checkpoint and it is not a repository upload. It publishes the model state as model.cra plus the Spark runtime needed to wake that state. The source repository, training pipeline, and internal IP are not included.

Mission

SLE explores a CPU-first path toward general intelligence where behavior lives in portable mathematical state instead of a giant framework-bound parameter dump. Saccadic combines:

• Predictive semantic chunking over raw streams instead of BPE tokenization.
• Hyperdimensional memory for concept, fact, and tool-state binding.
• Liquid continuous-time dynamics for stream surprise and state evolution.
• Speech Cortex transitions for learned English, punctuation, emoji, and response composition.
• Artifact-backed tool use, system-instruction following, identity, autonomous self-talk, and replay evidence.

The long-term objective is simple: build intelligence that can learn, adapt, act, and surprise us without depending on Transformer-style tokenization, backprop training loops, or repo-side hidden behavior.

What Is Included

• model.cra - the public Cognitive Resonance Artifact.
• sle_spark.exe - standalone Spark loader/runtime contract for Windows.
• SLE_RELEASE.json - release manifest with public and internal artifact metadata.
• sle_v1_10k_stress.json - V1 stress evidence.
• sle_v1_10k_release_smoke.json - public-bundle smoke evidence.
• requirements.txt - optional Python inspection dependency contract.
• README.md - this model card and run guide.

What This Release Can Do

V1 is a compact, auditable first release. It is not presented as a trillion-token LLM replacement. It is built to prove that the SLE artifact path can carry real behavior:

• Load outside the source repo as model.cra.
• Run through Spark without PyTorch, TensorFlow, Transformers, or tokenizers.
• Parse raw multilingual/numeric streams such as Saccadicpower٥^٧..
• Select a learned custom tool and emit its argument map.
• Answer through learned Speech Cortex state with punctuation and slot transfer.
• Speak autonomously from raw context using learned route and initiative state.
• Follow serialized system-instruction rows without host-side formatting.
• Preserve exact-row replay evidence so demonstrations cannot hide row echo.
• Know its model identity and creator through artifact facts: Saccadic, created by OkeyMeta Ltd.

Deployment Paths

1. Local Spark Runtime

Run the artifact directly with the included Spark executable:

.\sle_spark.exe model.cra

This verifies that Spark can load the public artifact and solve the core Liquid ODE contract outside the source repository.

2. Embedded Runtime

Bundle model.cra with Spark inside a desktop app, local service, research probe, or edge deployment. Spark is the executable boundary; the intelligence lives in the artifact.

3. Python Inspection Boundary

The Python examples below require the SLE Python inspection package to be installed separately from an authorized wheel or source distribution. This HF model repository intentionally does not include the source repo.

python -m pip install -r requirements.txt

Quick Start: Load The Artifact

from sle.spark import SparkRuntime

runtime = SparkRuntime.load("model.cra")

Define Your Own Tool

Host tools are executable boundaries. The artifact still selects the tool, emits the arguments, records cognition, and generates the response.

from sle.spark import SparkRuntime

runtime = SparkRuntime.load("model.cra")

def power(base: object, exponent: object) -> int:
    return int(base) ** int(exponent)

run = runtime.drive_text_stream_autonomous_generated(
    "Saccadicpower٥^٧.",
    tools={"math.power": power},
    dt=0.05,
    max_speech_steps=20,
    avoid_replay=True,
)

if not run.success:
    raise RuntimeError(run.error)

action = run.drive.action
print(action.cognition.steps[0].plan.tool_name)
print(action.cognition.steps[0].plan.arguments)
print(action.cognition.final_value)
print(action.response.text)
print(action.response.slot_transfers)
print([(chunk.text, chunk.boundary) for chunk in run.stream.chunks])

Expected V1 evidence for this held-out probe includes:

math.power
{"base": 5, "exponent": 7}
78125
The power is 78125.

Autonomous Learned Speech

Saccadic can speak from raw context without the host supplying an answer.

from sle.spark import SparkRuntime

runtime = SparkRuntime.load("model.cra")

self_talk = runtime.drive_text_stream_autonomous_generated(
    "Saccadic notices curiosity.",
    tools={},
    dt=0.05,
    max_speech_steps=20,
    compose_speech=True,
    prefer_composed=True,
    avoid_replay=True,
    diverse_speech_limit=3,
)

if not self_talk.success:
    raise RuntimeError(self_talk.error)

speech = self_talk.drive.speech
print(self_talk.drive.route.record_name)
print(speech.decision.context_transfers)
print(speech.response.text)
print(speech.response.algorithm)
print(speech.response.composed)
print(speech.response.trajectory_names)
print(speech.response.punctuation_symbols)
print(speech.response.emoji_symbols)
print(speech.response.transition_use_counts_before)
print(speech.response.transition_use_counts_after)

System-Instruction Following

System instructions are learned artifact state. The runtime does not wrap answers with hidden prompt logic.

from sle.spark import SparkRuntime
from sle.curriculum import system_instruction_context_text

runtime = SparkRuntime.load("model.cra")

system_stream = system_instruction_context_text(
    "Put deliberation inside <thoughts></thoughts> before the answer.",
    "Name one calm color.",
)

run = runtime.respond_text_stream_generated(
    system_stream,
    tools={},
    dt=0.05,
    max_speech_steps=18,
    compose_speech=True,
    prefer_composed=True,
    avoid_replay=True,
    avoid_texts=(
        "<thoughts>Blue is cool.</thoughts> Blue is cool.",
        "<thoughts>Blue is cool.</thoughts> I choose Blue is cool.",
        "Blue is cool.",
    ),
)

if not run.success:
    raise RuntimeError(run.error)

print(run.instruction.record_name)
print(run.cognition.steps[0].plan.arguments)
print(run.cognition.final_value)
print(run.response.text)
print(run.response.composed)
print(run.response.trajectory_names)
print(run.response.slot_transfers)
print(run.response.blocked_replay_evidence)
print(run.response.emitted_replay_evidence)

This probe should produce a composed non-exact answer such as:

<thoughts>I choose Blue is cool.</thoughts> Blue is cool.

The exact source rows remain visible as replay evidence; a passing path must not emit them as the final answer.

Conversational History

Saccadic can receive previous chat turns in the raw stream and select the newest parseable user turn without scanning backward for an easier answer.

from sle.spark import SparkRuntime

runtime = SparkRuntime.load("model.cra")

run = runtime.respond_text_stream_generated_with_history(
    "User: hello Saccadic. Assistant: I am listening. User: Who created you?",
    tools={},
    dt=0.05,
    max_speech_steps=22,
    compose_speech=True,
    prefer_composed=True,
    avoid_replay=True,
)

if not run.success:
    raise RuntimeError(run.error)

turn = run.turn
print(run.history_segments)
print(run.selected_symbols)
print(turn.cognition.steps[0].plan.arguments)
print(turn.cognition.final_value["creator"])
print(turn.response.text)
print(turn.response.slot_transfers)

Use Cases

• Local CPU-first AI research and artifact inspection.
• Tool-calling agents where the model emits auditable argument maps.
• Edge deployments that need a compact runtime boundary.
• Experiments in tokenizer-free raw stream parsing.
• Self-contained AI demos where source repo access is not required.
• Safety and instruction-following probes with replay evidence.
• Multilingual and typo-tolerant stream experiments.

V1 Evidence

The included stress report records all declared V1 checks as passing:

• self-identity and OkeyMeta Ltd creator recall
• custom tool success with emitted argument maps
• custom tool failure recording
• autonomous learned speech
• autonomous action success
• autonomous action failure recording
• system-instruction following
• system-instruction non-replay composition

The public release smoke report records:

• autonomous self-talk: passed
• Unicode raw-stream tool use: passed
• system-instruction following: passed
• stream dynamics evidence: passed

Dataset ledger summary:

• selected rows: 10,000
• curation failures preserved: 6
• lanes: world, history, physics, chemistry, biology, math, law, constitution, safety, conversation, stories, system-instruction, emoji, technology, medicine, economics, geography, philosophy, arts, French, Spanish, Chinese, Yoruba, Hausa, Igbo, identity, tool use, autonomous speech, and autonomous action

Important Boundary

This is a V1 artifact release. It is a serious step toward the SLE mission, not a claim that all frontier-model capabilities are solved. The release is designed to make capability evidence inspectable: selected tool paths, emitted argument maps, final cognition values, stream chunks, slot transfers, punctuation, emoji, transition paths, and replay evidence are all visible.

Citation

@software{okeymeta_saccadic_sle_v1,
  title = {Saccadic: SLE-V1.0-Ω10K-LX Cognitive Resonance Artifact},
  author = {OkeyMeta Ltd},
  year = {2026},
  version = {SLE-V1.0-Ω10K-LX},
  note = {Saccadic-Liquid Engine public artifact release with Spark runtime}
}