File size: 3,954 Bytes
4af471f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
---

language: en
license: apache-2.0
tags:
  - reasoning
  - agent
  - world-model
  - long-horizon
  - code
  - proof-of-concept
datasets:
  - Qwen/AgentWorldBench
  - datacurve/deep-swe
metrics:
  - pass@1
model_name: OMEGA-Reasoner
---


# OMEGA-Reasoner (POC)

⚠️ **This is a proof-of-concept** β€” a small-scale demonstration of a
self-contained LLM-driven agent framework.  It is **not** a frontier
model and is **not** intended to compete with production models on
public leaderboards such as DeepSWE.

## Honest positioning

| Property | This repo | DeepSeek-V4.1-Flash (Top-1 DeepSWE) |
|---|---|---|
| Parameters | β‰ˆ 100K (configurable) | 35B-class |
| Training data | none (synthetic / hand-coded) | trillions of tokens |
| Pass@1 on DeepSWE | **not measured** | 74.2 |
| Status | research POC | production model |

We do not submit to the official DeepSWE leaderboard.  The integration
code (`deep_swe.py`) is provided for educational and self-evaluation
purposes only.

## What this model is

`OMEGA-Reasoner` is a self-contained **language world model** + **autonomous

agent** framework.  It implements:

- HMoE-D reasoner: hierarchical mixture-of-experts with dynamic routing
- AGI_AgentWorld: full cognitive agent with episodic / semantic / procedural

  memory, ReAct loop, Tree-of-Thoughts planning, Reflexion-style

  self-correction, and constitutional guardrails

- AgentWorldBench adapter: 5-dim scoring (format, factuality, consistency,

  realism, quality)

- DeepSWE adapter: Harbor-format task loader + verifier runner



## Why this repo exists



To show that a complete agent framework β€” including memory, planning,

tool-use, self-correction, and benchmark adapters β€” can be implemented

from scratch without any external LLM API.  It is meant as a research

artifact, not a competitive submission.



## How to use



```python

from evo.agi_agent_world   import AGIAgentWorld

from evo.agentworld_bench  import load_all, WorldModelAgent, evaluate

from evo.deep_swe          import load_all_tasks, run_benchmark



# 1) Run a single goal

agi = AGIAgentWorld()

result = agi.run("Buy coffee by noon")



# 2) Evaluate on AgentWorldBench (synthetic data)

records = load_all("data/agentworldbench_synth")

rep     = evaluate(WorldModelAgent(), records)

print(rep.overall)



# 3) Run on DeepSWE tasks (synthetic seed data)

tasks   = load_all_tasks("data/deepswe_synth")
summary = run_benchmark(tasks)

print(summary.pass_at_1)

```



## Files



- `agi_agent_world.py`    β€” autonomous agent (memory, planning, tools)

- `omega_arch.py`         β€” HMoE-D model definition
- `omega_nlu.py`          β€” NLU engine (sentences, frames, FOL)
- `omega_math.py`         β€” math reasoning primitives
- `omega_physics.py`      β€” physics reasoner
- `omega_meta.py`         β€” meta-cognition / audit
- `omega_quant.py`        β€” quantization utilities
- `agentworld_bench.py`   β€” AgentWorldBench loader + 5-dim scorer
- `deep_swe.py`           β€” DeepSWE loader + verifier
- `tests/`                β€” unit tests (78+ tests, all passing)

## Test results

The repository ships with 78+ unit tests covering metrics, agents,
benchmarks, and the cognitive core.  All tests pass on the included
synthetic fixtures.

## Limitations

- The underlying HMoE-D model is a **demonstration** with no language
  pretraining.  Its `predict()` is template-based, not learned.
- `Pass@1` on DeepSWE is **not** claimed β€” the agent is heuristic.
- Numerical / symbolic reasoning is rule-based, not learned.

## Citation

If you use this code in research, please cite the framework only
(no leaderboard claim):

```bibtex

@software{omega_reasoner_poc,

  title  = {OMEGA-Reasoner: a self-contained LLM-agent framework (POC)},

  year   = {2026},

  url    = {https://huggingface.co/<your-org>/omega-reasoner-poc},

}

```

## License

Apache-2.0.