Omega (SingularityNET)

A neuro-symbolic agent framework from singularitynet, written in MeTTa on the OpenCog Hyperon stack: an LLM does the language work and hands every inference step to a formal logic engine (NAL, Non-Axiomatic Logic, or PLN, Probabilistic Logic Networks) whose truth-value arithmetic the model cannot touch. The README's line: "Unlike reactive, session-based agents, Omega operates in a continuous execution loop, managing its own goals and providing auditable proof trails for its reasoning." Apache-2.0, Python + MeTTa, 135★ / 66 forks, repo created 2026-04-02, last pushed 2026-09-18, tagged v0.1.19. Read 2026-09-20: README, docs/introduction.md, docs/reference-internals-loop.md, docs/reference-failure-modes.md, and the src/ tree. The public face is Oma, a Telegram bot at t.me/ASI_Alliance.

The pitch and the numbers pull in opposite directions, and the project's own docs supply both. That is the reason to read it.

The mechanism — call-and-wait

One function, (omega $k) in src/loop.metta, tail-recurses forever. Each turn: pull a message from the channel, assemble PROMPT + SKILLS + LAST_SKILL_USE_RESULTS + HISTORY + TIME, call the LLM (Anthropic by default; OpenAI, ASICloud/MiniMax, ASI:One, OpenRouter), repair unbalanced parentheses, parse the reply as a tuple of up to five skill s-expressions, run each, append the exchange and any errors to memory/history.metta, sleep, recurse. When no message has arrived and a countdown hits zero the loop skips the LLM call and idles until nextWakeAt, then grants a few extra turns for "self-initiated work". That is the goal-management claim, in code.

Reasoning happens inside step five. A skill tuple containing (metta (|- ...)) (NAL) or (metta (|~ ...)) (PLN) suspends generation, runs the engine, and injects the result atoms (e.g. (robin --> animal) (stv 0.72 0.32)) into the next prompt as immutable data. Every atom carries (stv frequency confidence); three action thresholds gate what the agent may act on (ACT f ≥ 0.6 ∧ c ≥ 0.5, HYPOTHESIZE f ≥ 0.3 ∧ c ≥ 0.2, else IGNORE). The division of labour is explicit: the LLM picks premises, assigns the initial truth values, chooses the rule and decides when to stop; the engine owns how truth propagates and whether the conclusion follows. The introduction's promise: "Confidence cannot be inflated by rhetoric."

Three memory tiers: pin (one volatile slot, overwritten each cycle), remember/query (embeddings in ChromaDB, survives restarts), and the AtomSpace itself (atomized, truth-valued knowledge the engines read). Skills are plain s-expressions — (remember "..."), (shell "ls"), (send ...) — defined in src/skills.metta; channels are IRC, Telegram, Slack, Mattermost. Secrets (LLM keys, bot tokens) are read from environment variables that deliberately lack the OMEGA_ prefix the config loader looks for, "to prevent agent accessing them": a permission control implemented as a naming convention.

What the project measured on itself

docs/reference-failure-modes.md is the most candid document in this spoke's framework corpus. The numbers come from Max Botnick, the maintainers' own Omega agent, over 3,100+ continuous cycles (4,500+ with error instrumentation), and the doc says Max "self-authored the whitepaper from which this documentation draws," so these are Omega-on-Omega figures, "not a formal benchmark."

• The LLM premise layer is where it breaks. LLM-supplied facts were right ~55% of the time against verified sources; asymmetric relations were written backwards up to 16.6% of the time; self-assigned confidence ran ~15 points high (an LLM c = 0.70 averaged ~0.55 against ground truth). "The symbolic engine cannot detect these errors — they look well-formed to it."
• The engine amplifies, not absorbs. Deduction confidence is c₁ × c₂ × f₁ × f₂ with no floor: from c = 0.9 per premise, hop three is already below 0.5, the ACT line, and hop four is ~0.25. Abduction has a practical ceiling near 0.45 and cannot clear ACT on its own. The doc names the result "GIGO amplification", and its worst case "confabulation under mathematical cover": a fabricated premise comes out stamped (stv 0.81 0.73).
• The most frequent failure is the LLM not emitting a valid s-expression at all. Across 4,500+ cycles the top error categories are NOTHING_WAS_DONE, multi-command parse failures, and unbalanced parentheses, "the most frequent failure mode in the entire system, not occasional glitches." Error rates rise measurably when a human message interrupts autonomous work.
• Missing rules. NAL-3 decomposition is not functional; two ==> premises do not chain; PLN abduction "returns empty in practice"; conjunctive antecedents cannot be represented.
• Self-improvement, three attempts, three failures. A confabulation-mitigation script the agent wrote was never invoked during confabulation; a self-model tool crashed on wrong file paths; a MeTTa analogy patch returned True instead of conclusions. "Validate externally before relying on them."
• Variance and hindsight. Ambiguous claims show up to 3× the assignment variance of clear ones (ostrich --> dangerous: stv 0.567 ± 0.103 across runs); rationalizing a conclusion after the fact moved frequency ~50% and inflated confidence +14%, which is the doc's argument that reasoning must be in-loop rather than retroactive.

The four-layer "defense stack" (novelty discount c × (1 − novelty), the thresholds, an expectation-ranked attention budget, and an adversarial-premise regression suite) is described as holding in "all tested cases" — the suite is not published in the docs read.

Two claims checked against the tree

• "Approximately 200 lines of MeTTa." src/loop.metta is 119 lines. The MeTTa core the module map lists (run, lib_omega, src/*.metta) sums to ~594 lines, before lib_nal.metta, lib_pln.metta and the Python bridges. The claim is true of the loop; the core is about three times that.
• The Docker image is singularitynet/omegaclaw and the container is named omegaclaw; the README never says why. Read beside openclaw and the hermes claw migrate command in hermes-agent, the name is the third framework in this spoke to borrow the suffix.

Why it belongs here

An agent-framework with a loop, skills, memory tiers, multi-channel gateway and multi-provider LLM access, the same anatomy as hermes-agent and openclaw, but the only one whose distinctive layer is a formal engine the model cannot overrule. That makes it the first instance of neuro-symbolic-agent in the corpus, and its own docs are the first quantified account of where that design moves the failure rather than removing it. It is also a negative instance for self-improving-agents: the loop that lets the agent modify "its own skills, memory, and operational logic at runtime" (disclaimer) produced three documented self-patches that did not work.

Caveats: every number is first-party and self-measured by the agent under test; stars are modest for a project of this age; the README's install path clones a sibling repo (trueagi-io/PeTTa, a Prolog-hosted MeTTa, which is why SWI-Prolog 10.0.2 is required) rather than the project itself; memory import works only inside Docker. The legal disclaimer is unusually direct about the risk surface (shell execution, file modification, prompt injection, unaudited third-party skills) and tells the user to run it "in an isolated environment with the minimum permissions necessary."

Related

neuro-symbolic-agent · singularitynet · agent-framework · self-improving-agents · agent-memory · durable-agents · agent-permission-model · hermes-agent · openclaw · llm-provider · loop-engineering