🤖 machine learning

FederatedSkill: Federated Learning for Agentic Skill Evolution

FederatedSkill is a privacy-preserving framework that enables collaborative agent evolution by aggregating semantic skill patches instead of raw trajectories, allowing for personalized skill library updates that significantly improve task success rates and reduce computational costs compared to isolated self-improvement baselines.

Original authors: Jingbo Yang, Guanyu Yao, Yang Zhang, Ramana Rao Kompella, Gaowen Liu, Shiyu Chang

Published 2026-06-03

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jingbo Yang, Guanyu Yao, Yang Zhang, Ramana Rao Kompella, Gaowen Liu, Shiyu Chang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a smart robot assistant (an "AI Agent") that helps you with tasks like navigating the web, analyzing data, or automating your work. To get really good at these jobs, the robot needs a Skill Library—a digital toolbox full of instructions on how to use tools, solve problems, and chain actions together.

The Problem: The "Lonely Learner" and the "Privacy Leak"

Currently, these robots learn in two ways, both of which have big flaws:

The Lonely Learner: If a robot only learns from its own user, it gets stuck. It only sees a narrow slice of the world. If it fails at a new task, it might not have the right "recipe" to fix it because it hasn't seen that specific problem before. It's like a chef who only cooks for one person; they never learn how to handle the weird ingredients that other people order.
The Privacy Leak: To fix the "lonely" problem, robots could share their experiences with a central server so everyone learns from everyone else. But this is dangerous. To share their experience, they would have to send their raw diary (screenshots, private emails, confidential spreadsheets) to the server. This is like asking a chef to send a video of their entire kitchen, including the customer's credit card numbers and secret family recipes, just to share a new cooking tip. No one wants to do that.

The Solution: FederatedSkill

The paper introduces FederatedSkill, a new way for these robot assistants to learn together without ever sharing their private diaries. Think of it as a secure, collaborative recipe exchange.

Here is how it works, using a simple analogy:

1. The "Patch" Instead of the "Diary"

Instead of sending the raw video of their kitchen (the private data), each robot looks at what it just did, figures out what went wrong or right, and writes a tiny, structured note called a "Skill Patch."

The Analogy: Imagine you are a chef. Instead of sending a video of your whole day, you just send a note to the central kitchen saying: "I added a new step to the 'Soup Recipe' to stop it from burning," or "I deleted the 'Spicy Sauce' step because it was too hot."
The Magic: This note (the patch) contains the lesson but not the private details. It doesn't say who ate the soup or what their allergies were. It just says how to fix the soup.

2. The "Smart Manager" (The Server)

On the server side, there is a special "Evolution Agent" (a smart manager). Its job isn't just to copy-paste everyone's notes into one giant book. That would be a disaster because different robots have different brains and different tools.

The Analogy: Imagine a master chef managing a team of cooks who use different ovens (some use gas, some electric) and have different skill levels.
- If a gas-oven cook suggests a new way to sear a steak, the manager knows that might not work for the electric-oven cook.
- The manager looks at the notes, figures out which robot is good at what, and customizes the updates.
- For the gas-oven cook, they might say, "Use this new searing trick." For the electric-oven cook, they might say, "Ignore that, but here is a different trick that works for your oven."

3. The Result: Personalized Growth

Because the manager tailors the updates, every robot gets a personalized library that fits its specific needs and capabilities.

