AgentScope Tuner - Alibaba Tongyi's one-stop automatic optimization engine

AgentScope Tuner What it is

AgentScope Tuner is a one-stop automatic optimization engine launched by Alibaba Tongyi Lab for Agentic AI. It is deeply integrated into the AgentScope ecosystem, connecting the entire development, tuning, deployment, and regression workflow. The tool provides three major capabilities: Prompt tuning, model selection, and AgentRL reinforcement fine-tuning, allowing existing Agent workflows to be connected for optimization with almost zero modification cost, achieving full-cycle coverage from lightweight validation to enterprise-level distributed training, making agents smarter the more they are used.

AgentScope Tuner Main features

• Prompt tuning: Uses automated search algorithms (such as MIPROv2) to systematically explore the prompt space, optimizes Prompt templates for Agent trajectories, and enables rapid iteration without a GPU.
• Model selection: Automatically evaluates and filters candidate models, combines multi-dimensional metrics such as accuracy, response speed, and Token consumption, and selects the optimal base model for overall cost-effectiveness with one click.
• Reinforcement fine-tuning (RFT): Based on the Trinity-RFT framework, it learns from real interaction trajectories, performs deep parameter optimization using end-to-end interaction as the unit, and supports distributed training on hundred-card clusters.
• Unified optimization interface: The three optimization strategies share the same API design paradigm, so developers can freely switch optimization methods without learning different frameworks.
• Development-tuning closed loop: Training metrics are consistent with online performance, eliminating tedious steps such as manually exporting data, format adaptation, and environment switching.

AgentScope Tuner Technical principles

• Workflow-as-Function abstraction and asynchronous execution graph: Abstracts the Agent workflow as a pure function async def workflow(task, model, system_prompt) -> WorkflowOutput, and implements declarative binding of optimizable variables through parameter injection. The Judge function returns a scalar reward, forming a standard (state, action, reward) reinforcement learning triplet, and the entire execution graph is scheduled using asynchronous coroutines.
• Combinatorial search mechanism for prompt optimization: Based on MIPROv2, it performs iterative search in the discrete instruction space: "meta-prompt generation of candidates -> few-shot evaluation -> local screening". It uses the training set to build an example pool and finds a local optimum in the syntactic-semantic joint space of the Prompt template through combinatorial optimization.
• Multi-objective Pareto computation for model selection: Converts accuracy, latency, and Token cost into a weighted utility function, performs batch inference on the candidate model set, calculates the expected reward of each model on the task distribution, and selects the overall optimal base through Pareto frontier analysis, enabling automatic decision-making under multi-objective trade-offs.
• Group relative policy optimization for trajectory-level reinforcement learning: Based on the Trinity-RFT framework, it treats the complete Agent interaction trajectory (multi-turn tool calls, observations, reasoning) as a single training sample. It uses GRPO (Group Relative Policy Optimization) to solve the long-trajectory credit assignment problem through intra-group relative advantage estimation, avoiding the estimation bias of traditional PPO value networks in discrete action spaces.
• Isomorphic runtime for training and inference: Tuner directly reuses the AgentScope runtime to generate training data, ensuring that the training distribution is consistent with the inference distribution. By directly injecting the parameters to be optimized into the workflow, it eliminates the data export and format conversion steps of traditional pipelines, fundamentally avoiding "good training, poor deployment" caused by environment drift.

How to use AgentScope Tuner

• Environment preparation: Install AgentScope Ensure that an existing Agent workflow can run normally.
• Prepare the dataset: Organize the task data in Hugging Face Datasets format as train.jsonl and test.jsonl, with each row containing the task input and expected output.
• Define the workflow function: Encapsulate the Agent logic as a async def workflow(task, ...) function that returns a WorkflowOutput object.
• Define the judging function: Implement async def judge_function(task, response), returning a reward contained in JudgeOutput to provide optimization signals.
• Start optimization: Call tune_prompt()、select_model() or tune() interfaces as needed, passing in the workflow, dataset, and configuration to automatically complete optimization and regression deployment.

Key information and usage requirements of AgentScope Tuner

• Producer: Alibaba Tongyi Lab (AgentScope official ecosystem).
• Open-source address：GitHub agentscope-ai/agentscope(the tuner module is located in src/agentscope/tuner）。
• Hardware requirements: Prompt tuning and model selection do not require a GPU; reinforcement fine-tuning requires a GPU and supports hundred-GPU clusters and cloud distributed training.
• Data format: Requires Hugging Face Datasets format (JSONL); you need to prepare the training set and evaluation set yourself.
• Integration cost: Existing AgentScope workflows require almost no code refactoring; optimization can be enabled by injecting system_prompt or model parameters.
• Dependent frameworks: Deep training is based on Trinity-RFT and supports inference acceleration such as vLLM.
• Recommended cases：GitHub agentscope-ai/agentscope-samples/tree/main/tuner provides examples such as Math Agent, Werewolf Multi-Agent, and Deep Finance Agent.

AgentScope Tuner project address

• Project official website：https://docs.agentscope.io/tune-agent/tune-your-first-agent
• GitHub repository：https://github.com/agentscope-ai/agentscope/tree/main/src/agentscope/tuner

Core advantages of AgentScope Tuner

• Agent-native closed loop: The only optimization engine designed around Agent multi-turn interaction trajectories, with training and online performance highly consistent, avoiding the disconnect problem of "good training, poor deployment".
• Zero-refactoring integration: Existing workflows only need a few parameter changes to start optimization, with no need to switch environments or rewrite logic.
• Full-cycle阶梯 optimization: From lightweight early-stage Prompt iteration to deep later-stage model training, it provides a continuous optimization path throughout the R&D lifecycle.
• Unified experience: The three optimization strategies share the same set of interfaces and evaluation criteria, reducing the learning cost of multiple frameworks.
• Enterprise-grade scalability: Supports distributed reinforcement learning on cloud hundred-GPU clusters, meeting large-scale training needs for complex business scenarios.

Comparison of AgentScope Tuner with similar competing products

Application scenarios of AgentScope Tuner

• Mathematical reasoning Agent: Optimize chain-of-thought paths and tool call descriptions to improve the accuracy of solving complex math problems.
• Multi-agent game system: Such as Werewolf scenarios, using reinforcement fine-tuning to train multiple Agents' high-level strategies such as reasoning, deception, and collaboration.
• Financial in-depth analysis Agent: For long-chain report generation tasks, optimize the end-to-end interaction trajectory to automate text analysis and financial data integration.
• Enterprise internal tool-calling Agent: When an Agent needs to accurately call a dozen internal APIs and generate reports according to complex business rules, break through the performance ceiling through RFT.
• Model cost reduction and efficiency improvement: With almost no loss in accuracy, automatically replace expensive large models with more cost-effective lightweight models.