Input: 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:   Scene_Objects:['pot', 'food_bread', 'tablelamp', 'food_salt', 'microwave', 'chair', 'freezer', 'ground_coffee', 'dough', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'mat', 'ceilinglamp', 'stovefan', 'faucet', 'shower', 'oil', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'powersocket', 'food_food', 'coffe_maker', 'television', 'wine', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'food_steak', 'door', 'sink', 'table', 'dishwasher', 'light']  Task:Cook some food  response:  {       thoughts : Walk into kitchen. Open fridge. Take food from fridge. Close fridge. Put food on kitchen counter. Prepare food. Turn on stove. Open kitchen cabinet. Take pot. Close cabinet. Put food in pot. Put pot on stove. Cook food.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <kitchen_counter>', '[PUTBACK] <food_food> <kitchen_counter>', '[CLOSE] <freezer>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <oven>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'food_salt', 'toilet', 'chair', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'food_bacon', 'tvstand', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'food_donut', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'napkin', 'light']  Task:Turn on light  response:

{  I enter the bedroom and find the light. Then I turn it on. }


Input: 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:   Scene_Objects:['food_bread', 'food_pizza', 'tablelamp', 'microwave', 'floor', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'laptop', 'window', 'homework', 'oil', 'closetdrawer', 'couch', 'nightstand', 'wall', 'cup', 'bed', 'food_food', 'mouthwash', 'toothbrush_holder', 'oven_mitts', 'razor', 'food_donut', 'check', 'clothes_scarf', 'bathroom_cabinet']  Task:Go to sleep  response:  {       thoughts : Walk to bedroom. Walk to bed, lie in bed.,       actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[LIE] <bed>']  }     Scene_Objects:['pot', 'scissors', 'tablelamp', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'tvstand', 'mousepad', 'form', 'pillow', 'wall', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'door', 'light']  Task:Pick up phone  response:

{  Enter office. Go to desk. Pick up phone. }


Input: 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:   Scene_Objects:['tablelamp', 'blender', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'shampoo', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'coin', 'doorjamb', 'mouse', 'sink', 'light', 'soap']  Task:Write  school paper  response:  {       thoughts : Writing  and drafting a paper for  class work,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink']  Task:Work  response:


Input: 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:   Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'television', 'curtain', 'doorjamb', 'cd', 'pajamas', 'door', 'table', 'light', 'dishwasher']  Task:Watch TV  response:  {       thoughts : Sitting on the couch watching my favorite television show.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['chair', 'blow_dryer', 'walllamp', 'food_butter', 'dough', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'character', 'tea_bag', 'computer', 'mat', 'tvstand', 'faucet', 'dining_room', 'wall', 'powersocket', 'tape', 'bed', 'towel_rack', 'hairbrush', 'conditioner', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'hands_both']  Task:Wash hands  response:

{  I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water. }


Input: 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:   Scene_Objects:['pot', 'tablelamp', 'walllamp', 'woman', 'drawing', 'phone', 'desk', 'man', 'toaster', 'laptop', 'mat', 'shower', 'electric_shaver', 'oil', 'form', 'pillow', 'dining_room', 'oven', 'shelf', 'bed', 'standingmirror', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'tooth_paste', 'scrabble']  Task:Greet guests  response:  {       thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'floor', 'phone', 'stamp', 'bedroom', 'keyboard', 'table_cloth', 'tvstand', 'closetdrawer', 'food_peanut_butter', 'dustpan', 'clothes_hat', 'bowl', 'nightstand', 'cup', 'food_cheese', 'novel', 'video_game_controller', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'napkin', 'bathroom_cabinet', 'laser_pointer', 'creditcard']  Task:Pet cat  response:

{  Walk to living room. Find the cat. Walk over to the cat. Touch the cat. }


Input: 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:   Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'oil', 'pillow', 'dining_room', 'wall', 'wall_clock', 'bench', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'headset', 'napkin', 'table']  Task:Watch TV  response:  {       thoughts : Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>']  }     Scene_Objects:['tea', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'deck_of_cards', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'video_game_controller', 'television', 'doorjamb', 'lighter', 'dresser', 'bathroom_cabinet', 'soap', 'scrabble']  Task:Watch TV  response:

{  you go into the living room, sit on a chair/sofa, grab remote control, turn on tv, change channels, then watch somethign fun. }


Input: 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:   Scene_Objects:['chair', 'ground_coffee', 'nail_polish', 'orchid', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'food_cake', 'bookshelf', 'mail', 'toaster', 'plate', 'homework', 'pillow', 'dining_room', 'wall', 'bed', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher']  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>']  }     Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'chair', 'jelly', 'walllamp', 'cat', 'orchid', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'dvd_player', 'character', 'food_bacon', 'bookmark', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'oil', 'closetdrawer', 'dustpan', 'towel', 'wall', 'check', 'doorjamb', 'cupboard', 'laundry_detergent', 'soap']  Task:Wash hands  response:

{  I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel. }


Input: 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:   Scene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'faucet', 'picture', 'window', 'dustpan', 'towel', 'wall', 'nightstand', 'photoframe', 'keys', 'toothbrush_holder', 'food_donut', 'mouse', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'vase', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Cleaning hands,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['sponge', 'chair', 'walllamp', 'dough', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'novel', 'television', 'doorjamb', 'diary', 'shoes', 'dresser', 'door', 'clothes_shirt']  Task:Watch TV  response:

