How AI Agents Learn General Skills Across Different Tasks

An Agent Learns Skills That Generalize

One benchmark asks an agent to figure out the rules of a board game. Another has it navigate a maze. A third puts it in control of a robot. At first glance, these tasks have little in common. But each may rely on the same underlying skill: tracking the state of the world and remembering what changed after an action.

That idea underpins The Trinity, a system that improves an AI agent’s scaffolding based on shared capability requirements rather than tuning it separately for every task. The authors left the model itself unchanged. Instead, they adjusted the tools and rules that guide its work: how it gathers facts, tests possibilities, plans actions, and decides when to stop.

The system improved average scores by 34 points across 28 training benchmarks and by 26 points across 18 benchmarks it had never seen before. The evaluation also included tasks performed by physical robots.

Why tasks need shared capabilities

Many modern AI agents have to work for extended periods across different formats: reading text, interpreting images and video, choosing actions, and accounting for their consequences. An early mistake can derail everything that follows. The agent may misread a scene, make the wrong move, then build a plan on a false understanding of the situation.

This problem is usually tackled separately for each task set. But task-specific tuning often fails to transfer to new conditions. A single, general-purpose set of tools can be awkward too: tasks call for different skills, and those skills can conflict. Caution, for example, can prevent irreversible mistakes but also get in the way of acting quickly.

The authors propose grouping tasks by the capabilities they require, not by how similar they look. Solving a grid puzzle and navigating a maze may seem unrelated, but both require noticing changes and tracking the state accurately. Training that shared skill could help across multiple environments.

The system has three roles:

🟠 The Creator designs small training worlds with clear rules and verifiable outcomes.

🟠 The Explorer works through those worlds and collects examples of successful and unsuccessful actions.

🟠 The Evolutionary Agent analyzes those examples, groups tasks by the capabilities they require, and proposes changes to the agent’s scaffolding.

Three roles connect tasks, training worlds, and the evolution of an AI agent’s scaffolding.

Turning capabilities into modules

The team started with 44 benchmarks: 28 for training and 18 for testing on new tasks. They covered puzzles, video tasks, games with other participants, control, and robotics. The researchers recreated some environments from their published rules.

They then ran the system on the training tasks and examined its action logs. This led them to identify six shared capabilities: tracking perception and state, testing hypotheses, handling constraints, choosing goals, finding relevant video frames, and understanding events between frames.

These capabilities were organized into a tree. Each node represents a combination of requirements, so tasks from different domains can end up on the same branch. Planning, inspecting objects, and navigating a maze, for instance, may all call for similar state tracking and result checking. The tree captures shared skills, not surface-level similarities between tasks.

For each node, the Creator then builds a simplified training world. If the target capability is checking whether a goal has actually been reached, the environment might teach it through a simple task involving objects and rules. The world must be easy enough to evaluate while preserving the key logic of the original tasks. Performance is then measured on the original benchmarks to see whether the skill transfers beyond the training world.

A training world is built around a shared capability needed by several different tasks.

The scaffolding itself is made up of modules. Some help the agent interpret data; others support memory, hypothesis testing, or action selection. The AI agent does not change the model’s weights. Instead, it improves these modules based on interaction logs, comparing successful and unsuccessful attempts and proposing targeted changes.

New modules go through several checks: their inputs and outputs must be clear, they must be grounded in real examples, and they must match the version they replace. Child branches in the tree can inherit modules from their parents while retaining their own settings. This produces different scaffolds for different combinations of capabilities.

This also avoids rebuilding the whole system from scratch each time. A module that helps track state can be reused across several branches, while solutions that do not fit a task need not be applied everywhere.

What the experiments showed

The authors compared several ways of organizing the scaffolding. A single shared set of modules, separate tuning for each task category, and grouping by capability all produced different results. The capability tree trained in system-generated worlds performed best on new tasks, scoring 47.26 points compared with 42.92 for the shared scaffold. On training tasks, it scored 56.95 versus 53.04.

The system was then improved over four cycles. Its average score rose from 39.1 to 73.2 points on the training set and from 42.1 to 64.1 on new tasks. The biggest gain came in the first cycle, but the next three also added points.

Improvements varied from task to task. For example, the score on ARC-AGI-3 rose from 41.0 to 53.6, and the score on SciGym went from 45.2 to 57.1. On Eleusis, however, the final score was slightly lower than after the first cycle. Averages can hide differences like these, so they should be considered alongside individual task results.

A router selects the right scaffold for each task using publicly available information about it and validated experience from previous runs. It scored 71.27 points on the training benchmarks and 60.96 on new ones. For comparison, choosing the best scaffold after the fact yielded 73.16 and 63.61 points, respectively. That means the selection can be automated with little loss in performance. The router does not get the correct answers from the test set; it uses only the available task description and experience collected during training runs.

Average scores rise with each cycle, while retraining costs fall as training worlds are reused.

The authors also tested whether the right modules helped on their own. Adding a module tied to a task’s required capability boosted the baseline scaffold’s score by 19.39 points. A random module unrelated to the task added just 1.02 points. Removing a relevant module from the improved scaffold lowered its score by 2.74 points. This supports selecting modules based on the capabilities a task needs, rather than adding them indiscriminately.

Finally, the evolved scaffolds were tested on two robots. In one experiment, a robot had to approach a table and reach toward it. In the other, it had to find a cube hidden under cups and identify its color and position. Robots using versions trained by the system completed both tasks more often, in simulation and in the real world. In the cup task, for example, the baseline scaffold might report that the cube was missing without ever checking the right cup. The improved scaffold checked the objects in sequence and answered once it found the cube.

A robot with improved scaffolding approaches its target more accurately and checks the cups before reporting where the cube is.

What the results don’t prove yet

The experiments show higher average scores and transfer to new tasks, but they do not guarantee improvement in every area. Progress was modest on some benchmarks, and the system performed worse than both comparison systems on tasks such as Crafter and DiG-bench.

The robotics results also need to be considered in light of how the evaluation was set up. The authors compared complete “scaffold plus prepared skills” systems, so it is not possible to isolate the contribution of the modules from that of the skills. There were also only two physical tasks, with a limited number of trials for each.

There is a practical trade-off, too: creating training worlds takes resources. The authors note that generating environments accounted for a substantial share of the cost in the first cycle, but those environments could be reused later. The approach becomes more worthwhile when a training world helps improve the scaffold over several cycles and transfers its gains to multiple tasks.

Conclusion

The Trinity shifts AI-agent development from individual tasks to shared capabilities. Rather than building a custom scaffold for every game, puzzle, or robot, the system identifies recurring requirements, creates testable training worlds for them, and gradually improves the relevant modules.

Results on new benchmarks and with robots suggest that this kind of transfer is possible. But the system does not improve every task equally, and the robotics evaluation covers only two scenarios. The next step is to test how well the capability tree can expand to cover new requirements and perform across a broader range of real-world conditions.