Skip to content

HYVE OMEGA-CORE · DECISION ORCHESTRATION

OMEGA-CORE

4 SIGNALS · DETERMINISTIC · RUST · TYPESCRIPT · PYTHON

Omega-core is the decision orchestrator at the heart of every HYVE agent. Four signals come in — Tide cognition, Trust reputation, Narrator audience, Augur security — and one decision comes out: refuse, clarify, or proceed. The function is deterministic, runs in under 200 nanoseconds per rule, and is fully reconstructible in Observatory.

Determinism is the audit story. Same inputs always produce the same output. Counsel can reproduce any decision; SOCs can replay any action; regulators can verify your gate did what you said it did. No probabilistic LLM mystery between input and decision.

4
Signal inputs
<200 ns
Per rule
Deterministic
Same in, same out
GET ETHER OS — $249.99SEE OMEGA IN THE OS

The decision flow.

Four signals fan in to a deterministic rule engine; one of three decisions fans out.

TIDE
The cognitive state of the operator at request time. Resonant + focused permits more agent autonomy; fatigued or divided narrows the gate.
TRUST
The agent's earned reputation in [0, 1]. Below threshold → automatic refuse. High trust permits proceed without clarification.
NARRATOR
The audience tone of the action's downstream effect. A SOC ticket has different gating than an executive summary.
AUGUR
Static analysis of the action being delegated. Any finding above threshold short-circuits to refuse.
↓
decide(tide, trust, narrator, augur) → Decision
DETERMINISTIC · < 200 NS PER RULE
↓
REFUSE
CLARIFY
PROCEED

decide() is the gate. Omega is the orchestrator.

The four-signal gate is one function. Inside HYVE Ether OS, that gate sits at the center of a full decision orchestrator that runs on your own hardware. These are the in-OS capabilities Omega already ships with — described as capabilities, not benchmarks.

Federates every model you own
Through HYVE LLM Creator, one Omega routes across 35+ LLM providers — bring your own keys; HYVE never sees them.
Generates images and video in chat
Drives the Spark image studio and the Cinema video studio inline — Omega calls the generators as tools, you stay in the conversation.
Persistent memory + world-model
Remember, recall, and auto-learn across sessions. Memory writes are device-local and replayable in Observatory.
Background task execution
Hands a delegated action off to run in the background once the decide() gate returns proceed — you are not blocked waiting on it.
Local-VLM image understanding
Its eyes: an on-device vision-language model lets Omega read and reason over images without anything leaving the machine.
Tamper-evident attestation ledger
Every decision, memory write, and bus event is logged and reconstructible in Observatory — verifiable autonomy, not a black box.

INTEGRATE · RUST · TYPESCRIPT · PYTHON

Decide() in three lines.

// Cargo.toml: omega-core = "1.0"
use omega_core::{Decide, Decision, TideState, TrustScore, NarrativeAudience, AugurReport};

fn main() -> anyhow::Result<()> {
    let decision = Decide::new()
        .tide(TideState::Resonant { coherence: 0.94 })
        .trust(TrustScore::new(0.87))
        .narrator(NarrativeAudience::Soc)
        .augur(AugurReport::clean())
        .evaluate();

    match decision {
        Decision::Proceed                => println!("✓ delegate to agent"),
        Decision::Clarify { reasons }    => println!("? clarify: {reasons:?}"),
        Decision::Refuse  { reasons }    => eprintln!("✗ refuse: {reasons:?}"),
    }
    Ok(())
}