Adaptive Domain Modeling with Language Models: A Multi-Agent Approach to Task Planning

Imagine you are trying to teach a robot how to cook dinner. In the old days, scientists had to write a massive, rigid instruction manual for every single possible scenario: "If the pot is red, do X. If the pot is blue, do Y." If the robot encountered a green pot, or a task it hadn't seen before, it would freeze because the manual didn't cover it. This is the world of symbolic planning, where computers follow strict, pre-written rules. It's powerful, but it's like a GPS that only knows roads drawn on a map from 1990; if a new road opens, the GPS gets lost.

On the other hand, we now have Large Language Models (LLMs), the super-smart AI brains that can chat, write stories, and understand human language. They are incredibly flexible and can guess what you mean even if you say things weirdly. However, they are also a bit like a brilliant but scatterbrained artist: they might dream up a plan that sounds great but is physically impossible for a robot to actually do, or they might forget the laws of physics entirely.

The big question for scientists is: How do we combine the strict reliability of the old rule-following robots with the flexible, creative brain of the new AI? We need a system that can understand a messy, real-world request like "Make a tower with the biggest block on the bottom," and then figure out how to build it, even if the robot has never seen a "biggest block" before. This is where the paper you are about to read comes in, offering a new way to let robots learn on the fly.

---

Meet TAPAS: The Robot's Team of Creative Architects

Meet TAPAS (Task-based Adaptation and Planning using AgentS). Think of TAPAS not as a single robot brain, but as a tiny, highly organized construction crew working inside a computer. Instead of one person trying to do everything, TAPAS splits the job up among three specialized "agents" (little AI workers), each with a specific role, who talk to each other to build a plan.

Here is how this team works, using a simple analogy: Imagine you want to build a tower out of blocks, but you tell the team, "I want the red block on top of the blue one."

1. The Domain Generator (The Rulebook Writer)
First, the Domain Generator listens to your request. In the old days, if the robot didn't know what "red" or "blue" meant in its rulebook, it would just say, "Error! I don't know that word!" and stop. But TAPAS is different. If the Domain Generator realizes, "Hey, our current rulebook doesn't have a way to describe colors," it doesn't panic. It says, "Okay, we need to add a 'color' rule to our rulebook." It literally rewrites the robot's internal instruction manual on the spot to include this new concept.

2. The Initial State Generator (The Scene Setter)
Next, the Initial State Generator looks at the room. It sees the blocks on the table. If the rulebook just got updated to include "color," this agent asks, "Wait, what color is each block?" If you didn't tell it, it might ask you (or the simulation) for that info. It sets the stage, making sure the robot knows exactly where every block is and what color it is, matching the new rules.

3. The Goal State Generator (The Target Setter)
Finally, the Goal State Generator looks at your wish: "Red on top of blue." It checks the new rulebook and the scene. It says, "Got it. The goal is to stack them so the red one is on top."

The Magic of "Tool-Calling"
The coolest part is how they talk. They don't just guess; they use "tools." If the Goal Generator sees a problem (like, "We can't stack blocks by size because we don't have a 'size' rule yet"), it pulls out a tool called missing_fluent and says to the Domain Generator, "Hey, we need a rule for size!" The Domain Generator then updates the rulebook, and the whole team starts over with the new, better instructions. It's like a group of friends building a Lego set where, if they realize they are missing a specific piece, one friend runs to the store to buy it, and then they all keep building together.

From "What" to "How": The Execution Team

Once the plan is written, TAPAS has to actually make the robot move. This is tricky because the plan might say "Place block A on block B," but the robot's physical arm might only know how to "Move gripper to coordinates X, Y, Z."

TAPAS uses a Plan Executor to bridge this gap. It acts like a translator.

• The Translator: It takes the fancy, high-level plan and turns it into simple, natural language instructions like "Move your arm to the left" or "Grab the red block."
• The ReAct Agent: This is the robot's "Reason and Act" brain. It looks at the instruction, checks what tools (skills) the robot actually has, and picks the best one. If the robot tries to grab a block and misses, the Validator Agent (the supervisor) says, "Whoops, that didn't work. Try again, but maybe move your arm slower."

What Did They Find?

The authors tested TAPAS in two main ways: on classic logic puzzles and in a simulated 3D house called VirtualHome.

1. The Logic Puzzles (The Benchmarks)
They tested TAPAS on seven different planning challenges, like the famous "Blocksworld" (stacking blocks) and "Barman" (mixing drinks).

• The Result: TAPAS was incredibly good. When using a top-tier AI model (GPT-4o), it solved 97% of the "Barman" problems and 100% of the "Blocksworld" problems.
• The Comparison: This was much better than using other AI models or just trying to force the AI to do everything without a structured plan. For example, in the "Blocksworld" test, TAPAS solved 100% of the problems, while other methods struggled significantly.

2. The "New Rules" Test (Adaptability)
This is where TAPAS really shines. The researchers gave the robot tasks it had never seen before, like "Stack the blocks so the biggest one is on the bottom" or "Move the blocks, but make sure the robot doesn't run out of battery."

• The Result: TAPAS successfully figured out that it needed to add "size" or "battery" rules to its rulebook. It did this automatically.
  • For the "size" task, it updated the rules to say, "You can only stack a block on top of a bigger one." It solved 90% of these new, tricky problems.
  • For the "battery" task, it added rules about energy consumption. It solved 100% of the "Grippers" (robot hand) battery problems.
• The Catch: It wasn't perfect. In the "Floortile" (cleaning tiles) test with battery constraints, it only solved 70% of the problems. The paper suggests this was because the AI sometimes guessed the starting battery level instead of asking for it, showing that the system still needs to be careful about making assumptions.

3. The VirtualHome Simulation
Finally, they put TAPAS in a 3D simulation of a house. The task was: "Get a pie from the fridge and put it on the table," and "Warm up some salmon and put it on the table."

• The Result: TAPAS successfully generated a plan, translated it into actions, and guided a virtual robot to open the fridge, grab the food, use the microwave, and place the items on the table.
• The Memory Trick: They also tested if TAPAS could learn from mistakes. They told the system, "Next time you use the fridge, make sure to close it, even if I don't say so." Later, when the robot faced a similar task, it remembered this rule and closed the fridge automatically. This showed that TAPAS can store "procedural memory" to get better over time.

Why This Matters (And What It Isn't)

The paper suggests that TAPAS is a strong step forward because it combines the best of both worlds: the creativity of AI that understands language and the reliability of strict planning rules. It doesn't just follow a script; it can rewrite the script when the situation changes.

However, the authors are careful to note that this is a simulation. They tested it in a computer world (VirtualHome) and on standard logic puzzles, not on a real robot in a messy, real-world kitchen. While the results are promising, the paper admits that real-world deployment still faces challenges, like preventing the AI from "hallucinating" (making up facts) or handling errors that are too complex to fix automatically.

In short, TAPAS is like a robot that doesn't just follow a map; it can draw a new map when it finds a roadblock, ask for directions if it's lost, and remember the shortcut for next time. It's not a perfect robot yet, but it's a very smart one that's learning how to think on its feet.