OmegaClaw Install Guide: SingularityNET's Symbolic Reasoning AI Agent
How to install OmegaClaw via Docker, connect it over IRC, and test its symbolic reasoning layer and persistent memory hands-on.
What is OmegaClaw?
OmegaClaw is an open-source agent framework from SingularityNET built on the Hyperon Stack, with its core written in MeTTa, a symbolic programming language closer to Prolog or Lisp than Python. Rather than wrapping a language model in application code and calling it a day, OmegaClaw puts a formal symbolic reasoning layer in charge of the loop, and treats the language model as a component that gets called by that layer rather than the thing running the show. That architectural choice changes what the agent can do: it runs continuously instead of only responding to prompts, it keeps a long-term memory that survives restarts, and it maintains a proof trail so you can inspect how it arrived at a conclusion.
TL;DR
- OmegaClaw runs as a continuous loop rather than a simple request-response cycle, meaning it keeps iterating even when nobody is actively chatting with it.
- The symbolic layer sits above the language model, so the LLM (in this case GLM) gets invoked by the MeTTa-based reasoning core instead of acting as the top-level controller.
- Installation is a single Docker command that pulls the image, and Docker is the recommended path given how many moving parts the system has.
- The agent has no web UI, it communicates only over chat channels like IRC, Telegram, or Slack, with IRC used as the default setup in testing.
- Memory persisted across a full container restart in hands-on testing, with the agent correctly recalling a fact it had been told before the restart.
- A dedicated MeTTa skill lets you talk to the symbolic layer directly, feeding it logical facts with attached truth values so it can derive new conclusions with computed confidence scores.
- The first attempt to query the symbolic layer returned a weaker result than expected (the model asked a clarifying question instead of returning a derived value), but a follow-up prompt asking it to run inference produced an actual truth value.
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
How do you install OmegaClaw?
OmegaClaw ships with Docker as the recommended installation method, largely because of how many components need to work together: a language model endpoint, a chat channel integration, a persistent volume for memory, and the MeTTa-based symbolic core itself. The setup runs as a single Docker command that downloads the image and walks through a guided configuration.
During setup, you choose a chat channel. The options include IRC, Telegram, and Slack, with IRC serving as the simplest default for testing since it just requires joining a channel and claiming your session with a one-time secret. You’re also asked for a model endpoint. OmegaClaw doesn’t lock you into a single provider: you can point it at an OpenAI-compatible API endpoint, an OpenRouter key, or a locally served model through something like llama.cpp. The agent doesn’t care which LLM sits behind the symbolic layer, as long as it responds to the standard API format.
Once the container is running, you can confirm the loop is alive by checking the container logs. The logs show repeated iterations and API calls returning successful responses, which is the visible evidence that the agent is continuously cycling in the background rather than sitting idle between messages.
How does the symbolic reasoning layer actually work?
The core of OmegaClaw is written in MeTTa, a language built for the Hyperon Stack that handles facts, rules, and logical derivation rather than general-purpose scripting. This is a genuinely different foundation than most agent frameworks, which tend to be Python glue code around an LLM call. MeTTa’s lineage traces back to older symbolic AI languages like Lisp and Prolog, the kind of tools that dominated AI research before the current generative AI wave.
In practice, this shows up as a specific skill that lets you bypass the language model and talk to the symbolic layer directly. You can feed it formal statements, facts paired with truth values that carry both a strength and a confidence measure, and ask the system to derive new conclusions from them. The point of this layer is that confidence isn’t just a language model sounding certain. It’s a number computed by the symbolic engine based on the logical structure of what you fed it.
In a hands-on test, the first attempt to invoke this didn’t work as advertised: instead of returning a derived truth value, the agent asked a clarifying question, meaning the facts were stored but no inference was actually run. A second, more explicit prompt asking the system to run inference on the stored facts did produce a derived conclusion with a computed truth value attached. That gap between the first and second attempts is worth flagging: the symbolic layer is real, but getting it to actually compute and surface a result isn’t always the first thing that happens when you ask.
Does memory actually persist across restarts?
This was tested directly, and it held up. The agent was told to remember a specific fact (in the test case, a detail about a YouTube channel’s content and posting schedule), and the container was then fully restarted. Long-term memory in OmegaClaw is stored in a Docker volume, which is designed specifically so restarting the container doesn’t wipe stored state.
After the restart, the agent rejoined its IRC channel and, when asked what it knew about the earlier fact, correctly recalled it. This is a meaningful distinction from typical chatbot sessions, where context disappears the moment a conversation window closes or a server resets. For anyone building or evaluating persistent agents, this kind of memory durability is one of the more practical, testable claims to verify before trusting a framework with longer-running tasks.
Is OmegaClaw worth setting up?
For anyone specifically interested in symbolic AI, or in agents that maintain state and reasoning history over time rather than resetting every session, OmegaClaw offers something genuinely different from typical LLM wrapper frameworks. The installation itself is straightforward if Docker is already in place, and the core claims (persistent memory, a continuous loop, a real symbolic layer) held up under direct testing, though the symbolic inference skill required a more explicit follow-up prompt to actually produce a derived result rather than just storing facts.
It’s not a polished consumer tool. There’s no web interface, interaction happens entirely through chat channels like IRC, Telegram, or Slack, and getting the symbolic reasoning skill to behave as documented took some trial and error. But for developers curious about what it looks like to put an LLM underneath a formal logic layer instead of on top of one, it’s a working, inspectable example rather than just an architectural pitch.
Frequently Asked Questions
What language model does OmegaClaw use?
OmegaClaw isn’t tied to one model. It works with any OpenAI-compatible API endpoint, OpenRouter, or a locally served model through tools like llama.cpp. In testing, a model called GLM was used, but the framework treats the LLM as a swappable component called by the symbolic layer, not a fixed dependency.
Does OmegaClaw have a web interface?
No. OmegaClaw communicates entirely through chat channels, specifically IRC by default, with support for Telegram and Slack as alternatives. There is no browser-based dashboard for interacting with it.
What is MeTTa and why does it matter here?
MeTTa is the symbolic programming language used to write OmegaClaw’s core, part of the Hyperon Stack from SingularityNET. It’s closer in design to Prolog or Lisp than to Python, and it’s built for expressing facts, rules, and logical derivation rather than general procedural code. It’s what allows OmegaClaw to compute confidence values from logical facts rather than just having the language model assert a confidence level in text.
Can OmegaClaw run shell commands?
The agent framework includes shell execution capability, which is why it ships with a security policy file in its configuration. This matters because OmegaClaw can also rewrite its own skills and logic while running, so the policy file is meant to constrain what it’s allowed to execute.
Is memory guaranteed to survive every restart?
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
In direct testing, memory persisted correctly across a full container restart because long-term memory is stored in a Docker volume rather than inside the container itself. That said, this was a single test case, not an exhaustive stress test, so edge cases around memory persistence under different failure conditions weren’t explored.