Blog|October 15, 2026

Introducing FLEX: How Cortex 2.6 learns from its own experience

Sereact8 min read

5x speed

How do you get good at folding a T-shirt? Someone shows you how, and then you fold a lot of T-shirts. Being shown gets you started, but practice is what makes you fast and reliable. At Sereact, this is a core challenge that we are tackling. Our robots work in logistics, where new items and new tasks arrive all the time. For us the question is how quickly a robot becomes reliable at something new, and whether what one robot learns can benefit every robot in the fleet.

Why imitation is not enough

Today's robot models, like vision-language-action models (VLAs) or world-action models (WAMs), learn almost entirely by imitation. A person demonstrates a task and the model learns to imitate it. That is enough to showcase impressive, human-like behavior, but they are not reliable in practice. When the robot makes a small mistake, it lands in a situation no demonstration covered, and one mistake leads to the next. The usual remedy is manual: record more demonstrations of how to recover, or have a person step in and correct the robot while it works.

The challenge of real-world reinforcement learning

Reinforcement learning (RL) promises something better: the robot tries, observes the outcome, and adjusts. The obstacle is how many tries it takes. Learning a skill from scratch can take millions of attempts, which is only affordable in simulation, and that is why RL has mostly succeeded on tasks that are easy to simulate. Soft items such as clothing are not. Methods that do learn on real robots have so far relied on many task-specific demonstrations, on hundreds to a thousand practice episodes per task, and often on a person who corrects the robot along the way (Recap, RL tokens). They work, but every new task still costs considerable resources, in terms of robot time and human attention. That does not scale to thousands of tasks across many sites.

Introducing FLEX

We have developed a method called FLEX (Flow Matching Learning from Experience) that lets a robot improve from a few dozen attempts of its own, with nobody stepping in. It builds on the knowledge already inside a pretrained model. With 50 practice attempts per task, the VLA backbone of Cortex 2.0 went from completing 60 to 70% of its attempts to completing 85 to 100% on three tasks from returns handling, and it finished all three faster. The same practice also improved a public VLA, π0.5, but Cortex 2.0 started higher and ended higher: the stronger the pretrained model, the more it gets out of practice.

Why is practice hard for a robot?

A VLA already has a policy: a way of deciding, from what its cameras show, how to move next. That is what it was trained to do, but it makes mistakes. Reinforcement learning is about changing the policy through trial and error.

This is not straightforward, because you cannot tell whether an action was bad just by looking at it. The same grasp might lead to success or to failure far into the future.

To handle this, we train a second model, the critic. It learns what RL calls a value function: from any moment in an attempt, it estimates the probability that the attempt will end in success. With the critic, we can estimate the advantage of each action the robot took: did things turn out better or worse than we anticipated from where we were? In the best case, the robot ends up far better off than expected. It found a shortcut. Estimating the advantage is what allows a robot to learn from experience at all. By shifting the policy toward more advantageous behavior, we improve both how often the robot succeeds and how fast it gets there.

Two ways to learn from experience

Using advantages to improve a policy is a widely used approach. So what is it that lets FLEX learn so quickly on real-world tasks? It comes down to how experience is used. In reinforcement learning, there is a dichotomy between two ways to learn from experience:

On-policy learning uses only experience collected with the current policy. This accurately represents what the robot needs to improve right now, given what it currently struggles with. The drawback is that as soon as the policy changes, all of the previous data is outdated.
Off-policy learning uses all the experience that has ever been collected, even with other policies. This makes it possible to accumulate experience over time, or across a fleet. The drawback is that old data no longer accurately portrays what the policy needs to improve on right now.

Previous methods typically lean on one or the other. On-policy methods need so much fresh data that they have mostly stayed in simulation. Off-policy methods for robot models reuse data well, but have proven to need on the order of hundreds to thousands of trials, human interventions, and task-specific demos.

How FLEX learns efficiently

The key difference of FLEX is that it adaptively combines the types of data. It mixes the demonstrations, the off-policy data, and the fresh on-policy experience in order to improve itself most efficiently. It works as a loop of four steps, as illustrated below:

