instruction stringlengths 627 1.62k | input stringlengths 22 84 | output dict |
|---|---|---|
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get some water
response:
{
"thoughts": I pour water, take a cloth, go to the dining room, clean, take the cloth to the kitchen,
"actions": ['[FIND] <cloth_napkin>', '[GRAB] <cloth_napkin>', '[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[TURNTO] <chair>', '[WIPE] <chair>', '[PUSH] <chair>', '[WALK] <dining_room>', '[DROP] <cloth_napkin>']
}
|
Task:Watch TV.
response:
| {
"thoughts": "Sit on my couch directly opposite my tv , switch on my tv with the remote control and watch",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TOUCH] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Wash dirty dishes
response:
{
"thoughts": Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']
}
|
Task:Clean mirror.
response:
| {
"thoughts": "Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <bathroom_cabinet>",
"[FIND] <bathroom_cabinet>",
"[OPEN] <bathroom_cabinet>",
"[FIND] <paper_towel>",
"[GRAB] <paper_towel>",
"[CLOSE] <bathroom_cabinet>",
"[WALK] <mirror>",
"[WIPE] <mirror>",
"[FIND] <trashcan>",
"[PUTBACK] <paper_towel> <trashcan>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Work
response:
{
"thoughts": I have my desktop computer set up on my desk and complete the paperwork I brought home with me from work.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <check> <desk>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Task:Study.
response:
| {
"thoughts": "Study norwegian",
"actions": [
"[WALK] <home_office>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <chair>",
"[SIT] <chair>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Change sheets and pillow cases
response:
{
"thoughts": Bring into the bedroom one fitted sheet, one top sheet and one pillow case. Place them to the side. Remove the sheets that are on the bed. Remove the pillow case that is on the pillow. Put the things that were removed in the dirty clothes hamper. Then unfold the fitted sheet and place it on the mattress. Make sure it is placed on evenly. Then unfold the top sheet and place it on top of the fitted sheet. Make sure it is placed on evenly. Then fold the top of the top sheet back by one foot evenly. Then put the pillow in the clean pillow case. Put the pillow case at the head of the bed.,
"actions": ['[FIND] <pillow>', '[TURNTO] <pillow>', '[LOOKAT] <pillow>', '[GRAB] <pillow>']
}
|
Task:Make popcorn.
response:
| {
"thoughts": "Lay popcorn bag flat inside microwave and press popcorn button to start.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <microwave>",
"[TURNTO] <microwave>",
"[OPEN] <microwave>",
"[PUTIN] <food_food> <microwave>",
"[CLOSE] <microwave>",
"[SWITCHON] <microwave>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Write book
response:
{
"thoughts": Writing a book,
"actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <electrical_outlet>', '[PLUGIN] <laptop>', '[WALK] <love_seat>', '[SIT] <love_seat>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Task:Put toys away.
response:
| {
"thoughts": "Pick up toys from the floor. Put toys into specific bins. Put bins away on the bookshelf.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[FIND] <bookshelf>",
"[OPEN] <bookshelf>",
"[PUTBACK] <toy> <bookshelf>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[PUTBACK] <toy> <bookshelf>",
"[CLOSE] <bookshelf>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Write book
response:
{
"thoughts": Writing a book,
"actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <electrical_outlet>', '[PLUGIN] <laptop>', '[WALK] <love_seat>', '[SIT] <love_seat>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Task:Open window.
response:
| {
"thoughts": "Unlock the latch at the top. Push the bottom half of the window upwards.",
"actions": [
"[WALK] <home_office>",
"[WALK] <window>",
"[OPEN] <window>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Unload various items from pockets and place them in bowl on table
response:
{
"thoughts": I remove my belongings from my pockets when I enter my home and place them in a bowl on a table near the door,
"actions": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <bowl>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <table>', '[FIND] <clothes_pants>', '[FIND] <bills>', '[GRAB] <bills>', '[FIND] <phone>', '[GRAB] <phone>']
}
|
Task:Turn light off.
response:
| {
"thoughts": "Put the light switch into the down, or off, position.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHOFF] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Re arrange office
response:
{
"thoughts": Walk in.Turn on light.Move furniture. Change the room,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[PUSH] <desk>', '[WALK] <chair>', '[PUSH] <chair>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>']
}
|
Task:Shredding.
response:
| {
"thoughts": "Shred old documents",
"actions": [
"[WALK] <home_office>",
"[WALK] <filing_cabinet>",
"[FIND] <check>",
"[GRAB] <check>",
"[WALK] <shredder>",
"[PLUGIN] <shredder>",
"[PUTBACK] <check> <shredder>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Leave home
response:
{
"thoughts": Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.,
"actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}
|
Task:Manage emails.
response:
| {
"thoughts": "Check the email account for new mails or sending to others.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <chair>",
"[SIT] <chair>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <mail>",
"[GRAB] <mail>",
"[READ] <mail>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[SWITCHOFF] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Put away shoes
response:
{
"thoughts": Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.,
"actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>']
}
|
Task:Fix snack.
response:
| {
"thoughts": "Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[CLOSE] <kitchen_cabinet>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_carrot>",
"[GRAB] <food_carrot>",
"[PUTBACK] <food_carrot> <plate>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[PUTBACK] <food_vegetable> <plate>",
"[CLOSE] <freezer>",
"[WALK] <table>",
"[PUTBACK] <plate> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Write book
response:
{
"thoughts": Writing a book,
"actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <electrical_outlet>', '[PLUGIN] <laptop>', '[WALK] <love_seat>', '[SIT] <love_seat>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Task:Make bed.
response:
| {
"thoughts": "Pull up the sheets. Pull up the comforter. Arrange pillows on the bed. Arrange stuffed animals on the bed.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <filing_cabinet>",
"[FIND] <sheets>",
"[GRAB] <sheets>",
"[FIND] <bed>",
"[PUTBACK] <sheets> <bed>",
"[FIND] <sheets>",
"[GRAB] <sheets>",
"[PUTBACK] <sheets> <bed>",
"[FIND] <pillow>",
"[GRAB] <pillow>",
"[PUTBACK] <pillow> <bed>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[PUTBACK] <toy> <bed>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Walk through
response:
{
"thoughts": Walk through the hallway.,
"actions": ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']
}
|
Task:Hang keys.
response:
| {
"thoughts": "Remove keys from purse, pocket or hand. Place in designated area (bowl, or on hook). Leave area",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[FIND] <purse>",
"[GRAB] <purse>",
"[OPEN] <purse>",
"[FIND] <keys>",
"[GRAB] <keys>",
"[FIND] <bowl>",
"[PUTBACK] <keys> <bowl>",
"[CLOSE] <purse>",
"[PUTOBJBACK] <purse>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Sleep
response:
{
"thoughts": Going to bed,
"actions": ['[FIND] <bed>', '[TURNTO] <bed>', '[POINTAT] <bed>', '[WASH] <bed>', '[TURNTO] <bed>', '[LOOKAT] <bed>', '[TOUCH] <bed>', '[SIT] <bed>']
}
|
Task:Sit in chair.
response:
| {
"thoughts": "I sit in a chair to rest and eat.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <chair>",
"[FIND] <chair>",
"[PULL] <chair>",
"[SIT] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Wash dishes by hand
response:
{
"thoughts": wash dish in sink, dry, put in cupboard,
"actions": ['[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[SQUEEZE] <dish_soap>', '[PUTOBJBACK] <dish_soap>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WASH] <bowl>', '[RINSE] <bowl>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <bowl>', '[PUTOBJBACK] <towel>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <bowl> <cupboard>', '[CLOSE] <cupboard>']
}
|
Task:Open bathroom window.
response:
| {
"thoughts": "Make sure bathroom window is unlocked. Lift up bathroom window so it is open.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <window>",
"[FIND] <window>",
"[OPEN] <window>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Clean floor
response:
{
"thoughts": Obtain cleaning materials. Wipe down floor.,
"actions": ['[WALK] <bathroom>', '[WALK] <mop>', '[FIND] <mop>', '[GRAB] <mop>', '[FIND] <water>', '[GRAB] <water>', '[PUTBACK] <water> <mop>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[PUTBACK] <cleaning_solution> <mop>', '[GRAB] <cleaning_solution>', '[PUTOBJBACK] <cleaning_solution>', '[PULL] <mop>', '[PUSH] <mop>', '[PULL] <mop>', '[PUSH] <mop>', '[PULL] <mop>', '[PUSH] <mop>', '[PUTOBJBACK] <mop>']
}
|
Task:Get something to drink.
response:
| {
"thoughts": "Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <cupboard>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[CLOSE] <freezer>",
"[POUR] <milk> <cup>",
"[DRINK] <cup>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Hang car keys
response:
{
"thoughts": Pick up the car keys. Hang them on the key hook.,
"actions": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <keys>', '[GRAB] <keys>', '[WALK] <wall>', '[FIND] <hanger>', '[PUTBACK] <keys> <hanger>']
}
|
Task:Put away keys.
response:
| {
"thoughts": "Return keys into a bag",
"actions": [
"[WALK] <home_office>",
"[WALK] <keys>",
"[FIND] <keys>",
"[GRAB] <keys>",
"[FIND] <bag>",
"[OPEN] <bag>",
"[PUTBACK] <keys> <bag>",
"[CLOSE] <bag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Watch horror movie
response:
{
"thoughts": I would find something scary to watch on dvd,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Task:Put alarm clock in bedroom.
response:
| {
"thoughts": "Take alarm clock. Sit it on stand, next to bed. Plug in alarm clock. Set time, according to watch. Set alarm, depending on what time you have to get up.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <alarm_clock>",
"[FIND] <alarm_clock>",
"[GRAB] <alarm_clock>",
"[FIND] <dresser>",
"[OPEN] <dresser>",
"[PUTBACK] <alarm_clock> <dresser>",
"[SWITCHON] <alarm_clock>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Turn on lights
response:
{
"thoughts": Walk to your lamp, switch it on, and lay on your bed,
"actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TURNTO] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <bed>', '[LIE] <bed>']
}
|
Task:Grab some juice.
response:
| {
"thoughts": "I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <cupboard>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <juice>",
"[GRAB] <juice>",
"[POUR] <juice> <cup>",
"[PUTOBJBACK] <juice>",
"[CLOSE] <freezer>",
"[FIND] <table>",
"[PUTBACK] <cup> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get glass of water
response:
{
"thoughts": Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <kitchen_cabinet>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>']
}
|
Task:Shut front door.
response:
| {
"thoughts": "Close the storm door. Lock the storm door.",
"actions": [
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Write school paper
response:
{
"thoughts": Writing and drafting a paper for class work,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}
|
Task:Put in chair.
response:
| {
"thoughts": "Take a comfortable chair. Place it in the entrance hall",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[GRAB] <chair>",
"[WALK] <home_office>",
"[WALK] <floor>",
"[FIND] <floor>",
"[PUTBACK] <chair> <floor>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Clean mirror
response:
{
"thoughts": Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks.,
"actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[WIPE] <mirror>', '[FIND] <trashcan>', '[PUTBACK] <paper_towel> <trashcan>']
}
|
Task:Organize pantry.
response:
| {
"thoughts": "Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <pantry>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[FIND] <garbage_can>",
"[PUTBACK] <food_food> <garbage_can>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[TURNTO] <food_vegetable>",
"[LOOKAT] <food_vegetable>",
"[PUTBACK] <food_vegetable> <garbage_can>",
"[FIND] <dry_pasta>",
"[GRAB] <dry_pasta>",
"[TURNTO] <dry_pasta>",
"[LOOKAT] <dry_pasta>",
"[PUTOBJBACK] <dry_pasta>",
"[FIND] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[PUSH] <food_food>",
"[FIND] <food_noodles>",
"[GRAB] <food_noodles>",
"[TURNTO] <food_noodles>",
"[LOOKAT] <food_noodles>",
"[PUTOBJBACK] <food_noodles>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Eat dinner
response:
{
"thoughts": Sit at the table and eat a meal.,
"actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <plate>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <plate>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[EAT] <plate>']
}
|
Task:Push in desk chair.
response:
| {
"thoughts": "Push the desk chair until it is under the desk.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <chair>",
"[TOUCH] <chair>",
"[PUSH] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Manage emails
response:
{
"thoughts": Check the email account for new mails or sending to others.,
"actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>']
}
|
Task:Clean screen.
response:
| {
"thoughts": "Use a soft rag to wipe the screen until there are no marks on it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <computer>",
"[WIPE] <computer>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Put clothes away
response:
{
"thoughts": Separate the clean and folded laundry by owner (which child) and type (pants, pajamas, short-sleeved shirts, etc.). Place each type in the dresser drawer containing the same type of item owned by the same child.,
"actions": ['[WALK] <bedroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <clothes_pants> <dresser>', '[CLOSE] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <clothes_pants> <dresser>', '[CLOSE] <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <clothes_shirt> <dresser>', '[CLOSE] <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <clothes_shirt> <dresser>', '[CLOSE] <dresser>']
}
|
Task:Use laptop.
response:
| {
"thoughts": "Sit down on a couch and perform tasks such as navigating the internet on a laptop",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <laptop>",
"[SWITCHON] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <keyboard>",
"[LOOKAT] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Take dishes out of dishwasher
response:
{
"thoughts": Take clean dishes out of the dishwasher and put away,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>']
}
|
Task:Grab things.
response:
| {
"thoughts": "The robot will need some kind of hands or grabbing device to transport objects.",
"actions": [
"[WALK] <novel>",
"[TURNTO] <novel>",
"[GRAB] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Draft home
response:
{
"thoughts": Using mathematics and CAD software design a home,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}
|
Task:De-wrinkle sheet.
response:
| {
"thoughts": "Go to the bed. Remove all items from on top of the bed, including blankets and comforters, until the sheet is showing. Gently go around the bed and pull each corner of the sheet until it is smooth on the bed.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <bed>",
"[FIND] <sheets>",
"[GRAB] <sheets>",
"[FIND] <basket_for_clothes>",
"[PUTBACK] <sheets> <basket_for_clothes>",
"[FIND] <sheets>",
"[GRAB] <sheets>",
"[PUTBACK] <sheets> <basket_for_clothes>",
"[FIND] <sheets>",
"[TOUCH] <sheets>",
"[PULL] <sheets>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Print out papers
response:
{
"thoughts": Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,
"actions": ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']
}
|
Task:Put umbrella away.
response:
| {
"thoughts": "Place the umbrella in the umbrella bucket point first.",
"actions": [
"[WALK] <home_office>",
"[WALK] <mop_bucket>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Draw picture
response:
{
"thoughts": Pick up a pad of paper and a pen. Draw a picture.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <desk>', '[OPEN] <desk>', '[FIND] <check>', '[GRAB] <check>', '[PUTBACK] <check> <desk>', '[FIND] <pencil>', '[GRAB] <pencil>', '[CLOSE] <desk>']
}
|
Task:Juggling.
response:
| {
"thoughts": "The robot would catch any items thrown at it and immediately start to juggle them at a pro level. It would have a max of 6 items it can juggle at once. That would be awesome to watch.",
"actions": [
"[FIND] <computer>",
"[TURNTO] <computer>",
"[POINTAT] <computer>",
"[WATCH] <computer>",
"[SWITCHON] <computer>",
"[TOUCH] <computer>",
"[WALK] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Take shower
response:
{
"thoughts": In the morning wake up and take a hot shower to start your day,
"actions": ['[FIND] <water>', '[TURNTO] <water>', '[POINTAT] <water>', '[WASH] <water>', '[TURNTO] <water>', '[LOOKAT] <water>']
}
|
Task:Paint ceiling.
response:
| {
"thoughts": "Take a paint can opener and open bucket of paint. Pour some of the paint into the paint tray. Roll the roller around in the paint tray and then roll the paint roller it across the ceiling until completely covered. Repeat rolling the paint roller in the paint tray as needed to finish the ceiling.",
"actions": [
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[POINTAT] <drawing>",
"[WATCH] <drawing>",
"[TOUCH] <drawing>",
"[WALK] <bedroom>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Wash hands
response:
{
"thoughts": Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Task:Place centerpiece.
response:
| {
"thoughts": "Move the centerpiece until it is centered in the middle of the table.",
"actions": [
"[WALK] <home_office>",
"[WALK] <table>",
"[FIND] <centerpiece>",
"[TURNTO] <centerpiece>",
"[LOOKAT] <centerpiece>",
"[GRAB] <centerpiece>",
"[PULL] <centerpiece>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Put away groceries
response:
{
"thoughts": Place groceries in refrigerator from shopping at the grocery store.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}
|
Task:Hand washing.
response:
| {
"thoughts": "Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <soap>",
"[WASH] <hands_both>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <hands_both>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Look at mirror
response:
{
"thoughts": I look at my reflection to check my cleanliness.,
"actions": ['[WALK] <bathroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>']
}
|
Task:Wipe down counter.
response:
| {
"thoughts": "Clean counter",
"actions": [
"[WALK] <dining_room>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <rag>",
"[SQUEEZE] <rag>",
"[SWITCHOFF] <faucet>",
"[WALK] <kitchen_counter>",
"[WIPE] <kitchen_counter>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Add paper to printer
response:
{
"thoughts": Take a stack of paper, about 25 pieces. Place carefully in the paper tray.,
"actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[WALK] <fax_machine>', '[PUTBACK] <printing_paper> <fax_machine>']
}
|
Task:Print out papers.
response:
| {
"thoughts": "Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.",
"actions": [
"[WALK] <home_office>",
"[WALK] <fax_machine>",
"[FIND] <fax_machine>",
"[SWITCHON] <fax_machine>",
"[FIND] <printing_paper>",
"[GRAB] <printing_paper>",
"[PUTBACK] <printing_paper> <fax_machine>",
"[FIND] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[GRAB] <printing_paper>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Eat snacks and drink tea
response:
{
"thoughts": Sitting in teak deck chair, eat snacks like guacamole and blue corn chips, and drink a cup of tea.,
"actions": ['[FIND] <chair>', '[TURNTO] <chair>', '[POINTAT] <chair>', '[WASH] <chair>', '[TURNTO] <chair>', '[LOOKAT] <chair>', '[TOUCH] <chair>', '[SIT] <chair>']
}
|
Task:Get glass of water.
response:
| {
"thoughts": "Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <kitchen_cabinet>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[PUTBACK] <cup> <sink>",
"[GRAB] <cup>",
"[SWITCHOFF] <faucet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Watch youtube
response:
{
"thoughts": Go to youtube.Com watch videos,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Task:Iron shirt.
response:
| {
"thoughts": "Set up an ironing board and an iron. Lay a shirt on board. Run iron over shirt until it is free of wrinkles.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <ironing_board>",
"[FIND] <ironing_board>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTBACK] <clothes_shirt> <ironing_board>",
"[FIND] <iron>",
"[GRAB] <iron>",
"[PLUGIN] <iron>",
"[PLUGOUT] <iron>",
"[PUTOBJBACK] <iron>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Dry soap bottles
response:
{
"thoughts": Go to the shower or bath. Locate bottles of soap or shampoo. Pick up each bottle and, using a towel, dry off the bottle. Return each bottle to its original location.,
"actions": ['[FIND] <towel>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[FIND] <soap>', '[WIPE] <soap>', '[GRAB] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <shampoo>', '[GRAB] <shampoo>', '[WIPE] <shampoo>', '[PUTOBJBACK] <shampoo>', '[FIND] <shampoo>', '[GRAB] <shampoo>', '[WIPE] <shampoo>', '[PUTOBJBACK] <shampoo>']
}
|
Task:Try yourself off.
response:
| {
"thoughts": "After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[FIND] <dresser>",
"[OPEN] <dresser>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[CLOSE] <dresser>",
"[FIND] <face>",
"[WIPE] <face>",
"[FIND] <arms_both>",
"[WIPE] <arms_both>",
"[FIND] <legs_both>",
"[WIPE] <legs_both>",
"[FIND] <feet_both>",
"[WIPE] <feet_both>",
"[FIND] <basket_for_clothes>",
"[PUTBACK] <towel> <basket_for_clothes>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Put on coat and shoes
response:
{
"thoughts": Choose a coat from the coat rack. Put on the coat. Choose a pair of shoes from the shoe rack. Put on the shoes.,
"actions": ['[FIND] <shoes>', '[TURNTO] <shoes>', '[POINTAT] <shoes>', '[WASH] <shoes>']
}
|
Task:Get ready for day.
response:
| {
"thoughts": "Grab shoes, purse etc and head out the door!",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[FIND] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[PUTON] <clothes_dress>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PUTON] <shoes>",
"[FIND] <purse>",
"[GRAB] <purse>",
"[CLOSE] <dresser>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Brush teeth
response:
{
"thoughts": Take toothbrush and toothpaste out of drawer, put toothpaste on toothbrush, start water from faucet. Wet toothbrush. Brush teeth. Rinse toothbrush and place back in drawer.,
"actions": ['[FIND] <brush>', '[GRAB] <brush>', '[TURNTO] <brush>', '[POINTAT] <brush>', '[WASH] <brush>', '[TURNTO] <brush>', '[LOOKAT] <brush>', '[PUTOBJBACK] <brush>']
}
|
Task:Eat snacks and drink tea.
response:
| {
"thoughts": "Sitting in teak deck chair, eat snacks like guacamole and blue corn chips, and drink a cup of tea.",
"actions": [
"[FIND] <chair>",
"[TURNTO] <chair>",
"[POINTAT] <chair>",
"[WASH] <chair>",
"[TURNTO] <chair>",
"[LOOKAT] <chair>",
"[TOUCH] <chair>",
"[SIT] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Leave home
response:
{
"thoughts": Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.,
"actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}
|
Task:Put away toys.
response:
| {
"thoughts": "With a child's help (assuming he is old enough) gather the toys played with that day and put them in their proper locations in the room.",
"actions": [
"[FIND] <child>",
"[FIND] <toy>",
"[WALK] <toy>",
"[GRAB] <toy>",
"[FIND] <filing_cabinet>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[WALK] <toy>",
"[GRAB] <toy>",
"[FIND] <filing_cabinet>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[WALK] <toy>",
"[GRAB] <toy>",
"[FIND] <filing_cabinet>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Hang pictures
response:
{
"thoughts": My daughter was a week early which threw us for a loop. I'm still hanging pictures in her nursery.,
"actions": ['[WALK] <bedroom>', '[WALK] <drawing>', '[FIND] <drawing>', '[GRAB] <drawing>', '[FIND] <wall>', '[PUTBACK] <drawing> <wall>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[FIND] <drawing>', '[GRAB] <drawing>', '[PUTBACK] <drawing> <wall>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}
|
Task:Sew.
response:
| {
"thoughts": "Using the sewing machine to fix and make clothes",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[CLOSE] <dresser>",
"[FIND] <chair>",
"[SIT] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Find dictionary
response:
{
"thoughts": Move towards the bookshelf, scan the bookshelf for the dictionary, when the dictionary is found, pick up the dictionary.,
"actions": ['[WALK] <home_office>', '[WALK] <bookshelf>', '[TURNTO] <bookshelf>', '[LOOKAT] <bookshelf>', '[TURNTO] <bookshelf>', '[LOOKAT] <bookshelf>', '[TURNTO] <bookshelf>', '[LOOKAT] <bookshelf>', '[TURNTO] <bookshelf>', '[LOOKAT] <bookshelf>', '[TURNTO] <bookshelf>', '[LOOKAT] <bookshelf>', '[TURNTO] <bookshelf>', '[LOOKAT] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>']
}
|
Task:Write report.
response:
| {
"thoughts": "Sit at a desk, turn on a computer. Open an existing document and revise it. Print a hard copy for mailing. Email a copy to the client.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[PULL] <mouse>",
"[TOUCH] <mouse>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[TYPE] <keyboard>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[TYPE] <keyboard>",
"[TOUCH] <mouse>",
"[FIND] <fax_machine>",
"[SWITCHON] <fax_machine>",
"[SWITCHOFF] <fax_machine>",
"[SWITCHOFF] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Wash hands
response:
{
"thoughts": Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Task:Look out window.
response:
| {
"thoughts": "I head into my child's room and look out the window to view the neighborhood from a different area in the house.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <window>",
"[TURNTO] <window>",
"[LOOKAT] <window>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Turn off TV
response:
{
"thoughts": Walk over to tv and press power button,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>']
}
|
Task:Getting dresses.
response:
| {
"thoughts": "Putting on undergarments and clothes",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[FIND] <dresser>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTON] <clothes_pants>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTON] <clothes_shirt>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Research
response:
{
"thoughts": I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>']
}
|
Task:Sit.
response:
| {
"thoughts": "We sit at the dining room table",
"actions": [
"[WALK] <dining_room>",
"[WALK] <chair>",
"[FIND] <chair>",
"[PULL] <chair>",
"[SIT] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Vacuum
response:
{
"thoughts": Plug vacuum into the wall. Turn on the vacuum. Move vacuum around the floor to clean it. Unplug vacuum.,
"actions": ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[FIND] <electrical_outlet>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[PUTOBJBACK] <vacuum_cleaner>']
}
|
Task:Greet people.
response:
| {
"thoughts": "Say HI to those that come in.",
"actions": [
"[WALK] <home_office>",
"[WALK] <woman>",
"[FIND] <woman>",
"[GREET] <woman>",
"[FIND] <woman>",
"[GREET] <woman>",
"[FIND] <man>",
"[GREET] <man>",
"[FIND] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Relax on sofa
response:
{
"thoughts": Walk to living room. Find couch. Sit on couch,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Task:Sleep.
response:
| {
"thoughts": "Going to bed",
"actions": [
"[FIND] <bed>",
"[TURNTO] <bed>",
"[POINTAT] <bed>",
"[WASH] <bed>",
"[TURNTO] <bed>",
"[LOOKAT] <bed>",
"[TOUCH] <bed>",
"[SIT] <bed>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Open front door
response:
{
"thoughts": Walk over to the front door, turn the knob, and open the door.,
"actions": ['[WALK] <home_office>']
}
|
Task:Sort laundry.
response:
| {
"thoughts": "Sort laundry for today's wash",
"actions": [
"[WALK] <bedroom>",
"[WALK] <clothes_pants>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[TURNTO] <clothes_pants>",
"[LOOKAT] <clothes_pants>",
"[WALK] <basket_for_clothes>",
"[PUTBACK] <clothes_pants> <basket_for_clothes>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[TURNTO] <clothes_pants>",
"[LOOKAT] <clothes_pants>",
"[WALK] <basket_for_clothes>",
"[PUTBACK] <clothes_pants> <basket_for_clothes>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[TURNTO] <clothes_shirt>",
"[LOOKAT] <clothes_shirt>",
"[WALK] <basket_for_clothes>",
"[PUTBACK] <clothes_shirt> <basket_for_clothes>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[TURNTO] <clothes_shirt>",
"[LOOKAT] <clothes_shirt>",
"[WALK] <basket_for_clothes>",
"[PUTBACK] <clothes_shirt> <basket_for_clothes>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[TURNTO] <clothes_shirt>",
"[LOOKAT] <clothes_shirt>",
"[WALK] <basket_for_clothes>",
"[PUTBACK] <clothes_shirt> <basket_for_clothes>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Leave home
response:
{
"thoughts": Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.,
"actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}
|
Task:Put on coat and shoes.
response:
| {
"thoughts": "Choose a coat from the coat rack. Put on the coat. Choose a pair of shoes from the shoe rack. Put on the shoes.",
"actions": [
"[FIND] <shoes>",
"[TURNTO] <shoes>",
"[POINTAT] <shoes>",
"[WASH] <shoes>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Put on coat and shoes
response:
{
"thoughts": Choose a coat from the coat rack. Put on the coat. Choose a pair of shoes from the shoe rack. Put on the shoes.,
"actions": ['[FIND] <shoes>', '[TURNTO] <shoes>', '[POINTAT] <shoes>', '[WASH] <shoes>']
}
|
Task:Pick up.
response:
| {
"thoughts": "Pick up toys and place them into the toy box. Put books back onto the shelves. Put shoes into a shoe rack in the closet. Hang up clothing in the closet. Make the beds.",
"actions": [
"[FIND] <toy>",
"[TURNTO] <toy>",
"[POINTAT] <toy>",
"[WASH] <toy>",
"[TURNTO] <toy>",
"[LOOKAT] <toy>",
"[TOUCH] <toy>",
"[WALK] <bedroom>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Turn light off
response:
{
"thoughts": Put the light switch into the down, or off, position.,
"actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>']
}
|
Task:Take dishes out of dishwasher.
response:
| {
"thoughts": "Take clean dishes out of the dishwasher and put away",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[OPEN] <dishwasher>",
"[CLOSE] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get some water
response:
{
"thoughts": I pour water, take a cloth, go to the dining room, clean, take the cloth to the kitchen,
"actions": ['[FIND] <cloth_napkin>', '[GRAB] <cloth_napkin>', '[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[TURNTO] <chair>', '[WIPE] <chair>', '[PUSH] <chair>', '[WALK] <dining_room>', '[DROP] <cloth_napkin>']
}
|
Task:Empty dishwasher and fill dishwasher.
response:
| {
"thoughts": "Open up dishwasher, remove dishes and silverware, putting everything away where it belongs. Fill emptied dishwasher with dirty dishes in kitchen sink and on counter, put Cascade soap in dispenser in dishwasher, close dishwasher door, turn on dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <cupboard>",
"[OPEN] <cupboard>",
"[PUTBACK] <plate> <cupboard>",
"[WALK] <dishwasher>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[WALK] <cupboard>",
"[PUTBACK] <fork> <cupboard>",
"[WALK] <sink>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dishwasher>",
"[PUTBACK] <plate> <dishwasher>",
"[WALK] <sink>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[WALK] <dishwasher>",
"[PUTBACK] <fork> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get glass of milk
response:
{
"thoughts": Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>']
}
|
Task:Have conversation with boyfriend.
response:
| {
"thoughts": "Sit on sofa, talk",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Check email
response:
{
"thoughts": I log onto my computer and then go to the e-mail app, I click on each new email and read them,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>']
}
|
Task:Social media checks.
response:
| {
"thoughts": "Logging on to things like facebook and twitter",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <chair>",
"[SIT] <chair>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Fix snack
response:
{
"thoughts": Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>']
}
|
Task:Spread table with appropriate supplies.
response:
| {
"thoughts": "Spread table cloth and table runner, put table mats in front of every seat, put dinner plates, quarter plates, cutlery on table mats",
"actions": [
"[FIND] <table>",
"[TURNTO] <table>",
"[POINTAT] <table>",
"[WASH] <table>",
"[TURNTO] <table>",
"[LOOKAT] <table>",
"[TOUCH] <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Let baby learn how to walk
response:
{
"thoughts": The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.,
"actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>']
}
|
Task:Turn on TV with remote.
response:
| {
"thoughts": "I pick up the remote from the table in front of the couch, I point the remote at the television and hit the red on button in the upper right corner. This turns the television on.",
"actions": [
"[WALK] <home_office>",
"[WALK] <table>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[SWITCHON] <television>",
"[PUTOBJBACK] <remote_control>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Make coffee
response:
{
"thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Task:Come in and leave home.
response:
| {
"thoughts": "When I leave. I get my shoes, walk in and out.",
"actions": [
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PUTON] <shoes>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Study
response:
{
"thoughts": Study norwegian,
"actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Task:Change clothes.
response:
| {
"thoughts": "Switch your clothes.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[PUTON] <clothes_dress>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Vacuum
response:
{
"thoughts": Plug vacuum into the wall. Turn on the vacuum. Move vacuum around the floor to clean it. Unplug vacuum.,
"actions": ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[FIND] <electrical_outlet>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[PUTOBJBACK] <vacuum_cleaner>']
}
|
Task:Scrubbing living room tile floor is once week activity for me.
response:
| {
"thoughts": "I will scrub the floor with a mop and floor cleaner. I place hot water in the pail and add Mr. Clean. I must move by furniture to mop under and around it. After the floor dries, I will empty the dirty water from the pail, and after the floor dries, I will place the furnish back where it belongs.",
"actions": [
"[FIND] <mop>",
"[TURNTO] <mop>",
"[POINTAT] <mop>",
"[WASH] <mop>",
"[TURNTO] <mop>",
"[LOOKAT] <mop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Wash dishes
response:
{
"thoughts": Place all of the dirty dishes in a sink full of clean, soapy water. Wash them. Rinse them in fresh, running water. Place them in the strainer to dry.,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[PUTBACK] <sponge> <sink>', '[SWITCHON] <faucet>', '[RINSE] <cup>', '[GRAB] <cup>', '[FIND] <dishrack>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[GRAB] <sponge>', '[PUTOBJBACK] <sponge>']
}
|
Task:Give milk to cat.
response:
| {
"thoughts": "Grab milk and pour it into the plate so that the cat can drink",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[POINTAT] <cat>",
"[PULL] <cat>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[FIND] <plate>",
"[POUR] <milk> <plate>",
"[TOUCH] <cat>",
"[SCRUB] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Say goodbye to guests leaving
response:
{
"thoughts": Tell them bye,
"actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[FIND] <man>', '[TOUCH] <man>', '[FIND] <woman>', '[TOUCH] <woman>']
}
|
Task:Clean bathroom.
response:
| {
"thoughts": "I'm going to clean the bathroom, take the brush, wash and rinse the toilet and shower",
"actions": [
"[WALK] <bathroom>",
"[WALK] <brush>",
"[FIND] <brush>",
"[GRAB] <brush>",
"[FIND] <detergent>",
"[GRAB] <detergent>",
"[FIND] <toilet>",
"[PUTBACK] <detergent> <toilet>",
"[FIND] <toilet>",
"[SCRUB] <toilet>",
"[RINSE] <toilet>",
"[FIND] <shower>",
"[SCRUB] <shower>",
"[RINSE] <shower>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Put down bags
response:
{
"thoughts": When walking into the house, putting down the things i am carrying,
"actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <table>', '[PUTBACK] <food_food> <table>']
}
|
Task:Look at painting.
response:
| {
"thoughts": "Walk to the painting. Look up at the painting. Admire it on the wall.",
"actions": [
"[WALK] <home_office>",
"[WALK] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Make toast
response:
{
"thoughts": Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <toaster>']
}
|
Task:Play on laptop.
response:
| {
"thoughts": "Sit down on the couch. Place laptop on lap. Open laptop. Turn on laptop. Choose selected program. Play selected program. Close game. Close laptop.",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[FIND] <couch>",
"[SIT] <couch>",
"[SWITCHON] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[SWITCHOFF] <laptop>",
"[PUTOBJBACK] <laptop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Clean mirror
response:
{
"thoughts": Spray glass cleaner on mirror. Wipe with a clean cloth.,
"actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[WALK] <mirror>', '[PUTOBJBACK] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']
}
|
Task:Throw away newspaper.
response:
| {
"thoughts": "Take the newspaper on the living room table and toss it",
"actions": [
"[WALK] <home_office>",
"[WALK] <table>",
"[FIND] <table>",
"[TURNTO] <table>",
"[FIND] <newspaper>",
"[GRAB] <newspaper>",
"[WALK] <trashcan>",
"[OPEN] <trashcan>",
"[PUTBACK] <newspaper> <trashcan>",
"[CLOSE] <trashcan>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get ready to leave
response:
{
"thoughts": Get shoes on, jacket, etc.,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTON] <clothes_jacket>', '[CLOSE] <dresser>', '[FIND] <phone>', '[GRAB] <phone>']
}
|
Task:Sweep hallway please.
response:
| {
"thoughts": "Vacuum all the way up and down the hallway. Get all the dirt and crumbs out of carpet please.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Story reading time
response:
{
"thoughts": Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures,
"actions": ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>']
}
|
Task:Switch on lamp.
response:
| {
"thoughts": "Press the button so the light comes on.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Put on coat
response:
{
"thoughts": Open closet and grab coat. Put on coat and fasten the front closed. Close closet.,
"actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>']
}
|
Task:Re arrange office.
response:
| {
"thoughts": "Walk in.Turn on light.Move furniture. Change the room",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <desk>",
"[PUSH] <desk>",
"[WALK] <chair>",
"[PUSH] <chair>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <filing_cabinet>",
"[PUSH] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get ready for school
response:
{
"thoughts": Take clothes out of dressers and get dressed for school.,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[CLOSE] <dresser>', '[PUTON] <clothes_dress>']
}
|
Task:Take off shoes.
response:
| {
"thoughts": "Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PULL] <shoes>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[PUTIN] <shoes> <dresser>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PULL] <shoes>",
"[WALK] <dresser>",
"[PUTIN] <shoes> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Use laptop
response:
{
"thoughts": Sit down on a couch and perform tasks such as navigating the internet on a laptop,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}
|
Task:Eat cereal.
response:
| {
"thoughts": "Sit in chair. Put spoon in cereal bowl. Scoop up cereal. Eat.",
"actions": [
"[FIND] <chair>",
"[TURNTO] <chair>",
"[POINTAT] <chair>",
"[WASH] <chair>",
"[TURNTO] <chair>",
"[LOOKAT] <chair>",
"[SIT] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Open front door
response:
{
"thoughts": Walk over to the front door, turn the knob, and open the door.,
"actions": ['[WALK] <home_office>']
}
|
Task:Get drink.
response:
| {
"thoughts": "I go to the fridge and open the door. I look for the water pitcher, and take it out, making sure to close the fridge door behind me. Then I take a pint glass out of the upper cabinet over the sink and use the water pitcher to pour a full glass of water. Then I return the pitcher to the fridge and shut the door again, and take my glass of water out of the kitche.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <kitchen_cabinet>",
"[WALK] <freezer>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <cup>",
"[OPEN] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Pick up toys
response:
{
"thoughts": Grab toys off floor. Put it in a container.,
"actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}
|
Task:Open curtains.
response:
| {
"thoughts": "Gently pull the curtains open, from the middle to the sides.",
"actions": [
"[WALK] <home_office>",
"[WALK] <curtain>",
"[FIND] <curtain>",
"[PULL] <curtain>",
"[FIND] <curtain>",
"[PULL] <curtain>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Take dishes out of dishwasher
response:
{
"thoughts": Take clean dishes out of the dishwasher and put away,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>']
}
|
Task:Get ready for school.
response:
| {
"thoughts": "Take clothes out of dressers and get dressed for school.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[CLOSE] <dresser>",
"[PUTON] <clothes_dress>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Wash dishes by hand
response:
{
"thoughts": wash dish in sink, dry, put in cupboard,
"actions": ['[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[SQUEEZE] <dish_soap>', '[PUTOBJBACK] <dish_soap>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WASH] <bowl>', '[RINSE] <bowl>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <bowl>', '[PUTOBJBACK] <towel>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <bowl> <cupboard>', '[CLOSE] <cupboard>']
}
|
Task:Add paper to printer.
response:
| {
"thoughts": "Take a stack of paper, about 25 pieces. Place carefully in the paper tray.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <printing_paper>",
"[GRAB] <printing_paper>",
"[WALK] <fax_machine>",
"[PUTBACK] <printing_paper> <fax_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Hand washing
response:
{
"thoughts": Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}
|
Task:Read on sofa.
response:
| {
"thoughts": "Pick up book. Sit on sofa. Open book. Read",
"actions": [
"[WALK] <bedroom>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <bookmark>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Computer work
response:
{
"thoughts": Find the computer, Turn on the computer, find keyboard, find mouse, go online,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Task:Restock.
response:
| {
"thoughts": "Restock toothpaste, floss, Q-tips, toilet paper, towels, etc. As needed.",
"actions": [
"[FIND] <bathtub>",
"[TURNTO] <bathtub>",
"[LOOKAT] <bathtub>",
"[TOUCH] <bathtub>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Wash sink
response:
{
"thoughts": I spray some cleaner and wait a minte or so then wipe it out.,
"actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[WALK] <sink>', '[POUR] <cleaning_solution> <sink>', '[PUTOBJBACK] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[WIPE] <sink>', '[WIPE] <sink>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>']
}
|
Task:Read to child.
response:
| {
"thoughts": "Read a book out loud to a child",
"actions": [
"[WALK] <bedroom>",
"[WALK] <child>",
"[FIND] <child>",
"[GREET] <child>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[TURNTO] <novel>",
"[LOOKAT] <novel>",
"[TURNTO] <novel>",
"[POINTAT] <novel>",
"[TURNTO] <novel>",
"[POINTAT] <novel>",
"[READ] <novel>",
"[READ] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Hang up car keys
response:
{
"thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
"actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}
|
Task:File expense reports.
response:
| {
"thoughts": "File expense reports on computer",
"actions": [
"[WALK] <home_office>",
"[WALK] <filing_cabinet>",
"[FIND] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <folder>",
"[GRAB] <folder>",
"[CLOSE] <filing_cabinet>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <desk>",
"[OPEN] <desk>",
"[PUTBACK] <folder> <desk>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[OPEN] <folder>",
"[FIND] <check>",
"[GRAB] <check>",
"[TURNTO] <check>",
"[LOOKAT] <check>",
"[PUTBACK] <check> <desk>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Make coffee
response:
{
"thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Task:Let baby learn how to walk.
response:
| {
"thoughts": "The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[TOUCH] <child>",
"[GREET] <child>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[POINTAT] <couch>",
"[TURNTO] <child>",
"[LOOKAT] <child>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Fix snack
response:
{
"thoughts": Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>']
}
|
Task:Eat cheese.
response:
| {
"thoughts": "Open fridge. Get cheese. Eat it.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_cheese>",
"[GRAB] <food_cheese>",
"[EAT] <food_cheese>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Go to sleep
response:
{
"thoughts": Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep.,
"actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <sheets>', '[PULL] <sheets>']
}
|
Task:Hang with friends.
response:
| {
"thoughts": "Sit with friends. Talk",
"actions": [
"[WALK] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[TURNTO] <man>",
"[LOOKAT] <man>",
"[GREET] <man>",
"[FIND] <woman>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <man>",
"[LOOKAT] <man>",
"[GREET] <man>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Pet dog
response:
{
"thoughts": Pet my dog in hall,
"actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']
}
|
Task:Arrange furniture.
response:
| {
"thoughts": "Move furniture where you want it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <coffee_table>",
"[PUSH] <coffee_table>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <filing_cabinet>",
"[PUSH] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Pull up carpet
response:
{
"thoughts": Pry up a corner of your old dirty carpet. Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.,
"actions": ['[WALK] <home_office>', '[WALK] <mat>', '[FIND] <mat>', '[TOUCH] <mat>', '[PULL] <mat>']
}
|
Task:Unload various items from pockets and place them in bowl on table.
response:
| {
"thoughts": "I remove my belongings from my pockets when I enter my home and place them in a bowl on a table near the door",
"actions": [
"[WALK] <home_office>",
"[WALK] <table>",
"[FIND] <bowl>",
"[GRAB] <bowl>",
"[PUTBACK] <bowl> <table>",
"[FIND] <clothes_pants>",
"[FIND] <bills>",
"[GRAB] <bills>",
"[FIND] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Wash sink
response:
{
"thoughts": I spray some cleaner and wait a minte or so then wipe it out.,
"actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[WALK] <sink>', '[POUR] <cleaning_solution> <sink>', '[PUTOBJBACK] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[WIPE] <sink>', '[WIPE] <sink>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>']
}
|
Task:vacuum carpet.
response:
| {
"thoughts": "I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Type up document
response:
{
"thoughts": A person at a computer desk with coffee on the side by the keyboard typing up a document. The person looks relaxed and is typing while looking at the screen which shows a text editor and the content the person was typing.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>', '[PUTOBJBACK] <coffee_cup>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Task:Receive credit card.
response:
| {
"thoughts": "hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard",
"actions": [
"[WALK] <home_office>",
"[WALK] <envelope>",
"[FIND] <envelope>",
"[GRAB] <envelope>",
"[WALK] <home_office>",
"[WALK] <scissors>",
"[FIND] <scissors>",
"[OPEN] <envelope>",
"[FIND] <creditcard>",
"[GRAB] <creditcard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Write school paper
response:
{
"thoughts": Writing and drafting a paper for class work,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}
|
Task:Pick up cat hair.
response:
| {
"thoughts": "Pick up the large balls of cat hair under the bed and in random places around the room.",
"actions": [
"[FIND] <cat>",
"[TURNTO] <cat>",
"[POINTAT] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[PUSH] <cat>",
"[RUN] <bedroom>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Bring me red cookbook
response:
{
"thoughts": Look at the bookshelf. Find the red cookbook. Bring it to me.,
"actions": ['[WALK] <home_office>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <table>', '[PUTBACK] <novel> <table>']
}
|
Task:Find dictionary.
response:
| {
"thoughts": "Move towards the bookshelf, scan the bookshelf for the dictionary, when the dictionary is found, pick up the dictionary.",
"actions": [
"[WALK] <home_office>",
"[WALK] <bookshelf>",
"[TURNTO] <bookshelf>",
"[LOOKAT] <bookshelf>",
"[TURNTO] <bookshelf>",
"[LOOKAT] <bookshelf>",
"[TURNTO] <bookshelf>",
"[LOOKAT] <bookshelf>",
"[TURNTO] <bookshelf>",
"[LOOKAT] <bookshelf>",
"[TURNTO] <bookshelf>",
"[LOOKAT] <bookshelf>",
"[TURNTO] <bookshelf>",
"[LOOKAT] <bookshelf>",
"[FIND] <novel>",
"[GRAB] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Collect napkin rings
response:
{
"thoughts": Collect all the napkin rings. Place them in the basket.,
"actions": ['[FIND] <basket_for_clothes>', '[TURNTO] <basket_for_clothes>', '[POINTAT] <basket_for_clothes>', '[WASH] <basket_for_clothes>', '[TURNTO] <basket_for_clothes>', '[LOOKAT] <basket_for_clothes>', '[TURNTO] <basket_for_clothes>']
}
|
Task:Change TV channels.
response:
| {
"thoughts": "Take remote. Change to desired channel by you.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TOUCH] <remote_control>",
"[TOUCH] <remote_control>",
"[TOUCH] <remote_control>",
"[FIND] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WATCH] <television>",
"[WATCH] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Draw picture
response:
{
"thoughts": Pick up a pad of paper and a pen. Draw a picture.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <desk>', '[OPEN] <desk>', '[FIND] <check>', '[GRAB] <check>', '[PUTBACK] <check> <desk>', '[FIND] <pencil>', '[GRAB] <pencil>', '[CLOSE] <desk>']
}
|
Task:Dry soap bottles.
response:
| {
"thoughts": "Go to the shower or bath. Locate bottles of soap or shampoo. Pick up each bottle and, using a towel, dry off the bottle. Return each bottle to its original location.",
"actions": [
"[FIND] <towel>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[FIND] <soap>",
"[WIPE] <soap>",
"[GRAB] <soap>",
"[PUTOBJBACK] <soap>",
"[FIND] <shampoo>",
"[GRAB] <shampoo>",
"[WIPE] <shampoo>",
"[PUTOBJBACK] <shampoo>",
"[FIND] <shampoo>",
"[GRAB] <shampoo>",
"[WIPE] <shampoo>",
"[PUTOBJBACK] <shampoo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get glass of water
response:
{
"thoughts": Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <kitchen_cabinet>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>']
}
|
Task:Clean sink.
response:
| {
"thoughts": "Squirt soap into the sink. Get a wet rag. Wipe out the sink. Rinse out the sink and the rag. Hang the rag out to dry.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[WALK] <sink>",
"[POUR] <cleaning_solution> <sink>",
"[PUTOBJBACK] <cleaning_solution>",
"[WIPE] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <sink>",
"[RINSE] <rag>",
"[SWITCHOFF] <faucet>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Hand washing
response:
{
"thoughts": Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}
|
Task:Straighten pictures on wall.
response:
| {
"thoughts": "Move the pictures/paintings until they are straight.",
"actions": [
"[WALK] <home_office>",
"[WALK] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>",
"[TOUCH] <drawing>",
"[PUSH] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>",
"[TOUCH] <drawing>",
"[PUSH] <drawing>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:vacuum carpet
response:
{
"thoughts": I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet.,
"actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}
|
Task:Greet guests.
response:
| {
"thoughts": "When someone knocks I n the door walk through the hallway and greet them.",
"actions": [
"[RUN] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[GREET] <man>",
"[FIND] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Answer emails
response:
{
"thoughts": Open email application. Open new emails. Respond accordingly,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>']
}
|
Task:Watch movie.
response:
| {
"thoughts": "Play the dvd player end watch with my baby",
"actions": [
"[WALK] <bedroom>",
"[WALK] <child>",
"[FIND] <child>",
"[GREET] <child>",
"[WALK] <dresser>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <cd_player>",
"[SWITCHON] <cd_player>",
"[FIND] <bed>",
"[SIT] <bed>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Eat snacks and drink tea
response:
{
"thoughts": Sitting in teak deck chair, eat snacks like guacamole and blue corn chips, and drink a cup of tea.,
"actions": ['[FIND] <chair>', '[TURNTO] <chair>', '[POINTAT] <chair>', '[WASH] <chair>', '[TURNTO] <chair>', '[LOOKAT] <chair>', '[TOUCH] <chair>', '[SIT] <chair>']
}
|
Task:Sent email.
response:
| {
"thoughts": "Walk into home office. Sit down in a chair at a desk. Turn on laptop. Bring up the internet. Go to gmail website. Begin composing an email. Hit the send button.",
"actions": [
"[WALK] <chair>",
"[SIT] <chair>",
"[FIND] <laptop>",
"[SWITCHON] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[FIND] <mail>",
"[GRAB] <mail>",
"[READ] <mail>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[SWITCHOFF] <laptop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get some water
response:
{
"thoughts": I pour water, take a cloth, go to the dining room, clean, take the cloth to the kitchen,
"actions": ['[FIND] <cloth_napkin>', '[GRAB] <cloth_napkin>', '[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[TURNTO] <chair>', '[WIPE] <chair>', '[PUSH] <chair>', '[WALK] <dining_room>', '[DROP] <cloth_napkin>']
}
|
Task:Read.
response:
| {
"thoughts": "We pick out a book from the bookshelf and read it.",
"actions": [
"[WALK] <novel>",
"[WALK] <bookshelf>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <chair>",
"[SIT] <chair>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Get dressed
response:
{
"thoughts": Find dresser, grab pants, grab shirt, put on pants, put on shirt,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']
}
|
Task:Wash hands.
response:
| {
"thoughts": "Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <sink>",
"[TURNTO] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <hands_both>",
"[WASH] <hands_both>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <soap>",
"[RINSE] <hands_both>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <hands_both>",
"[PUTOBJBACK] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Let baby learn how to walk
response:
{
"thoughts": The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.,
"actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>']
}
|
Task:Wash dishes.
response:
| {
"thoughts": "Place all of the dirty dishes in a sink full of clean, soapy water. Wash them. Rinse them in fresh, running water. Place them in the strainer to dry.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[SWITCHOFF] <faucet>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[POUR] <dish_soap> <sink>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <sponge>",
"[GRAB] <sponge>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[SCRUB] <cup>",
"[PUTOBJBACK] <cup>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[SCRUB] <cup>",
"[PUTOBJBACK] <cup>",
"[PUTBACK] <sponge> <sink>",
"[SWITCHON] <faucet>",
"[RINSE] <cup>",
"[GRAB] <cup>",
"[FIND] <dishrack>",
"[PUTBACK] <cup> <dishrack>",
"[RINSE] <cup>",
"[GRAB] <cup>",
"[PUTBACK] <cup> <dishrack>",
"[RINSE] <sponge>",
"[SWITCHOFF] <faucet>",
"[GRAB] <sponge>",
"[PUTOBJBACK] <sponge>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:File expense reports
response:
{
"thoughts": File expense reports on computer,
"actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <folder>', '[GRAB] <folder>', '[CLOSE] <filing_cabinet>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <folder> <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[OPEN] <folder>', '[FIND] <check>', '[GRAB] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[PUTBACK] <check> <desk>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Task:Draft home.
response:
| {
"thoughts": "Using mathematics and CAD software design a home",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[TURNTO] <computer>",
"[POINTAT] <computer>",
"[PUTOBJBACK] <mouse>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Use laptop
response:
{
"thoughts": Sit down on a couch and perform tasks such as navigating the internet on a laptop,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}
|
Task:Admire art.
response:
| {
"thoughts": "Looking at painting, art",
"actions": [
"[WALK] <home_office>",
"[WALK] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Rain welcome
response:
{
"thoughts": The robot would greet me and then hand me a towel. It would make an appropriate quip about the weather while I dried off. It would receive the wet towel when I was done.,
"actions": ['[WALK] <bedroom>', '[WALK] <towel>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <hair>', '[WIPE] <hair>', '[PUTOBJBACK] <towel>']
}
|
Task:Call family member with skype application.
response:
| {
"thoughts": "Sit down on desk chair located in front of computer. Turn on computer. Log in to skype application. Locate individual to call on contacts list. Press the call button with computer mouse.",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[TURNTO] <computer>",
"[POINTAT] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Use computer
response:
{
"thoughts": Pull out a desk chair. Sit down at computer. Use mouse and keyboard to navigate computer device. Use computer.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[FIND] <button>', '[PUSH] <button>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Task:Do taxes.
response:
| {
"thoughts": "Doing taxes",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <check>",
"[GRAB] <check>",
"[READ] <check>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[SWITCHOFF] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Task:Make toast
response:
{
"thoughts": Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <toaster>']
}
|
Task:Write book.
response:
| {
"thoughts": "Writing a book",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[FIND] <electrical_outlet>",
"[PLUGIN] <laptop>",
"[WALK] <love_seat>",
"[SIT] <love_seat>",
"[SWITCHON] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 5