{  I walk into the living room. I sit on the couch. I pick up the remote control. I push the power button.  I push the guide button and look for my favorite show \ The Middle.\   I click that channel and enjoy my show. }


Input: 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:   Scene_Objects:['glue', 'dry_pasta', 'crayon', 'band-aids', 'detergent', 'drawing', 'clothes_underwear', 'table_cloth', 'stovefan', 'laptop', 'toaster', 'faucet', 'ceilinglamp', 'closetdrawer', 'wall', 'nightstand', 'oven', 'keys', 'food_food', 'tray', 'coffee_pot', 'pencil', 'headset', 'door', 'hairdryer', 'sink', 'table', 'dishwasher', 'clothes_shirt', 'creditcard']  Task:Pet cat  response:  {       thoughts : You walk to the living room and find the cat. You look at the cat and touch it to pet it.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['crayon', 'chair', 'walllamp', 'cat', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'button', 'alcohol', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'clothes_hat', 'microphone', 'pillow', 'wall', 'photoframe', 'novel', 'coffe_maker', 'television', 'doorjamb', 'coffee_pot', 'dresser']  Task:Watch TV  response:

{  Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television. }


Input: 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:   Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'faucet', 'mousepad', 'wall', 'wall_clock', 'oven', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dishwasher']  Task:Drink  response:  {       thoughts : Walk to kitchen, grab a cup, fill with water and then drink it.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[DRINK] <cup>']  }     Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'tea_bag', 'computer', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'television', 'after_shave', 'doorjamb', 'kettle', 'dresser', 'pajamas']  Task:Watch TV  response:

{  I walk into the living room and sit on the sofa to watch tv }


Input: 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:   Scene_Objects:['juice', 'crayon', 'walllamp', 'trashcan', 'dough', 'floor', 'phone', 'bedroom', 'tea_bag', 'toaster', 'mat', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'pasta', 'oven', 'cutting_board', 'food_cheese', 'newspaper', 'coffe_maker', 'check', 'food_food', 'tray', 'towel_rack', 'pencil', 'dresser', 'conditioner', 'home_office', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'hairbrush', 'door']  Task:Browse internet  response:

{  Turn on computer, pull up browser, browse the internet }


Input: 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:   Scene_Objects:['fork', 'pot', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'mat', 'ceilinglamp', 'shower', 'oil', 'food_peanut_butter', 'food_orange', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'pencil', 'dresser', 'door', 'napkin', 'light', 'shoe_rack']  Task:Put groceries in Fridge  response:  {       thoughts : put away groceries in fridge. open the door, put on shelf, close the door.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['spectacles', 'pot', 'food_pizza', 'chair', 'ground_coffee', 'orchid', 'needle', 'cpuscreen', 'hanger', 'desk', 'food_cake', 'computer', 'closetdrawer', 'clothes_pants', 'dining_room', 'oven', 'powersocket', 'cup', 'photoframe', 'coffe_maker', 'television', 'coin', 'tray', 'after_shave', 'doorjamb', 'diary', 'towel_rack', 'cupboard', 'door', 'bathroom_cabinet']  Task:Turn on light  response:

{  Walk to the living room, walk to the lamp, switch on the lamp. }


Input: 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:   Scene_Objects:['dog', 'freezer', 'bathroom', 'detergent', 'shampoo', 'desk', 'stamp', 'food_bacon', 'brush', 'ceilinglamp', 'oil', 'soap', 'food_orange', 'towel', 'nightstand', 'video_game_controller', 'razor', 'television', 'wine', 'food_onion', 'mouse', 'shoes', 'hair', 'door', 'sink', 'home_office', 'light', 'vase', 'colander', 'teeth']  Task:Open door  response:  {       thoughts : I walk up to the door.  I use my hand to turn the door knob to the left.  I pull the door open with the same hand I used to turn the door knob,       actions : ['[RUN] <home_office>']  }     Scene_Objects:['tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'detergent', 'drawing', 'cpuscreen', 'floor', 'phone', 'character', 'bedroom', 'bookshelf', 'keyboard', 'brush', 'stereo', 'oven', 'cup', 'food_donut', 'curtain', 'kettle', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office', 'dishwasher', 'teeth']  Task:Listen to music  response:

{  walk to living room ,find radio ,switch on radio ,listen to music 4 }


Input: 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:   Scene_Objects:['pot', 'filing_cabinet', 'scissors', 'mop', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'chessboard', 'laundry_detergent', 'door', 'board_game']  Task:Go to toilet  response:  {       thoughts : walk to bathroom , run to toilet,       actions : ['[WALK] <bathroom>', '[RUN] <toilet>']  }     Scene_Objects:['food_pizza', 'food_salt', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'mat', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'toothbrush_holder', 'wine', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'door', 'sink', 'clothes_scarf', 'light']  Task:Turn on light  response:

{  Walk into living room. Find wall. Find light button. Switch on light button. }


Input: 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:   Scene_Objects:['beer', 'measuring_cup', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'keyboard', 'purse', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'novel', 'food_food', 'television', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'dresser', 'hairbrush', 'door', 'napkin', 'home_office', 'board_game']  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>']  }     Scene_Objects:['freezer', 'bathroom', 'food_carrot', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'mat', 'stereo', 'closetdrawer', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'food_kiwi', 'wall', 'food_food', 'television', 'diary', 'mouse', 'pencil', 'kitchen_counter', 'shoes', 'dishrack', 'comb', 'dresser', 'cupboard']  Task:Put groceries in Fridge  response:

{  I pick up groceries. I open fridge. I put groceries in the fridge. }


Input: 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:   Scene_Objects:['spectacles', 'drawing', 'knife', 'orchid', 'hanger', 'floor', 'keyboard', 'purse', 'bookshelf', 'mail', 'toaster', 'ceilinglamp', 'shower', 'balanceball', 'window', 'couch', 'clothes_pants', 'wall', 'oven', 'powersocket', 'television', 'coin', 'diary', 'cd', 'dresser', 'hairbrush', 'hair', 'conditioner', 'table', 'soap']  Task:Relax on sofa  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] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['dry_pasta', 'tablelamp', 'nail_polish', 'cpuscreen', 'hanger', 'ceiling', 'phone', 'bedroom', 'thread', 'mail', 'ceilinglamp', 'foundation', 'food_peanut_butter', 'dustpan', 'dining_room', 'powersocket', 'cup', 'newspaper', 'bed', 'coffe_maker', 'check', 'tray', 'wooden_spoon', 'kitchen_counter', 'bathroom_cabinet', 'table', 'home_office', 'soap', 'washing_machine', 'creditcard']  Task:Wash clothes  response:

