Agentica Project rLLM Scalable AI Agents with Reinforcement Learning

Agentica: The Beginning of a New Era of Agent AI with Job Invocation

The field of artificial intelligence is changing fast. Agentica brings a groundbreaking way to create AI agents by centering on a new idea—LLM Function Calling. Instead of using complicated workflows or graph nodes like older agent frameworks, Agentica provides a simpler more adaptable solution. It uses the built-in abilities of large language models to pick and use functions.

Agentica Project rLLM Scalable AI Agents with Reinforcement Learning

Agentica’s Idea: Shifting From Complexity Toward Results

Traditional AI systems rely on complex workflows built using graph nodes. As the systems grow more advanced, these workflows become more complicated and prone to mistakes. This issue called the Cartesian Product Problem, can cause workflows to fail more often. For instance, if a simple five-node workflow has an 80% success rate for each node, the entire workflow will succeed about 33% of the time.

Agentica avoids this problem. Instead of using workflow graphs, it focuses on function calling. Developers just need to write and share functions to build strong adaptable agents. The logic is managed by the LLM, which takes care of tasks like selecting, combining, and executing these function calls. This removes the need for manual management.

How It Works: Follow the Lead of Functions

Agentica works by using Swagger/OpenAPI documentation or TypeScript class definitions at its foundation. The framework allows the LLM to understand the context of a conversation, pick the right function, populate its parameters, and carry it out. This removes the need to rely on regular workflow logic.

One example shows a shopping chatbot linked to a high-performing backend with 289 API endpoints. These handle tasks like managing products, processing payments, arranging deliveries, and managing coupons. The whole setup operates on an efficient 8-billion parameter LLM, which can run on a standard laptop. This example shows that powerful agents don’t need oversized models. They just need clever design.

Document-Driven Development: A New Approach in AI

Agentica presents a fresh approach called Document-Driven Development (DDD). Developers concentrate on writing clear documentation for individual functions instead of crafting complicated agent workflows. While inspired by the ideas of Domain-Driven Design, it adapts them to suit AI agents.

By documenting functions on their own, developers divide their systems into smaller organized domains. The documentation lays out how functions are connected, and the LLM takes over handling their interactions. This encourages flexibility, growth, and easy upkeep.

Compiler-Driven Development: Let Automation Handle Repetition

To make this method work, Agentica focuses on something called compiler-driven schema generation. Instead of having developers create function schemas, which can lead to mistakes and wasted effort, Agentica relies on the TypeScript compiler to create LLM-compatible schemas. This approach improves safety, avoids repeated code, and reduces the workload for developers.

Agentica suggests using backend frameworks that align with this process:

• TypeScript (NestJS + Nestia): Uses the compiler to generate Swagger documentation.
• Python (FastAPI): Creates similar documentation through runtime reflection.

On the other hand, frameworks like Java Spring, PHP Laravel, and Python Django depend on manual schema creation. This makes them riskier and less effective to use with AI agents.

Managing Errors with Validation Feedback Methods

Calling functions offers great potential, but it’s not without its issues. Sometimes large language models generate invalid parameters when they run functions. To solve this, Agentica uses a reliable approach called the Validation Feedback Strategy.

1. Let the LLM try to execute the functions even if the arguments might not be valid.
2. Detect any specific type errors with the help of the Typia validator, which is created from TypeScript code.
3. Offer clear feedback to the LLM, so it can fix mistakes and try the call again.

This method boosts success rates a lot and makes large models less of a necessity. Even smaller LLMs with just 8 billion parameters can work well when paired with proper validation and strong schema setups.

Simplified Structure Within Agentica

Agentica runs on a system organized around three modular agents:

• Selector Agent: Looks at the context to decide which function to use or chooses a default reply.
• Caller Agent: Puts together the function inputs and asks the user for any needed details.
• Describer Agent: Shares the outcomes of the function call with the user.

The process cycles between the selector and caller until the task finishes, providing a simpler but effective option to traditional agent setups.

Conclusion: Changing the Way We See Agentic AI

Agentica shows that building effective Agentic AI does not depend on using oversized architectures or huge LLMs. Instead, it requires a reliable, practical, and expandable approach to function calling. Agentica combines compiler-driven schema creation, document-oriented development, and strong validation tools to create a new standard in designing intelligent agents.

The future of Agentic AI will not focus on developing complicated workflows. It will focus on enabling LLMs to perform clear and specific tasks on their own.

rLLM project details from GitHub repository

What is rLLM?

rLLM is an open project aimed to make reinforcement learning accessible for training large language models. It supports scalable and repeatable training of LLMs on practical tasks. The models it emphasizes include:

• DeepSeek R1
• OpenAI O1 and O3

The initiative seeks to supply everything required to recreate these models. This includes:

• Training code
• Prebuilt models
• Infrastructure for training
• Data collections
• Logs along with guides

Main Highlights

• Scalable Reproducibility: rLLM allows recreating RL-trained models like DeepSeek R1 or OpenAI O1/O3.
• Alignment with Practical Tasks: These models are built to handle tasks in real-life scenarios by utilizing RLHF (Reinforcement Learning from Human Feedback).
• Accessible Tools: It provides everything, including data and model weights, to encourage open research and make AI resources more accessible.

Getting Started

To use rLLM, follow these basic steps:

1. Clone the Repository

git clone https://github.com/agentica-project/rllm.git
cd rllm

2. Install Dependencies

pip install -r requirements.txt

3. Run Training or Evaluation Scripts

The repository includes scripts for training, evaluation, and interacting with the models.

Why Choose rLLM?

• Use it if you are a researcher or developer planning to create your own RL-aligned large language model.
• Use it as a guide to learn how training methods like DeepSeek are applied.
• Explore it if you are researching how RLHF works on bigger models.

rLLM provides production-quality tools to develop LLMs trained through reinforcement learning. It eliminates the need to rely on proprietary infrastructure.

Resources

• GitHub repository: https://github.com/agentica-project/rllm
• Agentica Project Website: https://www.agentica-project.com