deep-agent-reasoning

name	deep-agent-reasoning
title	DeepAgent: A General Reasoning Agent with Scalable Toolsets
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.21618
keywords	["Agent","Reasoning","Tool Learning","RL","Memory Management"]
description	Enables autonomous reasoning agents to discover and invoke tools efficiently through end-to-end training. Uses autonomous memory folding to compress interaction history and ToolPO to learn general-purpose tool use, applicable across diverse benchmarks from QA to web automation.

DeepAgent: Unified Autonomous Reasoning with Tool Learning

Existing reasoning agents struggle with two key limitations: they accumulate errors across long-horizon tasks through verbose interaction histories, and they require task-specific tool interfaces rather than learning generalizable tool use patterns.

DeepAgent solves this by integrating autonomous thinking, tool discovery, and action execution into a single end-to-end reasoning process. The system combines memory compression with learned tool invocation, enabling agents to handle complex multi-step tasks efficiently.

Core Concept

DeepAgent operates through three integrated mechanisms:

• Autonomous Memory Folding: Compresses past interactions into structured episodic, working, and tool memories, reducing error propagation
• ToolPO (Tool Policy Optimization): An end-to-end RL strategy using simulated APIs and fine-grained tool-call advantage attribution
• Tool Retrieval: Handles both labeled-tool and open-set discovery scenarios

Architecture Overview

• Memory compression captures essential interaction patterns without verbose history
• Tool-call advantage attribution isolates credit signals to tool invocation tokens
• Memory types (episodic, working, tool) serve different reasoning stages
• End-to-end training enables discovery of effective tool combinations

Implementation Steps

The memory folding mechanism selectively summarizes interactions at each step. Rather than maintaining full conversation history, compress past state and actions into dense representations:

class MemoryFolder:
    def fold_interaction(self, history, current_state):
        # Compress episodic memory: factual outcomes from past steps
        episodic = self.compress_facts(history)
        # Working memory: intermediate reasoning state
        working = self.compress_reasoning(current_state)
        # Tool memory: effective tool patterns
        tools = self.extract_tool_patterns(history)
        return {episodic, working, tools}

    def compress_facts():
        
         [fact  fact  history  is_critical(fact)]

     ():
        
         {(context, goal): tool  context, goal, tool  history}