OxyGent: Build Multi-Agent Systems That Learn and Scale Without YAML

While many agent frameworks offer little more than a disparate collection of parts, OxyGent provides a streamlined production line. It treats agents, tools, and models as standardized, modular components—referred to as "Oxy" units—that integrate seamlessly. You can hot-swap a tool, replace a model, or reuse a sub-agent across multiple projects without friction. The framework manages all the underlying orchestration.

The result is a system that eliminates repetitive boilerplate code, allowing you to focus on shipping agents ready for production environments.

What Sets It Apart

OxyGent is designed to solve the primary challenges that often stall enterprise AI initiatives.

• Development Speed: Engineering is handled entirely in Python. There are no massive YAML configuration files to maintain and no complex JSON schemas to debug. You simply define an Oxy component and assign it specific tools or sub-agents; the framework assembles the logic automatically.
• Intelligent Coordination: Agents do more than just operate in sequence. They decompose complex tasks, negotiate strategies, and adapt to shifting requirements. A master agent can delegate work to specialized sub-agents—such as those for time queries, file operations, or mathematical calculations—while maintaining a transparent and auditable decision trail.
• Elastic Architecture: OxyGent supports a wide range of structures, from simple ReAct loops to complex hybrid planning topologies. Dependency mapping is handled automatically, and integrated visual debugging tools allow you to track performance and latency across distributed setups.
• Continuous Improvement: Every interaction is processed by an internal evaluation engine. The system generates training data based on its own successes and failures, allowing agents to refine their behavior through iterative feedback loops. This moves beyond static prompt engineering; the system actually improves through active use.
• Scalability: The distributed scheduler follows a principle similar to Metcalfe's Law: collaborative intelligence grows exponentially while operational costs rise linearly. This makes large-scale optimization and real-time decision-making manageable at scale.

Who Benefits

• Developers can stop building redundant infrastructure and focus on core agent logic.
• Enterprises can transition from isolated AI experiments to a unified, coherent framework.
• End users interact with a system where agents cooperate effectively rather than working at cross-purposes.

The Full Lifecycle

1. Develop: Write agents using standard Python.
2. Deploy: Launch locally or to the cloud with a single command.
3. Monitor: Track agent decisions and performance in real time.
4. Optimize: Allow the system to self-improve based on interaction data.

OxyGent is not merely a research prototype; it is production infrastructure designed to put multi-agent systems to work.

Get Started in Five Minutes

First, create a Python environment using conda or uv:

conda create -n oxy_env python==3.10
conda activate oxy_env

Alternatively, using uv:

curl -LsSf https://astral.sh/uv/install.sh | sh
uv python install 3.10
uv venv .venv --python 3.10
source .venv/bin/activate

Install the OxyGent framework:

pip install oxygent
# or: uv pip install oxygent

Install Node.js and any additional required dependencies:

pip install -r requirements.txt
brew install coreutils   # Install if necessary for your OS

A Working Example

import os
from oxygent import MAS, Config, oxy, preset_tools

Config.set_agent_llm_model("default_llm")

oxy_space = [
    oxy.HttpLLM(
        name="default_llm",
        api_key=os.getenv("DEFAULT_LLM_API_KEY"),
        base_url=os.getenv("DEFAULT_LLM_BASE_URL"),
        model_name=os.getenv("DEFAULT_LLM_MODEL_NAME"),
        llm_params={"temperature": 0.01},
        semaphore=4,
    ),
    preset_tools.time_tools,
    oxy.ReActAgent(
        name="time_agent",
        desc="Queries the current time",
        tools=["time_tools"],
    ),
    preset_tools.file_tools,
    oxy.ReActAgent(
        name="file_agent",
        desc="Reads and writes files",
        tools=["file_tools"],
    ),
    preset_tools.math_tools,
    oxy.ReActAgent(
        name="math_agent",
        desc="Performs calculations",
        tools=["math_tools"],
    ),
    oxy.ReActAgent(
        is_master=True,
        name="master_agent",
        sub_agents=["time_agent", "file_agent", "math_agent"],
    ),
]

async def main():
    async with MAS(oxy_space=oxy_space) as mas:
        await mas.start_web_service(
            first_query="What time is it? Save the time to time.txt."
        )

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

Configure your LLM credentials:

export DEFAULT_LLM_API_KEY="your_api_key"
export DEFAULT_LLM_BASE_URL="your_base_url"
export DEFAULT_LLM_MODEL_NAME="your_model_name"

You can also store these in a .env file for easier management. Finally, run the demo:

python demo.py

The Bottom Line

OxyGent treats multi-agent development as a rigorous engineering discipline rather than a series of experiments. With its modular components, clear observability, and built-in learning capabilities, it is designed for deployment in real-world environments. If your team is ready to move beyond basic demos and into production-grade AI, OxyGent is the ideal starting point.