Practice. The robot attempts the task a few times with its current policy. Each attempt ends as a success or a failure.
Remember. The new attempts are added to a memory of the last few rounds.
Judge. The critic scores every action: did it turn out better or worse than expected?
Improve. The policy is shifted towards advantageous actions adaptively. FLEX uses fresh experience to learn what the policy needs to improve on right now, off-policy data to draw on previous experience, and demonstrations to remind the policy of how the task is done.

Then the loop starts again with the updated policy.

Three principles for learning efficiently from experience

How is FLEX able to improve so efficiently from all three sources of data, while state-of-the-art methods struggle? FLEX learns from both on-policy and off-policy data, and it accounts for the benefits and drawbacks of each.

On-policy data is of high quality: it shows the errors and successes the current version of the policy actually encounters, which is exactly what learning should reinforce. But it is sparse, and reusing the same few attempts for too many updates leads to overfitting and degrades the policy.

Off-policy data is abundant, but it does not represent the policy's current behavior: what it is failing on now, and how it can improve.

With this in mind, FLEX follows three principles to use its data as efficiently as possible:

Trust fresh experience more than old. FLEX uses data from previous versions of itself, but it places more importance on the experience it just collected. That experience best describes what the policy should focus on now: its recent attempts, failures and wins.
Vet the critic before it guides the policy. With so little data, new experience can fall outside what the critic has seen before. In those situations, following the critic's signal can lead the policy astray. FLEX checks the quality of the critic and adapts how much it trusts the critic's estimates when improving the policy.
Confirm changes over time. A policy is made of millions of adjustable numbers. Think of them as knobs. Every update suggests a direction to turn each one. Some suggestions reflect a real lesson, and others are coincidence. Building on findings on cautious optimizers (Liang et al., 2026), FLEX turns a knob only when the new suggestion agrees with the direction that knob has been turning recently. A lesson that keeps showing up is applied. A one-off is ignored.

Results on real robots

Each task started from 100 pre-collected human demonstrations. The robot then practiced for 10 rounds of 5 attempts, with nobody correcting it. We trained two models: the VLA backbone of Cortex 2.0, pretrained on industrial robot data, and π0.5, a publicly available model.

Better pretraining helps, but up to a limit. Still relying on imitation, Cortex 2.0 starts ahead on every task compared to π0.5, showing that stronger pretrained VLAs perform better but saturate at 60-70% on real-world tasks.
A stronger backbone gets more out of practice. Both VLAs improve, but applying FLEX to Cortex 2.0 results in the strongest combination. With practice it also learned to recover from its own mistakes, for example by re-grasping after a failed grasp. π0.5 improved mostly by making fewer mistakes, not discovering new corrective behavior.
Both got faster. π0.5 finished 5 to 20% sooner after practice. Cortex 2.0 was already 17 to 48% faster than π0.5, and practice made it faster again on all three tasks.

Built for a fleet

One robot practicing is useful. Many robots practicing for one shared policy is a scalable way to learn from a quickly increasing amount of fleet-wide experience. FLEX runs on a learning system built for fleet deployment:

On site, a local copy of the policy runs next to the robots, so control never waits for a distant server.
Experience flows up. Every attempt goes to an online buffer in the training cluster: camera images, robot state, and whether it succeeded. The pre-collected human demonstrations sit in a separate offline buffer.
Policies flow down. A large-scale GPU cluster trains one shared policy on the experience of all robots and sends each new version to every site.

This allows for fleet-wide learning, which can reap from experience from the whole fleet to accelerate improvement. If one robot encounters a new technique, this will be broadcast to all robots with the new version, allowing them to use this technique to further improve their skills.

The road ahead

FLEX shows that reaching high success rates on real-world tasks from a few dozen trials is possible without any simulation or manual human corrections. This sets a clear course toward robots that can learn efficiently while producing value. Two trends point to the scaling directions. First, FLEX benefits from strong pretraining, so it will benefit from efforts to train on increasingly large amount of demonstration data. Second, as FLEX is ready for fleet-wide deployment, it can reap the benefits of experience accumulated across a growing fleet. Together, these lead to robots that swiftly improve their efficiency and that are reliable and revenue-generating.

Article Resources

Access content and assets from this post

