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
REQUEST BETA ACCESSSEE 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.

Runs on the models you own
One Omega works with the models you own. If you add your own API key for a frontier provider, the key is stored on your machine and is sent to that provider with each request. HYVE LLM Creator is coming soon.
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.
Hash-chained attestation log
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.

The standalone Omega-core SDK is being built; it is not yet published for public download, so the install lines below do not work yet.

// Cargo.toml: omega-core = "1.0"  (not yet published)
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(())
}