{  I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine. }


Input: 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:   Scene_Objects:['tea', 'microwave', 'toilet', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'envelope', 'toaster', 'plate', 'shower', 'stereo', 'dish_soap', 'wall', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'food_food', 'mouthwash', 'check', 'curtain', 'kitchen_counter', 'cupboard', 'pajamas', 'conditioner', 'sink', 'spoon', 'home_office', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['food_bread', 'tablelamp', 'food_ice_cream', 'freezer', 'bathroom', 'orchid', 'bills', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'stereo', 'closetdrawer', 'nightstand', 'oven', 'photoframe', 'clothes_gloves', 'toilet_paper', 'video_game_controller', 'television', 'doorjamb', 'mouse', 'cupboard', 'controller', 'door', 'spoon', 'bathroom_cabinet', 'light', 'dishwasher', 'instrument_violin']  Task:Browse internet  response:

{  The task is browse and surf on the internet regarding a particular topic }


Input: 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:   Scene_Objects:['pot', 'detergent', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'window', 'oil', 'clothes_socks', 'couch', 'food_orange', 'pillow', 'wall', 'novel', 'coffe_maker', 'television', 'food_rice', 'rag', 'doorjamb', 'cupboard', 'door', 'sink', 'napkin', 'table', 'light']  Task:Relax  response:  {       thoughts : Lie down on the couch.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['microwave', 'nail_polish', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'bedroom', 'tea_bag', 'laptop', 'tvstand', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'check', 'television', 'doorjamb', 'towel_rack', 'cards', 'dresser', 'door', 'home_office', 'light']  Task:Turn on light  response:

{  I walk into the dining room and turn on the lights }


Input: 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:   Scene_Objects:['tablelamp', 'chair', 'jelly', 'bathroom', 'knife', 'dvd_player', 'character', 'bedroom', 'thread', 'computer', 'toaster', 'shoe-shine_kit', 'deck_of_cards', 'shower', 'electric_shaver', 'homework', 'food_peanut_butter', 'form', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'novel', 'light_bulb', 'food_food', 'curtain', 'coffee_pot', 'food_steak', 'door', 'light']  Task:Listen to music  response:  {       thoughts : Go to the living room. Find the radio. Turn on the radio.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['tablelamp', 'chair', 'band-aids', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'television', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'door']  Task:Browse internet  response:

{  Go to home office, turn on the computer, open the internet and browse around the internet. }


Input: 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:   Scene_Objects:['sheets', 'water_glass', 'food_salt', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'stovefan', 'mat', 'iron', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'keys', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'tooth_paste']  Task:Drink  response:  {       thoughts : walk to kitchen ,find fridge ,open fridge ,find water  glass , drink from water glass,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['filing_cabinet', 'food_salt', 'chair', 'band-aids', 'bathroom_counter', 'character', 'desk', 'keyboard', 'purse', 'mat', 'tvstand', 'faucet', 'stereo', 'shower', 'oven', 'cup', 'clothes_gloves', 'novel', 'television', 'oven_mitts', 'wooden_spoon', 'curtain', 'pencil', 'kitchen_counter', 'paper_towel', 'coffee', 'cupboard', 'laundry_detergent', 'dishwasher', 'hands_both']  Task:Go to toilet  response:

{  Walking towards Toilet room, And dispose of human waste. Cleaning your hands with tissue paper or water. }


Input: 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:   Scene_Objects:['pot', 'beer', 'mop', 'chair', 'freezer', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'shower', 'window', 'food_orange', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'spoon', 'table', 'light', 'coffee']  Task:Put groceries in Fridge  response:  {       thoughts : I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'headset', 'dresser', 'door', 'sink']  Task:Write an email  response:

{  I go to the home office to find the computer. I turn switch computer on , i open the email. i write the email and  send it. }


Input: 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:   Scene_Objects:['sheets', 'sponge', 'tablelamp', 'mop', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'stamp', 'wine_glass', 'clothes_socks', 'couch', 'pillow', 'wall', 'nightstand', 'food_cheese', 'bed', 'photoframe', 'food_food', 'check', 'doorjamb', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'light']  Task:Entertain  response:  {       thoughts : Give guests wine, cheese, crackers and sit and talk,       actions : ['[WALK] <home_office>', '[WALK] <food_cheese>', '[FIND] <food_cheese>', '[FIND] <food_food>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <wine_glass>', '[GRAB] <wine_glass>', '[DRINK] <wine_glass>']  }     Scene_Objects:['pot', 'tablelamp', 'bathroom', 'food_butter', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mop_bucket', 'toaster', 'shower', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'bed', 'razor', 'television', 'after_shave', 'doorjamb', 'dresser', 'conditioner', 'door', 'light']  Task:Turn on light  response:

{  Walk into the bedroom and walk to the light switch. Flip the switch. }


Input: 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:   Scene_Objects:['food_pizza', 'scissors', 'tea', 'freezer', 'blow_dryer', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'character', 'desk', 'toaster', 'shower', 'picture', 'mousepad', 'candle', 'dining_room', 'bench', 'oven', 'basket_for_clothes', 'bed', 'check', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'sink', 'light', 'tooth_paste', 'laser_pointer']  Task:Turn on light  response:  {       thoughts : I walk into the living room and then I walk to the light switch in there and turn the lights on,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['pot', 'beer', 'microwave', 'toilet', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'ceilinglamp', 'tvstand', 'foundation', 'mousepad', 'oil', 'couch', 'pillow', 'bowl', 'cutting_board', 'photoframe', 'food_donut', 'tray', 'curtain', 'doorjamb', 'mouse', 'headset', 'hairdryer', 'instrument_guitar', 'colander', 'tooth_paste']  Task:Turn on light  response:

{  walk to living room ,find electrical outlet , switch on eletrical outlet }


Input: 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:   Scene_Objects:['food_bread', 'tablelamp', 'microwave', 'chair', 'walllamp', 'floor', 'ceiling', 'character', 'bedroom', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'closetdrawer', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'nightstand', 'cutting_board', 'photoframe', 'television', 'mouse', 'pencil', 'hairbrush', 'pajamas', 'bathroom_cabinet', 'light', 'teeth']  Task:Read book  response:  {       thoughts : Bring book, lie on the sofa, read book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>']  }     Scene_Objects:['tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'computer', 'table_cloth', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'towel', 'wall', 'nightstand', 'oven', 'cup', 'novel', 'television', 'toothbrush_holder', 'mouse', 'pencil', 'door', 'sink', 'soap']  Task:Read book  response:

{  Reading book , Its free time hobby for relaxing }


Input: 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:   Scene_Objects:['pot', 'tea', 'microwave', 'bathroom', 'trashcan', 'orchid', 'knife', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'envelope', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'food_food', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'table', 'light', 'dishwasher']  Task:Put out flowers  response:  {       thoughts : Place a flower centrepiece on the entrance hall table.,       actions : ['[WALK] <home_office>', '[WALK] <centerpiece>', '[FIND] <centerpiece>', '[GRAB] <centerpiece>', '[WALK] <table>', '[PUTBACK] <centerpiece> <table>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'measuring_cup', 'freezer', 'walllamp', 'bathroom', 'knife', 'needle', 'cpuscreen', 'wallshelf', 'orchid', 'ceiling', 'phone', 'character', 'computer', 'bookmark', 'ceilinglamp', 'deck_of_cards', 'picture', 'mousepad', 'closetdrawer', 'couch', 'powersocket', 'oven', 'keys', 'check', 'food_rice', 'dishwasher', 'scrabble']  Task:Pick up phone  response:

{  I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone. }


Input: 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:   Scene_Objects:['spectacles', 'ceilingfan', 'food_carrot', 'toothbrush', 'drawing', 'knife', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'cup', 'photoframe', 'light_bulb', 'coffe_maker', 'television', 'tray', 'curtain', 'pencil', 'maindoor', 'table', 'light', 'coffee']  Task:Watch TV  response:  {       thoughts : Turn TV on to TV channel and sit down on the couch and watch TV.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'walllamp', 'dough', 'drawing', 'needle', 'food_egg', 'wallshelf', 'cpuscreen', 'orchid', 'floor', 'ceiling', 'computer', 'mail', 'mat', 'tvstand', 'shoe-shine_kit', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'coin', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'clothes_dress', 'tooth_paste']  Task:Relax on sofa  response:

{  Walk to the living room, turn to the sofa. Sit on the sofa and relax. }


Input: 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:   Scene_Objects:['microwave', 'toilet', 'chair', 'jelly', 'ground_coffee', 'knifeblock', 'drawing', 'needle', 'food_egg', 'hanger', 'clothes_underwear', 'desk', 'purse', 'alcohol', 'mat', 'stereo', 'faucet', 'food_peanut_butter', 'wall', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'curtain', 'mouse', 'vacuum_cleaner', 'shoes', 'bathroom_cabinet', 'clothes_shirt', 'electrical_outlet']  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>']  }     Scene_Objects:['tablelamp', 'food_salt', 'bathroom', 'detergent', 'drawing', 'hanger', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'piano_bench', 'ceilinglamp', 'closetdrawer', 'candle', 'dustpan', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'bed', 'novel', 'check', 'doorjamb', 'lighter', 'dresser', 'door', 'sink', 'light']  Task:Turn on light  response:

{  Walk to the bedroom and use the button on the wall, next to the door to turn on the lights. }


Input: 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:   Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf']  Task:Watch TV  response:  {       thoughts : Sit and watch the television,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sponge', 'pot', 'food_pizza', 'scissors', 'tablelamp', 'microwave', 'band-aids', 'floor', 'folder', 'food_cake', 'mail', 'computer', 'table_cloth', 'toaster', 'brush', 'plate', 'shower', 'dish_soap', 'wall', 'coffe_maker', 'oven_mitts', 'food_donut', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'home_office', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed. }


Input: 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:   Scene_Objects:['food_ice_cream', 'measuring_cup', 'toilet', 'chair', 'drawing', 'food_egg', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'button', 'shoe-shine_kit', 'shower', 'window', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'standingmirror', 'novel', 'coin', 'doorjamb', 'door', 'light', 'table', 'creditcard']  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>']  }     Scene_Objects:['tablelamp', 'juice', 'freezer', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'computer', 'mop_bucket', 'mat', 'tvstand', 'stereo', 'ceilinglamp', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'keys', 'television', 'ice', 'doorjamb', 'pencil', 'coffee', 'home_office', 'light', 'teeth']  Task:Listen to music  response:

{  sitting down to listen to music on the radio }


Input: 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:   Scene_Objects:['juice', 'microwave', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'milk', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'computer', 'mail', 'mat', 'shower', 'pillow', 'dining_room', 'wall', 'nightstand', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'table', 'tooth_paste']  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>']  }     Scene_Objects:['walllamp', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'plate', 'faucet', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'powersocket', 'box', 'photoframe', 'novel', 'food_food', 'television', 'food_donut', 'curtain', 'doorjamb', 'bathroom_cabinet']  Task:Read book  response:

{  Sit on couch. Grab book. Open book. Read book. }


Input: 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:   Scene_Objects:['band-aids', 'walllamp', 'floor', 'keyboard', 'toaster', 'mat', 'plate', 'tvstand', 'stereo', 'window', 'dish_soap', 'couch', 'food_kiwi', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'wine', 'tray', 'cards', 'dishrack', 'dresser', 'clothes_dress', 'maindoor', 'spoon', 'napkin', 'dishwasher', 'vase', 'colander']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'light_bulb', 'check', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'clothes_dress', 'door', 'table', 'clothes_shirt']  Task:Pick up phone  response:

{  Walk to living room. Go near telephone. take the receiver and then talk to other person on that side. }


Input: 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:   Scene_Objects:['glue', 'filing_cabinet', 'scissors', 'microwave', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'desk', 'bookshelf', 'purse', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'nightstand', 'child', 'cup', 'television', 'curtain', 'centerpiece', 'food_steak', 'hairdryer', 'table', 'vase']  Task:Watch TV  response:  {       thoughts : Turn on tv.  Sit with kids.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['chair', 'walllamp', 'nail_polish', 'drawing', 'orchid', 'wallshelf', 'food_egg', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'laser_pointer']  Task:Watch TV  response:

{  Go to the living room, sit on the couch, find the remote, switch on the TV and watch }


Input: 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:   Scene_Objects:['glue', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'needle', 'floor', 'ceiling', 'phone', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'stereo', 'iron', 'stovefan', 'couch', 'pillow', 'wall', 'television', 'food_rice', 'curtain', 'doorjamb', 'bag', 'bathroom_cabinet', 'table', 'laser_pointer']  Task:Watch TV  response:  {       thoughts : Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['filing_cabinet', 'food_salt', 'crayon', 'jelly', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'dvd_player', 'character', 'keyboard', 'thread', 'food_bacon', 'toaster', 'mat', 'shower', 'closetdrawer', 'pillow', 'dining_room', 'cup', 'newspaper', 'keys', 'mouthwash', 'television', 'colander', 'mouse', 'dishrack', 'sink', 'soap', 'hands_both']  Task:Wash hands  response:


Input: 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:   Scene_Objects:['sheets', 'toilet', 'bathroom', 'bills', 'orchid', 'cpuscreen', 'floor', 'phone', 'character', 'bedroom', 'piano_bench', 'toaster', 'mat', 'ceilinglamp', 'window', 'foundation', 'electric_shaver', 'oil', 'closetdrawer', 'couch', 'broom', 'nightstand', 'wall', 'cup', 'bed', 'check', 'toothbrush_holder', 'sink', 'napkin', 'dishwasher']  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>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'shoe-shine_kit', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'coffe_maker', 'television', 'coin', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light']  Task:Write an email  response:

{  Walk to the home office. Walk to the desk. Sit down in chair. Use mouse to open email program. Type email with keyboard. }


Input: 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:   Scene_Objects:['dry_pasta', 'filing_cabinet', 'jelly', 'drawing', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'faucet', 'clothes_socks', 'couch', 'pillow', 'broom', 'wall', 'wall_clock', 'tape', 'photoframe', 'novel', 'check', 'food_onion', 'doorjamb', 'door', 'bathtub', 'table', 'light']  Task:Relax on sofa  response:  {       thoughts : Go to the living room and relax on the sofa with a book,       actions : ['[RUN] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[DROP] <bookmark>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']  }     Scene_Objects:['pot', 'tablelamp', 'juice', 'microwave', 'chair', 'freezer', 'detergent', 'food_butter', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'table_cloth', 'toaster', 'ceilinglamp', 'stovefan', 'mat', 'faucet', 'shower', 'couch', 'food_orange', 'pillow', 'wall', 'powersocket', 'oven', 'coffe_maker', 'food_food', 'television', 'food_donut', 'tray', 'doorjamb', 'diary', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'food_steak', 'table', 'dishwasher', 'light']  Task:Put groceries in Fridge  response:

{  Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge }


Input: 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:   Scene_Objects:['sponge', 'pot', 'crayon', 'tea', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'faucet', 'picture', 'wall', 'oven', 'food_food', 'check', 'television', 'ice', 'tray', 'rag', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'spoon']  Task:Clean  response:  {       thoughts : Take out a rag. Turn on faucet and get water on the rag. Clean counter off.,       actions : ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <rag> <sink>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[SQUEEZE] <rag>', '[WALK] <kitchen_counter>', '[WIPE] <kitchen_counter>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['spectacles', 'filing_cabinet', 'tea', 'microwave', 'dog', 'freezer', 'walllamp', 'drawing', 'orchid', 'hanger', 'keyboard', 'button', 'ceilinglamp', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'food_cheese', 'keys', 'tray', 'lighter', 'mouse', 'kitchen_counter', 'cd', 'clothes_dress', 'bathroom_cabinet']  Task:Pet cat  response:


Input: 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:   Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'headset', 'cupboard', 'sink', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk to the sofa, and lie down on the sofa.,       actions : ['[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['filing_cabinet', 'food_ice_cream', 'microwave', 'ground_coffee', 'walllamp', 'milk', 'knife', 'needle', 'wallshelf', 'hanger', 'bookshelf', 'clothes_jacket', 'bookmark', 'stovefan', 'mat', 'stereo', 'faucet', 'floor_lamp', 'oil', 'pillow', 'cup', 'curtain', 'after_shave', 'kitchen_counter', 'conditioner', 'sink', 'home_office', 'table', 'dishwasher', 'soap']  Task:Turn on light  response:

{  Walk over to light switch, flip the switch to the on position }


Input: 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:   Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'cat', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'food_bacon', 'stovefan', 'ceilinglamp', 'iron', 'dustpan', 'pillow', 'wall', 'toy', 'box', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cd', 'dresser', 'cupboard', 'light', 'table']  Task:Vacuum  response:  {       thoughts : Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone.,       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>']  }     Scene_Objects:['blender', 'toilet', 'freezer', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'purse', 'computer', 'mat', 'tvstand', 'stereo', 'couch', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'food_food', 'television', 'coffee_filter', 'doorjamb', 'cards', 'pencil', 'table', 'board_game', 'laser_pointer']  Task:Relax on sofa  response:

{  I'm tired and want to relax on the sofa }


Input: 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:   Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'beer', 'crayon', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'iron', 'electric_shaver', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'novel', 'food_food', 'check', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'table']  Task:Read book  response:  {       thoughts : I go to the book case, I select a book, I go back and sit down, then I read.,       actions : ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>']  }     Scene_Objects:['water_glass', 'scissors', 'measuring_cup', 'freezer', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'food_cake', 'mat', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'food_food', 'check', 'television', 'water', 'kitchen_counter', 'cupboard', 'door', 'light', 'clothes_skirt']  Task:Drink  response:

{  go to kitchen, find water glass and grab it, find fridge and open grab water and pour into it, then drink. }


Input: 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:   Scene_Objects:['crayon', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'bathroom_counter', 'ceiling', 'phone', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'faucet', 'shower', 'couch', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'bench', 'bed', 'toothbrush_holder', 'tray', 'curtain', 'dresser', 'clothes_dress', 'sink', 'spoon', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTBACK] <clothes_jacket> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Watch TV  response:

{  Go the living room,  sit in the chair. Take the remote control and switch on the TV. }


Input: 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:   Scene_Objects:['sponge', 'pot', 'toilet', 'detergent', 'orchid', 'longboard', 'floor', 'desk', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'balanceball', 'window', 'bed', 'oven_mitts', 'ice', 'curtain', 'after_shave', 'lighter', 'towel_rack', 'cards', 'controller', 'laundry_detergent', 'maindoor', 'door', 'sink', 'home_office', 'table']  Task:Turn on light  response:  {       thoughts : Twist the lamp switch until the light goes on.,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['dry_pasta', 'pot', 'water_glass', 'tablelamp', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'tea_bag', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'water', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bag', 'table', 'dishwasher', 'light']  Task:Drink  response:

{  Going to the kitchen to get a drink of water. }


Input: 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:   Scene_Objects:['tablelamp', 'mop', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'candle', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'door', 'bathroom_cabinet', 'light']  Task:Relax on sofa  response:  {       thoughts : I go to the living room, switch off the light, sit in the sofa and do nothing.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'photoframe', 'novel', 'television', 'after_shave', 'doorjamb', 'chessboard', 'dresser', 'laundry_detergent', 'instrument_guitar']  Task:Watch TV  response:

{  I go into the living room. I find the remote. I turn on the tv. I sit on the couch and watch tv. }


Input: 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:   Scene_Objects:['ceilingfan', 'toothbrush', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'mop_bucket', 'mat', 'tvstand', 'faucet', 'couch', 'clothes_pants', 'towel', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'wooden_spoon', 'after_shave', 'coffee', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'laser_pointer', 'hands_both', 'shoe_rack']  Task:Wash hands  response:  {       thoughts : Turn faucet clockwise to turn on water.  Place hands under stream of water, pick up soap, rub hands with soap.  Put soap back down.  Rub hands together with soap on them.  Rinse hands under water from faucet.  Turn faucet counterclockwise to turn water off.  Dry hands by rubbing them on a towel.,       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>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['sheets', 'glue', 'pot', 'toilet', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'kettle', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'controller', 'light']  Task:Relax on sofa  response:

{  I get home from work and walk into the living room. I see the couch and go to sit on it. }


Input: 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:   Scene_Objects:['chair', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'stovefan', 'toaster', 'laptop', 'faucet', 'closetdrawer', 'couch', 'bowl', 'dining_room', 'wall', 'oven', 'bench', 'bed', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub']  Task:Cook some food  response:  {       thoughts : I switch on the stove and cook my groceries there.,       actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[SWITCHON] <oven>', '[FIND] <bowl>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <oven>', '[FIND] <food_food>', '[SWITCHOFF] <oven>']  }     Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'chair', 'freezer', 'walllamp', 'blow_dryer', 'nail_polish', 'detergent', 'wallshelf', 'shampoo', 'ceiling', 'remote_control', 'envelope', 'computer', 'food_bacon', 'toaster', 'faucet', 'oil', 'dining_room', 'broom', 'cup', 'food_food', 'tray', 'diary', 'towel_rack', 'kitchen_counter', 'spoon', 'table', 'colander']  Task:Change TV channel  response:

{  I walk to the living room. I find the TV remote. I change the channel. }


Input: 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:   Scene_Objects:['fork', 'tablelamp', 'freezer', 'ceilingfan', 'food_carrot', 'knifeblock', 'clothes_underwear', 'floor', 'ceiling', 'bedroom', 'desk', 'stamp', 'alcohol', 'food_bacon', 'table_cloth', 'ceilinglamp', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'food_food', 'check', 'television', 'towel_rack', 'kettle', 'kitchen_counter', 'dishrack', 'hair', 'dishwasher', 'vase']  Task:Put groceries in Fridge  response:  {       thoughts : walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'food_salt', 'bathroom', 'drawing', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stereo', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'toothbrush_holder', 'wooden_spoon', 'doorjamb', 'shoes', 'dresser', 'door', 'light', 'coffee']  Task:Turn on light  response:


Input: 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:   Scene_Objects:['toilet', 'chair', 'dog', 'walllamp', 'ground_coffee', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'clothes_socks', 'towel', 'wall', 'cutting_board', 'shelf', 'basket_for_clothes', 'coffe_maker', 'food_rice', 'water', 'tray', 'doorjamb', 'food_steak', 'home_office', 'vase', 'soap', 'teeth']  Task:Take shower  response:  {       thoughts : Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[TURNTO] <shower>', '[FIND] <water>', '[RINSE] <water>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <water>', '[FIND] <towel>', '[GRAB] <towel>', '[SCRUB] <towel>']  }     Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'bedroom', 'bookshelf', 'keyboard', 'button', 'table_cloth', 'shoe-shine_kit', 'homework', 'clothes_socks', 'clothes_pants', 'powersocket', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'clothes_dress', 'laundry_detergent', 'clothes_skirt', 'dishwasher', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine }


Input: 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:   Scene_Objects:['tablelamp', 'blender', 'bathroom', 'detergent', 'food_carrot', 'cpuscreen', 'wallshelf', 'phone', 'bedroom', 'desk', 'remote_control', 'envelope', 'computer', 'mail', 'tvstand', 'shower', 'iron', 'mousepad', 'closetdrawer', 'oven', 'powersocket', 'newspaper', 'novel', 'food_food', 'curtain', 'dresser', 'food_steak', 'sink', 'table', 'shoe_rack']  Task:Watch TV  response:  {       thoughts : I walk to the living room and sit on the couch.  I grab the TV remote.  I press the power button on the TV remote and the TV turns on.  I grab the surround sound remote.  I press the power button on the surround sound remote and the system turns on.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'band-aids', 'walllamp', 'food_carrot', 'bills', 'drawing', 'cpuscreen', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'bookshelf', 'mop_bucket', 'stovefan', 'mat', 'shower', 'broom', 'wall', 'cup', 'bed', 'newspaper', 'mouthwash', 'cupboard', 'door', 'sink', 'bathroom_cabinet']  Task:Go to toilet  response:


Input: 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:   Scene_Objects:['pot', 'food_bread', 'juice', 'microwave', 'chair', 'freezer', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'shower', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'newspaper', 'coffe_maker', 'television', 'ice', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'cupboard', 'table', 'dishwasher', 'creditcard']  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>']  }     Scene_Objects:['fork', 'filing_cabinet', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'toaster', 'faucet', 'stereo', 'couch', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'bed', 'photoframe', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'soap', 'hands_both']  Task:Wash hands  response:


Input: 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:   Scene_Objects:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer']  Task:Pet cat  response:  {       thoughts : I walk into the living room and I pet the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'tablelamp', 'food_salt', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'desk', 'alcohol', 'stovefan', 'mat', 'plate', 'shower', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'food_food', 'television', 'tray', 'towel_rack', 'kitchen_counter', 'sauce_pan', 'cupboard', 'spoon', 'napkin', 'light', 'dishwasher']  Task:Cook some food  response:

{  I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate. }


Input: 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:   Scene_Objects:['tablelamp', 'toilet', 'ground_coffee', 'walllamp', 'food_butter', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'thread', 'stovefan', 'toaster', 'tvstand', 'faucet', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'oven_mitts', 'coffee_filter', 'water', 'wine', 'wooden_spoon', 'controller', 'bathroom_cabinet', 'home_office', 'dishwasher']  Task:Make coffee  response:  {       thoughts : Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch 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>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['pot', 'scissors', 'beer', 'microwave', 'bathroom', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'toaster', 'brush', 'plate', 'shower', 'clothes_socks', 'dining_room', 'wall', 'powersocket', 'tape', 'box', 'cup', 'coffe_maker', 'food_food', 'doorjamb', 'centerpiece', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start. }


Input: 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:   Scene_Objects:['crayon', 'cd_player', 'chair', 'toilet', 'walllamp', 'cat', 'hanger', 'floor', 'phone', 'remote_control', 'purse', 'alcohol', 'tvstand', 'iron', 'picture', 'window', 'wall', 'nightstand', 'powersocket', 'bench', 'cutting_board', 'basket_for_clothes', 'after_shave', 'doorjamb', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'door', 'light']  Task:Listen to music  response:  {       thoughts : Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music.,       actions : ['[WALK] <cd_player>', '[SWITCHON] <cd_player>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']  }     Scene_Objects:['pot', 'microwave', 'chair', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'plate', 'shower', 'iron', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'oven', 'basket_for_clothes', 'coffe_maker', 'check', 'tray', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'dishwasher', 'board_game', 'dirt']  Task:Wash dishes with dishwasher  response:

{  I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet.. }


Input: 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:   Scene_Objects:['sponge', 'filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'ground_coffee', 'knifeblock', 'hanger', 'floor', 'ceiling', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'wall', 'cup', 'razor', 'coin', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher']  Task:Drink  response:  {       thoughts : To go kitchen and find a cup. open the faucet and fill water in the cup and drink.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <cup>', '[GRAB] <cup>', '[TURNTO] <faucet>', '[POINTAT] <faucet>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']  }     Scene_Objects:['tablelamp', 'mop', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'candle', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'door', 'bathroom_cabinet', 'light']  Task:Relax on sofa  response:

{  I go to the living room, switch off the light, sit in the sofa and do nothing. }


Input: 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:   Scene_Objects:['tablelamp', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'stamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'dining_room', 'wall', 'toy', 'bed', 'food_food', 'toilet_paper', 'mouthwash', 'doorjamb', 'pencil', 'kitchen_counter', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'home_office', 'bathroom_cabinet', 'dishwasher', 'washing_machine']  Task:Wash clothes  response:  {       thoughts :  I walk to entrance hall   I walk to bedroom   I find basket of clothes   I lift basket of  clothes   I walk to kitchen   I find washing machine   I open washing machine    I put laundry in washing machine   I add laundry detergent     I close washing machine lid   I switch washing machine on ,       actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']  }     Scene_Objects:['glue', 'blender', 'food_salt', 'toilet', 'chair', 'toothbrush', 'drawing', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'alcohol', 'clothes_jacket', 'ceilinglamp', 'foundation', 'pillow', 'bowl', 'dining_room', 'bed', 'curtain', 'lighter', 'doorjamb', 'towel_rack', 'console', 'chessboard', 'cd', 'clothes_scarf', 'instrument_guitar', 'light', 'teeth']  Task:Listen to music  response:

{  I walk to the living room. I find a radio there and switch it on to listen to music. }


Input: 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:   Scene_Objects:['juice', 'freezer', 'ground_coffee', 'detergent', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'faucet', 'shower', 'balanceball', 'food_noodles', 'candle', 'bowl', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'toothbrush_holder', 'rag', 'doorjamb', 'towel_rack', 'conditioner', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer']  Task:Wipe down sink  response:  {       thoughts : Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>', '[CLOSE] <bathroom_cabinet>']  }     Scene_Objects:['chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'floor', 'character', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'coffe_maker', 'kitchen_counter', 'shoes', 'cd', 'hairbrush', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'scrabble', 'hands_both']  Task:Wash hands  response:

{  I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly. }


Input: 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:   Scene_Objects:['toilet', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light']  Task:Go to toilet  response:  {       thoughts : walk to bathroom , run to toilet,       actions : ['[WALK] <bathroom>', '[RUN] <toilet>']  }     Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'dresser', 'sink', 'instrument_violin']  Task:Watch TV  response:

{  I go to the the living room, sit down on the sofa, and then I switch on the TV with the TV remote }