Abstract Robots that learn by copying people hit a ceiling. With FLEX, our new learning method, Cortex 2.0 keeps getting better by practicing on its own. After 50 attempts per task, its success on three returns-handling tasks rose from 60-70% to 85-100%. This was on real hardware, with no simulator and nobody stepping in to correct it. It also got faster, and it learned to recover from its own mistakes, which no one had shown it how to do. Every robot can share what it learns, so this is a step toward fleets that get better simply by doing their job. How do you get good at folding a T-shirt? Someone shows you how, and then you fold a lot of T-shirts. Being shown gets you started, but practice is what makes you fast and reliable. At Sereact, this is a core challenge that we are tackling. Our robots work in logistics, where new items and new tasks arrive all the time. For us the question is how quickly a robot becomes reliable at something new, and whether what one robot learns can benefit every robot in the fleet. Why imitation is not enough Today's robot models, like vision-language-action models (VLAs) or world-action models (WAMs), learn almost entirely by imitation. A person demonstrates a task and the model learns to imitate it. That is enough to showcase impressive, human-like behavior, but they are not reliable in practice. When the robot makes a small mistake, it lands in a situation no demonstration covered, and one mistake leads to the next. The usual remedy is manual: record more demonstrations of how to recover, or have a person step in and correct the robot while it works. The challenge of real-world reinforcement learning Reinforcement learning (RL) promises something better: the robot tries, observes the outcome, and adjusts. The obstacle is how many tries it takes. Learning a skill from scratch can take millions of attempts, which is only affordable in simulation, and that is why RL has mostly succeeded on tasks that are easy to simulate. Soft items such as clothing are not. Methods that do learn on real robots have so far relied on many task-specific demonstrations, on hundreds to a thousand practice episodes per task, and often on a person who corrects the robot along the way (Recap, RL tokens). They work, but every new task still costs considerable resources, in terms of robot time and human attention. That does not scale to thousands of tasks across many sites. Introducing FLEX We have developed a method called FLEX (Flow Matching Learning from Experience) that lets a robot improve from a few dozen attempts of its own, with nobody stepping in. It builds on the knowledge already inside a pretrained model. With 50 practice attempts per task, the VLA backbone of Cortex 2.0 went from completing 60 to 70% of its attempts to completing 85 to 100% on three tasks from returns handling, and it finished all three faster. The same practice also improved a public VLA, π0.5, but Cortex 2.0 started higher and ended higher: the stronger the pretrained model, the more it gets out of practice. Why is practice hard for a robot? A VLA already has a policy: a way of deciding, from what its cameras show, how to move next. That is what it was trained to do, but it makes mistakes. Reinforcement learning is about changing the policy through trial and error. This is not straightforward, because you cannot tell whether an action was bad just by looking at it. The same grasp might lead to success or to failure far into the future. To handle this, we train a second model, the critic. It learns what RL calls a value function: from any moment in an attempt, it estimates the probability that the attempt will end in success. With the critic, we can estimate the advantage of each action the robot took: did things turn out better or worse than we anticipated from where we were? In the best case, the robot ends up far better off than expected. It found a shortcut. Estimating the advantage is what allows a robot to learn from experience at all. By shifting the policy toward more advantageous behavior, we improve both how often the robot succeeds and how fast it gets there. Two ways to learn from experience Using advantages to improve a policy is a widely used approach. So what is it that lets FLEX learn so quickly on real-world tasks? It comes down to how experience is used. In reinforcement learning, there is a dichotomy between two ways to learn from experience: On-policy learning uses only experience collected with the current policy. This accurately represents what the robot needs to improve right now, given what it currently struggles with. The drawback is that as soon as the policy changes, all of the previous data is outdated. Off-policy learning uses all the experience that has ever been collected, even with other policies. This makes it possible to accumulate experience over time, or across a fleet. The drawback is that old data no longer accurately portrays what the policy needs to improve on right now. Previous methods typically lean on one or the other. On-policy methods need so much fresh data that they have mostly stayed in simulation. Off-policy methods for robot models reuse data well, but have proven to need on the order of hundreds to thousands of trials, human interventions, and task-specific demos. How FLEX learns efficiently The key difference of FLEX is that it adaptively combines the types of data. It mixes the demonstrations, the off-policy data, and the fresh on-policy experience in order to improve itself most efficiently. It works as a loop of four steps, as illustrated below: Practice. The robot attempts the task a few times with its current policy. Each attempt ends as a success or a failure. Remember. The new attempts are added to a memory of the last few rounds. Judge. The critic scores every action: did it turn out better or worse than expected? Improve. The policy is shifted towards advantageous actions adaptively. FLEX uses fresh experience to learn what the policy needs to improve on right now, off-policy data to draw on previous experience, and demonstrations to remind the policy of how the task is done. Then the loop starts again with the updated policy. Three principles for learning efficiently from experience How is FLEX able to improve so efficiently from all three sources of data, while state-of-the-art methods struggle? FLEX learns from both on-policy and off-policy data, and it accounts for the benefits and drawbacks of each. On-policy data is of high quality: it shows the errors and successes the current version of the policy actually encounters, which is exactly what learning should reinforce. But it is sparse, and reusing the same few attempts for too many updates leads to overfitting and degrades the policy. Off-policy data is abundant, but it does not represent the policy's current behavior: what it is failing on now, and how it can improve. With this in mind, FLEX follows three principles to use its data as efficiently as possible: Trust fresh experience more than old. FLEX uses data from previous versions of itself, but it places more importance on the experience it just collected. That experience best describes what the policy should focus on now: its recent attempts, failures and wins. Vet the critic before it guides the policy. With so little data, new experience can fall outside what the critic has seen before. In those situations, following the critic's signal can lead the policy astray. FLEX checks the quality of the critic and adapts how much it trusts the critic's estimates when improving the policy. Confirm changes over time. A policy is made of millions of adjustable numbers. Think of them as knobs. Every update suggests a direction to turn each one. Some suggestions reflect a real lesson, and others are coincidence. Building on findings on cautious optimizers (Liang et al., 2026), FLEX turns a knob only when the new suggestion agrees with the direction that knob has been turning recently. A lesson that keeps showing up is applied. A one-off is ignored. Results on real robots Each task started from 100 pre-collected human demonstrations. The robot then practiced for 10 rounds of 5 attempts, with nobody correcting it. We trained two models: the VLA backbone of Cortex 2.0, pretrained on industrial robot data, and π0.5, a publicly available model. Better pretraining helps, but up to a limit. Still relying on imitation, Cortex 2.0 starts ahead on every task compared to π0.5, showing that stronger pretrained VLAs perform better but saturate at 60-70% on real-world tasks. A stronger backbone gets more out of practice. Both VLAs improve, but applying FLEX to Cortex 2.0 results in the strongest combination. With practice it also learned to recover from its own mistakes, for example by re-grasping after a failed grasp. π0.5 improved mostly by making fewer mistakes, not discovering new corrective behavior. Both got faster. π0.5 finished 5 to 20% sooner after practice. Cortex 2.0 was already 17 to 48% faster than π0.5, and practice made it faster again on all three tasks. Built for a fleet One robot practicing is useful. Many robots practicing for one shared policy is a scalable way to learn from a quickly increasing amount of fleet-wide experience. FLEX runs on a learning system built for fleet deployment: On site, a local copy of the policy runs next to the robots, so control never waits for a distant server. Experience flows up. Every attempt goes to an online buffer in the training cluster: camera images, robot state, and whether it succeeded. The pre-collected human demonstrations sit in a separate offline buffer. Policies flow down. A large-scale GPU cluster trains one shared policy on the experience of all robots and sends each new version to every site. This allows for fleet-wide learning, which can reap from experience from the whole fleet to accelerate improvement. If one robot encounters a new technique, this will be broadcast to all robots with the new version, allowing them to use this technique to further improve their skills. The road ahead FLEX shows that reaching high success rates on real-world tasks from a few dozen trials is possible without any simulation or manual human corrections. This sets a clear course toward robots that can learn efficiently while producing value. Two trends point to the scaling directions. First, FLEX benefits from strong pretraining, so it will benefit from efforts to train on increasingly large amount of demonstration data. Second, as FLEX is ready for fleet-wide deployment, it can reap the benefits of experience accumulated across a growing fleet. Together, these lead to robots that swiftly improve their efficiency and that are reliable and revenue-generating.