OmniAgent: A Self-Evolving Agent Framework with Four-Layer Dynamic Security Scanning

What OmniAgent Solves and Who It Targets

OmniAgent addresses a specific gap in the current agent landscape: most agent frameworks treat skills, memory, and the underlying language model as fixed components that are configured once and then remain static. When the user changes how they work or when tasks evolve, the agent cannot adapt without manual reconfiguration or offline retraining. OmniAgent is built around the idea that all three components should evolve during live interaction.

The framework targets developers and researchers who want an agent that learns from a user's actual behavior over time rather than requiring periodic manual updates. It also targets teams running long-chain or high-risk tasks who need a more principled safety mechanism than the static security scanning found in comparable frameworks. The README positions it against OpenClaw and Hermes with a direct comparison table, and describes OmniAgent as the only framework implementing full-dimensional self-evolution across skills, context, and the BrainModel simultaneously.

OmniEvolve: The Four Dimensions of Self-Evolution

The README describes OmniEvolve as the core differentiator: a full-dimensional self-evolution system that operates across four layers simultaneously.

Proactive Memory uses a dual-path alignment mechanism combining explicit interactive feedback from the user with implicit LLM-based induction. This allows the agent to build and update a user profile without requiring the user to explicitly declare preferences.

Skill Self-Evolution works by extracting patterns from high-frequency action sequences during interaction. New skills are created automatically, then diagnosed and repaired through dual-path feedback. The comparison table in the README contrasts this real-time approach with Hermes, which uses periodic post-execution evolution that is slower to take effect, and with OpenClaw, which uses static skills with no evolution.

Context Self-Evolution builds an adaptive personalized context through real-time capture of multi-dimensional preference signals. A multi-layer information stack architecture incorporates both user interaction feedback and LLM summarization feedback to continuously update the context that the agent operates within.

BrainModel Self-Evolution is the most technically distinct feature. Through an online reinforcement learning loop using GRPO and PRM, the agent's own language model is updated during interaction rather than on a fixed training schedule. The README describes this as a closed-loop iterative process that occurs while the agent is in use.

Hyper-Harness: The Execution Scaffold

Hyper-Harness is OmniAgent's execution infrastructure. It addresses four aspects of agent execution: context loading, multi-agent coordination, tool scheduling, and security enforcement.

Progressive Context Loading applies a technique the README attributes to Anthropic Claude Skills, which it describes as Progressive Disclosure: context is loaded on demand in graduated stages (L0, L1, L2) rather than all at once. This prevents token overflow on long conversations.

Dynamic Multi-Agent introduces two specialized agents: Sentinel for planning and Guardian for safety. These agents activate dynamically based on task complexity and risk level rather than being always active.

Dynamic Concurrent Tool Execution automatically resolves inter-tool dependencies and shifts from serial execution to async parallel invocation. For long-chain tasks, this reduces latency by running independent tool calls simultaneously.

Four-Layer Dynamic Security Scanning is described in the README as a key differentiator over comparable frameworks. The four layers are: LLM intelligent review, a policy engine, interactive user approval, and an execution sandbox. Skills are assigned trust levels, and higher-risk operations pass through more layers. The README claims this scanning is unbypassable, a claim that the README presents as an industry-first. Verifying this claim in practice requires independent testing, which the README does not document.

Deep Reflexion: Dual-Layer Failure Recovery

Deep Reflexion is the mechanism that improves task success rate (PASS@1) when the agent encounters failures during execution. It operates at two layers.

The inner layer runs a three-part failure prevention system during task execution. It monitors for trajectory repetition (the agent repeatedly visiting the same states), error action repetition (the agent making the same failing call multiple times), and loop pseudo-termination (the agent signaling completion when it has actually stalled). When any of these patterns are detected, the system injects context to redirect the agent.

The outer layer handles failures after they occur. It uses LLM-driven root cause analysis (RCA) to extract a heuristic strategy from the failure, then injects that strategy as a Reflexion into the context space for the retry. The result is an inner-outer collaborative closed-loop: the inner layer prevents predictable failure modes, and the outer layer learns from those that occur anyway.

The comparison table in the README contrasts this with a single ReAct loop, which both OpenClaw and Hermes use. A single loop has no structural mechanism for handling the failure modes that Deep Reflexion addresses, and the README describes this as a contributor to lower success rates in those frameworks.

Installing and Running OmniAgent

OmniAgent is a Python package targeting Python 3.11 and later, including 3.12 and 3.13. The pyproject.toml defines the package name as omniagent and registers a CLI entry point:

[project.scripts]
omniagent = "omniagent.cli:main"

The package uses setuptools as the build backend and declares dependencies including aiohttp, click, pydantic, structlog, PyYAML, websockets, psutil, rich, the openai SDK, the anthropic SDK, beautifulsoup4, and prompt-toolkit. An optional feishu extra adds lark-oapi for Feishu bot integration. The README does not document a step-by-step installation guide; the project's website at yeqing17-2026.github.io/OmniAgent and the linked documentation at docs.omniagent.dev (described as on the way in the README) are the references for setup instructions.

The repository includes a tests/ directory and dev dependencies for pytest and mypy. The classification in pyproject.toml is Development Status :: 3 - Alpha, confirming that the project is not yet at a stable release.

Limitations, Alpha Status, and GPL-3.0 Implications

OmniAgent's alpha classification is a practical constraint. Version 0.1.0 with Development Status :: 3 - Alpha signals that APIs may change, documented features may be incomplete, and the installation and configuration experience may not yet be smooth. The documentation site is listed as on the way, and the README links a Feishu community document for a product walkthrough rather than formal reference documentation.

The BrainModel Self-Evolution feature, which updates the agent's underlying language model through online reinforcement learning during interaction, is the most technically demanding claim in the README. Running online RL during live interaction requires deploying a self-hosted model (the README describes this as a self-deployed model rather than a commercial API call), which adds significant infrastructure requirements. Teams using cloud-hosted language model APIs cannot use this feature without running their own model server.

The GPL-3.0 license is a hard blocker for commercial closed-source products. Any software that ships OmniAgent's code must release its own source code under GPL-3.0. Internal enterprise tooling where the software is not distributed externally is not subject to this restriction, but any SaaS product, downloadable application, or API service that incorporates OmniAgent must comply with the copyleft requirement. LangChain, an alternative Python framework for building LLM applications with tool use, is available under the MIT license and does not impose this constraint, though it does not implement OmniAgent's online RL model evolution.

Editorial conclusion

OmniAgent is in alpha (version 0.1.0), with a last push on 2026-07-27. The GPL-3.0 license means any product that ships OmniAgent's code must open its own source under the same terms, which rules it out for most closed commercial deployments. Internal tooling and research use are not affected. Teams evaluating it should start by confirming the omniagent CLI installs cleanly on Python 3.11 or later and that the four-layer security scanning interacts predictably with their local filesystem layout before committing to the framework.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. YeQing17-2026/OmniAgent on GitHub