No Privacy Lost: The raw data (the customer's credit card, the secret recipe) never leaves the robot's local kitchen. Only the abstract "lesson" travels.
Better Performance: The paper tested this on 20 different types of tasks (like financial analysis or web navigation). They found that robots using this system got 44% better at succeeding at tasks compared to robots that learned alone.
Cheaper: Because the robots learned better and didn't waste time trying the same mistakes over and over, they used 37% less computing power (and money) to get the job done.

Summary

FederatedSkill is like a global cooking club where chefs share tips and tricks (Skill Patches) instead of their private customer lists (Raw Data). A smart manager then takes those tips and adapts them for each chef's specific kitchen, ensuring everyone gets better at cooking without ever compromising their secrets.

The paper proves this works: it makes AI agents smarter, faster, and more private, allowing them to evolve their skills collaboratively without the risk of data leaks.

Technical Summary: FederatedSkill

Problem Statement

Modern Large Language Model (LLM) agents increasingly rely on skill libraries—collections of reusable procedural memories—to handle complex, multi-step tasks. While agents can self-improve by evolving these libraries based on local execution trajectories, single-user data streams suffer from a data bottleneck: they lack the diversity required to build comprehensive skills for long-tail or challenging tasks.

Existing collaborative approaches attempt to overcome this by sharing raw execution trajectories across users to a central server. However, this paradigm faces two critical obstacles:

Privacy Risks: Raw trajectories often contain sensitive information (e.g., private web content, confidential spreadsheet data) that users cannot safely transmit, even to trusted servers.
Client Heterogeneity: A single, uniform global skill library is rarely optimal for all users. The effectiveness of a skill depends on the specific model family, agent framework (harness), and task distribution of the client. Naive aggregation leads to a "one-size-fits-all" library that underserves heterogeneous users.

The central question addressed is: Can users collaboratively evolve skills while preserving privacy and obtaining a skill library tailored to their specific needs?

Methodology: FederatedSkill

The authors propose FederatedSkill, a privacy-preserving framework for collaborative agent evolution that operates as a client-server loop. It draws inspiration from federated learning but adapts the communication unit from model weights to semantic skill diffs.

1. Client-Side: Local Execution and Patch Distillation

Instead of uploading raw trajectories, clients perform local self-reflection and distillation:

Local Execution: The client agent executes tasks using its current skill library ( $L_i$ ) and backbone model ( $\rho_i$ ), generating a trajectory batch ( $B_i$ ).
Patch Distillation: A local patcher (sharing the client's backbone) analyzes the trajectory and the current library to generate a skill patch ( $\delta_i$ $δ_{i}$ ).
- Structure: The patch is a structured tuple containing ADD, EDIT, or DELETE operations on the library files (e.g., SKILL.md).
- Privacy by Construction: The patcher is explicitly prompted to strip task-specific values, IDs, and raw interaction logs. It outputs only high-level, reusable procedural knowledge (playbooks) and structural paths. Raw trajectories and sensitive data remain strictly local.
- Output: The client uploads only the patch $\delta_i$ , which documents the semantic changes to the library.

2. Server-Side: Personalized Evolution Agent

The server hosts an Evolution Agent ( $M$ ) that operates under partial observability (it sees only patches and client profiles, not raw data). It treats the aggregation process as a Partially Observable Markov Decision Process (POMDP).

Capability Modeling: The agent maintains a Capability Matrix and a Two-Level Memory:
- Shared Memory: Tracks which task workflows are solved, absorbing, broken, or missing across the federation.
- Private Memory: Records model-specific failure modes and capability boundaries for each client.
Personalized Planning: Rather than merging patches into a single global average, the agent generates a personalized evolution plan for each client. It decides which peer skills to adopt, how to refactor them to match the target client's model/harness, and which to reject.
Execution: The agent applies these directives to update each client's library ( $L_i^{t+1}$ ), ensuring the resulting library is tailored to that client's specific "capability boundaries."

Key Contributions

Privacy-Preserving Protocol: The paper introduces a mechanism where agents exchange semantic skill patches instead of raw trajectories. This eliminates the leakage of sensitive user data (PII, confidential business logic) inherent in trajectory-sharing approaches.
Personalized Federated Evolution: Unlike traditional federated learning (which aggregates parameters) or prior collaborative skill works (which create a single global library), FederatedSkill achieves personalization at the semantic-skill level. It dynamically models client heterogeneity to produce distinct, optimized libraries for each client.
Framework Implementation: The system is implemented as a client-server loop where the server acts as a "merger agent" that curates and adapts skills, handling the complexity of different model backbones (e.g., Qwen, GLM, Kimi) and agent harnesses (e.g., Claude Code, Qwen Coder).

Experimental Results

The framework was evaluated on the SkillFlow benchmark, spanning 20 distinct task families, using heterogeneous setups involving different LLM backbones and agent harnesses.

Performance Gains: FederatedSkill significantly outperforms self-evolving baselines (where agents evolve in isolation).
- Achieved up to a 44.4% increase in task success rate.
- Demonstrated robust gains across homogeneous and highly heterogeneous settings (different models and harnesses).
Cost Efficiency: By avoiding library bloat (the uncontrolled growth of skills seen in self-evolution), FederatedSkill reduced computational costs.
- Achieved up to a 37.5% reduction in cost per solved task.
- Reduced per-trial API costs by 7% to 24% across different models.
Necessity of Personalization: Ablation studies comparing FederatedSkill against a "Global" baseline (single shared library) showed that personalized evolution yields an average performance gain of 12.2% over the non-personalized approach, confirming that a single global library is suboptimal for heterogeneous clients.
Privacy Verification: An empirical privacy audit confirmed that the outgoing skill patches leaked only 5.08% of sensitive entities (compared to 52% for naive summaries), and the personalized updates broadcast back to clients leaked a negligible 0.09%.

Significance and Claims

The paper claims that FederatedSkill establishes the skill library as a highly effective unit of federation for agent self-improvement. Its significance lies in resolving the trade-off between collaborative learning and privacy:

It enables agents to learn from the collective experiences of a diverse user base without compromising data privacy.
It moves beyond the "global average" limitation of current collaborative frameworks, acknowledging that different agents have different capabilities and requiring tailored solutions.
It demonstrates that semantic-level abstraction (patches) is sufficient for high-performance transfer, avoiding the massive bandwidth and privacy costs associated with raw data or parameter-level federated learning.

The authors note limitations, including the assumption of a trusted server environment (lack of defense against malicious/poisoned patches) and the current constraint to a modest number of concurrent clients due to computational resources. However, they posit that the framework provides a foundational step toward scalable, privacy-preserving collaborative agent ecosystems.