As LLM agent deployments scale to concurrent multi-agent systems, resource management becomes critical. AgentRM (2025) applies operating systems principles to manage agent resources – scheduling, isolation, and process management – treating the agent runtime as an OS-like environment with processes, memory tiers, and congestion control.

AgentRM draws a direct parallel between traditional OS resource management and the challenges of multi-agent systems:

AgentRM operates as middleware between the agent gateway and model APIs, maintaining global state about resource utilization while remaining transparent to individual agents.

1. Agent Scheduler (MLFQ):

The scheduler uses a Multi-Level Feedback Queue inspired by decades of OS research. Tasks start in Queue 0 (highest priority) and are demoted based on execution time and resource consumption:

$$Q_i \rightarrow Q_{i+1} \quad \text{when } t_{\text{exec}} > T_i$$

Priority boosting prevents starvation by periodically promoting long-running tasks, similar to Solaris TS scheduling. The scheduler addresses:

• Blocking: High-priority tasks delayed by lower-priority work
• Zombie processes: Completed tasks that fail to release resources
• Rate limit cascades: One agent's rate limiting affecting others
• Starvation: Long-running tasks never receiving execution time

2. Context Lifecycle Manager (Three-Tier Storage):

Manages context windows through three storage tiers with adaptive strategies:

• Active tier: Full context in model API memory for active conversations
• Compacted tier: Adaptively compressed context that preserves key information while reducing token usage
• Hibernated tier: Serialized complete session state (context, local variables, execution state) for inactive sessions, enabling full restoration without information loss

3. Resource Monitor:

Tracks system state across all agents and provides real-time feedback for scheduling decisions, including token usage rates, queue depths, and rate limit proximity.

Drawing from TCP congestion control, AgentRM implements AIMD (Additive Increase, Multiplicative Decrease) backoff for API rate limiting:

$$\text{rate}_{t+1} = \begin{cases} \text{rate}_t + \alpha & \text{if no rate limit hit} \\ \text{rate}_t \times \beta & \text{if rate limit detected} \end{cases}$$

where $\alpha$ is the additive increase constant and $\beta < 1$ is the multiplicative decrease factor. Token bucket rate limiting is applied per model API endpoint.

class AgentMLFQScheduler:
    def __init__(self, num_queues=4, time_quanta=None):
        self.queues = [[] for _ in range(num_queues)]
        self.time_quanta = time_quanta or [1, 2, 4, 8]
        self.boost_interval = 100
        self.ticks = 0
 
    def submit(self, agent_task):
        agent_task.queue_level = 0
        agent_task.exec_time = 0
        self.queues[0].append(agent_task)
 
    def schedule_next(self):
        self.ticks += 1
        if self.ticks % self.boost_interval == 0:
            self.priority_boost()
        self.reap_zombies()
        for level, queue in enumerate(self.queues):
            if queue:
                task = queue.pop(0)
                return task, self.time_quanta[level]
        return None, 0
 
    def task_completed(self, task, exec_time):
        task.exec_time += exec_time
        quantum = self.time_quanta[task.queue_level]
        if exec_time >= quantum and task.queue_level < len(self.queues) - 1:
            task.queue_level += 1
        if not task.is_done:
            self.queues[task.queue_level].append(task)
 
    def priority_boost(self):
        for level in range(1, len(self.queues)):
            while self.queues[level]:
                task = self.queues[level].pop(0)
                task.queue_level = 0
                self.queues[0].append(task)
 
    def reap_zombies(self):
        for queue in self.queues:
            zombies = [t for t in queue if t.is_done and not t.released]
            for z in zombies:
                z.release_resources()
                queue.remove(z)

AgentRM was evaluated against baseline scheduling algorithms across workloads derived from real production deployments, analyzing over 40,000 real-world issues from major agent frameworks.

Under rate limit cascade conditions (149 turns, 5 agents with oscillating 5-40% hang rates), AgentRM demonstrated effective resource contention handling through its AIMD-based backoff and lane isolation.

The principles underlying AgentRM apply broadly to any multi-agent system with limited resources:

• MLFQ scheduling with feedback for adaptive task prioritization
• Hierarchical storage matching access patterns (hot/warm/cold context)
• Explicit resource cleanup and zombie reaping to prevent leaks
• AIMD congestion control for shared API rate limits
• Lane-based isolation to prevent cascading failures across agents
• Priority boosting to prevent indefinite starvation of background tasks

• AgentRM: An OS-Inspired Resource Manager for Concurrent Agent Tasks (arXiv:2603.13110)

• Agent RL Training: Agent-R1 and RAGEN
• Chip Design Agents: Agentic EDA
• Data Science Agents: DatawiseAgent