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', 'filing_cabinet', 'tablelamp', 'juice', 'food_salt', 'microwave', 'chair', 'freezer', 'detergent', 'trashcan', 'toothbrush', 'floor', 'ceiling', 'bookshelf', 'toaster', 'shower', 'stereo', 'mousepad', 'clothes_pants', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'food_food', 'check', 'food_donut', 'kitchen_counter', 'cupboard', 'door', 'home_office']  Task:Cook some food  response:  {       thoughts : Go kitchen and make something for eat,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']  }     Scene_Objects:['beer', 'microwave', 'drawing', 'floor', 'purse', 'computer', 'plate', 'balanceball', 'shower', 'stereo', 'dustpan', 'clothes_hat', 'microphone', 'bench', 'basket_for_clothes', 'cup', 'bed', 'check', 'coffe_maker', 'food_onion', 'after_shave', 'cards', 'pencil', 'chessboard', 'maindoor', 'napkin', 'table', 'board_game', 'clothes_shirt', 'coffee']  Task:Set up table  response:

{  Get dishes. Place dishes neatly around table. Get food. Place food on middle of table. }


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', 'toilet', 'chair', 'walllamp', 'knifeblock', 'drawing', 'floor', 'phone', 'keyboard', 'toaster', 'stovefan', 'plate', 'shower', 'tvstand', 'dish_soap', 'couch', 'wall', 'coffe_maker', 'video_game_controller', 'food_onion', 'rag', 'towel_rack', 'mouse', 'kettle', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', '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:['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:

{  Twist the lamp switch until the light goes 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:['sponge', 'fork', 'pot', 'sheets', 'food_salt', 'detergent', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'shampoo', 'desk', 'food_cake', 'mat', 'faucet', 'food_kiwi', 'wall', 'powersocket', 'toy', 'novel', 'food_food', 'curtain', 'dresser', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Going to the sink and scrubbing hands,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>']  }     Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'blow_dryer', 'toothbrush', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'bedroom', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'food_peanut_butter', 'towel', 'wall', 'clothes_gloves', 'food_food', 'toilet_paper', 'tray', 'after_shave', 'dresser', 'cupboard', 'door', 'light']  Task:Look in refrigerator  response:

{  Approach the refrigerator. Use the handle to open the refrigerator door. Look at each shelf of the refrigerator. Look in each refrigerator drawer. Close the refrigerator door. }


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', 'jelly', 'freezer', 'chair', 'blow_dryer', 'bathroom', 'walllamp', 'knife', 'phone', 'keyboard', 'stovefan', 'homework', 'couch', 'food_jam', 'bench', 'oven', 'toy', 'box', 'food_cheese', 'oven_mitts', 'food_rice', 'tray', 'curtain', 'after_shave', 'dresser', 'clothes_dress', 'conditioner', 'hairdryer', 'vase', 'board_game']  Task:Pet cat  response:  {       thoughts : I walk to my living room, find my cat, scrub it using my hand.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']  }     Scene_Objects:['tablelamp', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt']  Task:Switch on lamp  response:

{  Press the button so the light comes 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:['pot', 'food_salt', 'beer', 'chair', 'freezer', 'knifeblock', 'bathroom_counter', 'longboard', 'phone', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'nightstand', 'bench', 'bed', 'photoframe', 'novel', 'television', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'food_steak', 'sink', 'hairdryer', 'vase']  Task:Read book  response:  {       thoughts : Go to the book shelf, get a book, open the book and read the book.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['sheets', 'chair', 'blow_dryer', 'trashcan', 'orchid', 'knifeblock', 'drawing', 'longboard', 'floor', 'ceiling', 'desk', 'cleaning_solution', 'computer', 'window', 'oil', 'clothes_socks', 'couch', 'pillow', 'wall', 'bed', 'newspaper', 'novel', 'toilet_paper', 'food_donut', 'curtain', 'rag', 'doorjamb', 'maindoor', 'napkin', 'bathroom_cabinet']  Task:Dust  response:

{  Gather wood cleaner and cleaning rag. Wipe baseboards and window sills with dry cloth, then spray with cleaner and buff }


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', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'couch', 'candle', 'clothes_hat', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'curtain', 'diary', 'towel_rack', 'mouse', 'dishrack', 'home_office', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['sheets', 'pot', 'food_pizza', 'dry_pasta', 'walllamp', 'trashcan', 'food_carrot', 'dough', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'wall', 'wall_clock', 'oven', 'food_cheese', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher']  Task:Keep an eye on stove as something is cooking  response:

{  Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done }


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', 'cat', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'sink', 'bathroom_cabinet', 'table']  Task:Turn on computer  response:  {       thoughts : Press the power button on the computer to turn it on,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['fork', 'dry_pasta', 'microwave', 'knifeblock', 'knife', 'longboard', 'ceiling', 'purse', 'face', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'towel', 'pillow', 'nightstand', 'powersocket', 'photoframe', 'bed', 'clothes_gloves', 'mouthwash', 'after_shave', 'shoes', 'dishrack', 'dresser', 'hair', 'home_office', 'table', 'dishwasher']  Task:Rain welcome  response:

{  The robot would greet me and then hand me a towel.  It would make an appropriate quip about the weather while I dried off.  It would receive the wet towel when I was done. }


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', 'band-aids', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'television', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'home_office', 'table', 'clothes_shirt']  Task:Relax on sofa  response:  {       thoughts : Sitting down and relaxing on the sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['scissors', 'tea', 'walllamp', 'knife', 'orchid', 'cpuscreen', 'hanger', 'character', 'desk', 'clothes_jacket', 'toaster', 'mat', 'tvstand', 'shower', 'clothes_hat', 'food_orange', 'bowl', 'bench', 'powersocket', 'oven', 'bed', 'light_bulb', 'coffe_maker', 'curtain', 'kitchen_counter', 'comb', 'pajamas', 'controller', 'sink', 'tooth_paste']  Task:Grab things  response:

{  The robot will need some kind of hands or grabbing device to transport objects. }


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', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'rag', 'doorjamb', 'cards', 'dresser', 'sink', 'dishwasher']  Task:Watch  TV  response:  {       thoughts : Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'bathroom', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'character', 'thread', 'piano_bench', 'toaster', 'deck_of_cards', 'homework', 'couch', 'dustpan', 'powersocket', 'newspaper', 'clothes_gloves', 'novel', 'coffe_maker', 'doorjamb', 'chessboard', 'cd', 'napkin', 'home_office', 'instrument_guitar', 'clothes_skirt', 'light']  Task:Close door  response:

{  Push the door shut until it latches. }


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', 'freezer', 'woman', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'man', 'bookshelf', 'keyboard', 'piano_bench', 'stovefan', 'tvstand', 'shower', 'faucet', 'oil', 'dining_room', 'food_kiwi', 'nightstand', 'bench', 'oven', 'powersocket', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light']  Task:Greet guests  response:  {       thoughts : Stand next to the door. When the door opens from the outside, greet the guests.,       actions : ['[RUN] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>']  }     Scene_Objects:['juice', 'measuring_cup', 'toilet', 'nail_polish', 'trashcan', 'dough', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'bookmark', 'ceilinglamp', 'deck_of_cards', 'shoe-shine_kit', 'window', 'couch', 'wall', 'nightstand', 'check', 'mouthwash', 'television', 'hairbrush', 'sink', 'home_office', 'table', 'dishwasher', 'soap', 'teeth']  Task:Do homework  response:

{  Sit on the couch in the Living room and pick u some papers }


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', 'microwave', 'toilet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'television', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'table']  Task:Watch TV  response:  {       thoughts : Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on Television.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['dry_pasta', 'pot', 'walllamp', 'detergent', 'milk', 'hanger', 'phone', 'toaster', 'tvstand', 'balanceball', 'electric_shaver', 'food_noodles', 'garbage_can', 'mousepad', 'clothes_hat', 'pillow', 'broom', 'food_kiwi', 'bench', 'food_vegetable', 'food_cheese', 'food_food', 'ice', 'wine', 'rag', 'shaving_cream', 'dresser', 'cupboard', 'napkin', 'pantry']  Task:Organize pantry  response:

{  Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly. }


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', 'chair', 'orchid', 'bills', 'drawing', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'faucet', 'mousepad', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'keys', 'coffe_maker', 'food_food', 'check', 'water', 'wine', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'board_game']  Task:Drink  response:  {       thoughts : Go to the kitchen and drink some water.,       actions : ['[RUN] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <cup> <sink>', '[FIND] <water>', '[GRAB] <cup>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>', '[PUTBACK] <cup> <sink>']  }     Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'beer', 'chair', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'cleaning_solution', 'bookmark', 'iron', 'mousepad', 'couch', 'dustpan', 'food_jam', 'tape', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'vase', 'colander', 'teeth']  Task:Clean mirror  response:

{  Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean. }


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', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'iron', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'video_game_controller', 'television', 'doorjamb', 'kettle', 'mouse', 'door', 'table']  Task:Browse internet  response:  {       thoughts : Walk to home office. Walk to computer. Switch on Computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'detergent', 'milk', 'drawing', 'orchid', 'cpuscreen', 'longboard', 'floor', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'laptop', 'window', 'mousepad', 'clothes_socks', 'couch', 'wall', 'nightstand', 'powersocket', 'television', 'console', 'mouse', 'pajamas', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Use laptop  response:

{  Sit down on a couch and perform tasks such as navigating the internet on a laptop }


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', 'freezer', 'bathroom', 'detergent', 'food_butter', 'longboard', 'bookshelf', 'stovefan', 'shower', 'pillow', 'towel', 'dining_room', 'nightstand', 'powersocket', 'toy', 'basket_for_clothes', 'newspaper', 'light_bulb', 'photoframe', 'food_food', 'coin', 'doorjamb', 'headset', 'shoes', 'hairbrush', 'cupboard', 'napkin', 'home_office']  Task:Listen to music  response:  {       thoughts : I walk into my room and turn the radio on so that I can listen to music.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knife', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'homework', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'light']  Task:Vacuum  response:

{  Keep my keyboard vacuumed and free of debris. }


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', 'glue', 'microwave', 'bathroom', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'plate', 'laptop', 'deck_of_cards', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'spoon', 'home_office', 'table', 'teeth']  Task:Relax on sofa  response:  {       thoughts : I walk to the sofa, and lie down on the sofa.,       actions : ['[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['glue', 'tablelamp', 'beer', 'mop', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'balanceball', 'electric_shaver', 'mousepad', 'wall', 'nightstand', 'bed', 'doorjamb', 'towel_rack', 'mouse', 'hairdryer', 'maindoor', 'light']  Task:Clean screen  response:

{  Use a soft rag to wipe the screen until there are no marks 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:['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:  {       thoughts : Walk to the living room, turn to the sofa. Sit on the sofa and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'microwave', 'toilet', 'walllamp', 'woman', 'drawing', 'hanger', 'longboard', 'bathroom_counter', 'phone', 'character', 'man', 'food_cake', 'alcohol', 'stovefan', 'window', 'mousepad', 'microphone', 'powersocket', 'cup', 'food_cheese', 'check', 'food_food', 'after_shave', 'controller', 'maindoor', 'food_steak', 'hairdryer', 'bathroom_cabinet', 'dirt']  Task:Greet guests  response:

{  Stand next to the door. When the door opens from the outside, greet the guests. }


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', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'coffee']  Task:Watch TV  response:  {       thoughts : walk to living room ,find television , switch on remote control,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[SWITCHON] <remote_control>']  }     Scene_Objects:['sheets', 'spectacles', 'food_pizza', 'beer', 'ground_coffee', 'bathroom', 'walllamp', 'ceilingfan', 'orchid', 'character', 'desk', 'cleaning_solution', 'bookshelf', 'food_bacon', 'mat', 'mousepad', 'wall', 'pasta', 'oven', 'powersocket', 'novel', 'food_rice', 'wooden_spoon', 'curtain', 'rag', 'console', 'chessboard', 'headset', 'dresser', 'cupboard']  Task:Clean  response:

{  Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean. }


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', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet']  Task:Listen to music  response:  {       thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['mop', 'walllamp', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'bookshelf', 'keyboard', 'mat', 'shower', 'faucet', 'couch', 'pillow', 'dining_room', 'photoframe', 'newspaper', 'novel', 'check', 'toilet_paper', 'coin', 'mirror', 'food_rice', 'rag', 'doorjamb', 'shoes', 'chessboard', 'dresser', 'hair', 'maindoor', 'table', 'clothes_shirt']  Task:Clean mirror  response:

{  Spray glass cleaner on mirror. Wipe with a clean cloth. }


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', 'microwave', 'ceilingfan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'mat', 'oil', 'couch', 'dining_room', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'kettle', 'door', 'napkin', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk to my living room and switch on the television, and lay on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'table_cloth', 'brush', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'napkin', 'light', 'vase']  Task:Wash monitor  response:

{  Clean the grime off of my monitor screen when not in use }


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', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'mouse', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'light', 'table']  Task:Look at painting  response:  {       thoughts : Walk to the painting.  Look up at the painting.  Admire it on the wall.,       actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']  }     Scene_Objects:['microwave', 'detergent', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'bookshelf', 'purse', 'food_cake', 'computer', 'ceilinglamp', 'mat', 'electric_shaver', 'pillow', 'dining_room', 'wall', 'toy', 'cup', 'television', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'cupboard', 'food_steak', 'hairdryer', 'sink', 'bathroom_cabinet', 'dishwasher']  Task:Clean room  response:

{  Pick up his toys, vacuum the garbage off the floor. }


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:['ironing_board', 'sheets', 'tablelamp', 'detergent', 'knifeblock', 'bathroom_counter', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'window', 'couch', 'pillow', 'bowl', 'nightstand', 'food_cheese', 'video_game_controller', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'bag', 'dishwasher', 'board_game', 'clothes_shirt']  Task:Iron shirt  response:  {       thoughts : Set up an ironing board and an iron.  Lay a shirt on board.  Run iron over shirt until it is free of wrinkles.,       actions : ['[WALK] <bedroom>', '[WALK] <ironing_board>', '[FIND] <ironing_board>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <ironing_board>', '[FIND] <iron>', '[GRAB] <iron>', '[PLUGIN] <iron>', '[PLUGOUT] <iron>', '[PUTOBJBACK] <iron>']  }     Scene_Objects:['filing_cabinet', 'blender', 'crayon', 'toilet', 'chair', 'freezer', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'window', 'pillow', 'wall', 'pasta', 'powersocket', 'toy', 'box', 'cup', 'check', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'dresser', 'door', 'light', 'scrabble']  Task:Pick up toys  response:

{  Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes. }


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', 'crayon', 'microwave', 'dog', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'orchid', 'floor', 'desk', 'bookshelf', 'computer', 'piano_bench', 'plate', 'faucet', 'dish_soap', 'food_jam', 'form', 'wall', 'photoframe', 'doorjamb', 'kettle', 'kitchen_counter', 'dishrack', 'cupboard', 'pajamas', 'sink', 'table']  Task:Wash dishes by hand  response:  {       thoughts : Walk to the kitchen and turn to the sink. Put the plate into the sink. Grab and squeeze the dish soap. Scrub the plate then rinse it. Put the plate into the dish rack.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[SQUEEZE] <dish_soap>', '[SCRUB] <plate>', '[RINSE] <plate>', '[GRAB] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>']  }     Scene_Objects:['filing_cabinet', 'chair', 'band-aids', 'freezer', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'envelope', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'towel', 'wall', 'powersocket', 'light_bulb', 'novel', 'curtain', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'board_game']  Task:Read to child  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', 'chair', 'walllamp', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'cupboard', 'controller', 'table']  Task:Browse internet  response:  {       thoughts : I go to my desk. I turn on the computer. I open a web page and look at it.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['bathroom', 'detergent', 'cat', 'knife', 'food_egg', 'character', 'stamp', 'bedroom', 'desk', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'window', 'oil', 'mousepad', 'clothes_hat', 'towel', 'pillow', 'dining_room', 'powersocket', 'coin', 'console', 'towel_rack', 'dishrack', 'cupboard', 'maindoor', 'sink', 'bag']  Task:Keep cats out of room  response:

{  Stand in the doorway and create a loud noise so the cats will stay out. }


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', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer']  Task:Relax on sofa  response:  {       thoughts : walk to living room, walk to sofa, sit in sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['glue', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table']  Task:Clean  mirror  response:

{  GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR }


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', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table']  Task:Work  response:  {       thoughts : I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[PUSH] <mouse>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['sheets', 'tablelamp', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'television', 'ice', 'curtain', 'mouse', 'maindoor', 'table']  Task:Straighten paintings on wall  response:

{  Go up to the painting and tilt it which ever way it is uneven until it looks straight. }


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', 'measuring_cup', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'novel', 'video_game_controller', 'television', 'mouse', 'door', 'napkin']  Task:Study  response:  {       thoughts : Study norwegian,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'cleaning_solution', 'faucet', 'balanceball', 'window', 'clothes_socks', 'food_orange', 'wall', 'powersocket', 'bench', 'cutting_board', 'photoframe', 'novel', 'check', 'rag', 'lighter', 'mouse', 'kitchen_counter', 'hair', 'sink', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'scrabble', 'dirt']  Task:Wash sink  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:['microwave', 'chair', 'walllamp', 'wallshelf', 'ceiling', 'phone', 'keyboard', 'thread', 'piano_bench', 'brush', 'mat', 'ceilinglamp', 'window', 'oil', 'closetdrawer', 'mousepad', 'food_peanut_butter', 'candle', 'nightstand', 'powersocket', 'newspaper', 'novel', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'home_office', 'table', 'instrument_violin']  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:['tablelamp', 'microwave', 'dog', 'blow_dryer', 'trashcan', 'orchid', 'bathroom_counter', 'longboard', 'ceiling', 'character', 'bedroom', 'computer', 'mop_bucket', 'stereo', 'shower', 'window', 'food_peanut_butter', 'food_orange', 'bench', 'oven', 'bed', 'toilet_paper', 'television', 'razor', 'curtain', 'towel_rack', 'cupboard', 'door', 'dishwasher', 'soap']  Task:Put umbrella away  response:

{  Place the umbrella in the umbrella bucket point first. }


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', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee']  Task:Browse internet  response:  {       thoughts : The task is browse and surf on the internet regarding a particular topic,       actions : ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']  }     Scene_Objects:['walllamp', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'pillow', 'dining_room', 'wall', 'bench', 'toy', 'box', 'photoframe', 'clothes_gloves', 'novel', 'video_game_controller', 'cards', 'vacuum_cleaner', 'dresser', 'controller', 'maindoor', 'napkin', 'dishwasher', 'instrument_violin']  Task:Pick up toys  response:

{  Bend down and pick up the toys off of the floor. }


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', 'scissors', 'crayon', 'toilet', 'jelly', 'walllamp', 'nail_polish', 'detergent', 'food_cake', 'alcohol', 'piano_bench', 'toaster', 'food_noodles', 'garbage_can', 'pillow', 'broom', 'oven', 'toy', 'food_vegetable', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'pantry']  Task:Organize pantry  response:  {       thoughts : Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.,       actions : ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'bathroom', 'detergent', 'ceilingfan', 'milk', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_rice', 'mouse', 'pencil', 'pajamas', 'maindoor', 'board_game', 'teeth', 'shoe_rack']  Task:Wipe down baseboards please  response:

{  Use a rag to get all the dust off the baseboards please. }


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', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'button', 'mat', 'shower', 'mousepad', 'oil', 'closetdrawer', 'microphone', 'oven', 'cutting_board', 'check', 'centerpiece', 'diary', 'clothes_dress', 'clothes_scarf', 'napkin', 'tooth_paste']  Task:Pet cat  response:  {       thoughts : Walk into the living room. Walk up to the cat. Pet the cat with your hand.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['tablelamp', 'measuring_cup', 'freezer', 'walllamp', 'bathroom', 'hanger', 'phone', 'desk', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'faucet', 'couch', 'nightstand', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'check', 'television', 'food_onion', 'after_shave', 'curtain', 'shaving_cream', 'mouse', 'maindoor', 'sink', 'bag', 'home_office']  Task:Open front door  response:

{  Walk over to the front door, turn the knob, and open the door. }


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', 'tablelamp', 'tea', 'microwave', 'chair', 'drawing', 'orchid', 'floor', 'computer', 'food_bacon', 'table_cloth', 'stovefan', 'toaster', 'homework', 'mousepad', 'couch', 'powersocket', 'oven', 'bench', 'check', 'oven_mitts', 'coffee_filter', 'curtain', 'rag', 'doorjamb', 'kitchen_counter', 'shoes', 'bathtub', 'dishwasher']  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', 'filing_cabinet', 'ground_coffee', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'shampoo', 'character', 'computer', 'ceilinglamp', 'mat', 'iron', 'plate', 'window', 'couch', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'video_game_controller', 'television', 'centerpiece', 'doorjamb', 'towel_rack', 'door', 'bathroom_cabinet', 'table']  Task:Read book  response:

{  Sit on a couch, grab a book, open it, and scan the pages }


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', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'tea_bag', 'envelope', 'clothes_jacket', 'toaster', 'balanceball', 'faucet', 'iron', 'bed', 'coffe_maker', 'wooden_spoon', 'cards', 'headset', 'dresser', 'napkin', 'spoon', 'vase', 'instrument_violin', 'laser_pointer', 'creditcard']  Task:Receive credit card  response:  {       thoughts : hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard,       actions : ['[WALK] <home_office>', '[WALK] <envelope>', '[FIND] <envelope>', '[GRAB] <envelope>', '[WALK] <home_office>', '[WALK] <scissors>', '[FIND] <scissors>', '[OPEN] <envelope>', '[FIND] <creditcard>', '[GRAB] <creditcard>']  }     Scene_Objects:['filing_cabinet', 'mop', 'chair', 'band-aids', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'laptop', 'toaster', 'foundation', 'pillow', 'wall', 'powersocket', 'bench', 'novel', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light', 'soap', 'instrument_violin']  Task:Turn off light  response:

{  Grasp light switch, flip light 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:['pot', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'brush', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'standingmirror', 'coffe_maker', 'television', 'food_rice', 'wine', 'curtain', 'doorjamb', 'diary', 'pencil', 'door', 'bathroom_cabinet', 'table']  Task:Change TV channel  response:  {       thoughts : walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>']  }     Scene_Objects:['microwave', 'chair', 'detergent', 'trashcan', 'dough', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'thread', 'clothes_jacket', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'brush', 'wall', 'toilet_paper', 'television', 'wooden_spoon', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'cupboard', 'laundry_detergent', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'teeth']  Task:Sweep hallway please  response:

{  Vacuum all the way up and down the hallway.  Get all the dirt and crumbs out of carpet please. }


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', 'food_salt', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:  {       thoughts : I need to complete work on my computer, so I will be pulling out my chair, turning on my computer and begin my task.,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['blender', 'walllamp', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'floor', 'phone', 'bedroom', 'stamp', 'keyboard', 'table_cloth', 'stovefan', 'ceilinglamp', 'window', 'couch', 'towel', 'wall', 'oven', 'bed', 'photoframe', 'clothes_gloves', 'television', 'doorjamb', 'laundry_detergent', 'door', 'maindoor', 'home_office', 'table', 'clothes_shirt']  Task:Read magazine  response:

{  Please sit on the couch and read a magazine }


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', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'newspaper', 'television', 'curtain', 'rag', 'doorjamb', 'mouse', 'door', 'bathtub', 'table']  Task:Use computer  response:  {       thoughts : Browse reddit,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'orchid', 'drawing', 'knifeblock', 'floor', 'folder', 'envelope', 'table_cloth', 'mop_bucket', 'stovefan', 'brush', 'ceilinglamp', 'window', 'foundation', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'newspaper', 'light_bulb', 'food_donut', 'wooden_spoon', 'doorjamb', 'door', 'maindoor', 'napkin', 'light']  Task:Put toys away  response:

{  Pick up all the toys on the floor and put them in their correct storage bin or shelf. }


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', 'spectacles', 'scissors', 'knife', 'hanger', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'keyboard', 'piano_bench', 'stovefan', 'stereo', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'console', 'pencil', 'shoes', 'door', 'bathtub', 'bag', 'instrument_guitar', 'table', 'home_office', 'light', 'board_game']  Task:Listen to music  response:  {       thoughts : I walk into my room and turn the radio on so that I can listen to music.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     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:

{  Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone. }


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', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light']  Task:Drink  response:  {       thoughts : im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>']  }     Scene_Objects:['pot', 'food_bread', 'food_pizza', 'dog', 'freezer', 'bathroom', 'trashcan', 'milk', 'knife', 'orchid', 'floor', 'ceiling', 'bedroom', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'balanceball', 'garbage_can', 'food_dessert', 'wall', 'nightstand', 'oven', 'tape', 'food_cheese', 'food_vegetable', 'novel', 'toothbrush_holder', 'ice', 'colander']  Task:Rotate stock in refrigerator  response:

{  Throw out expired items, put older items in front. }


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', 'freezer', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'shampoo', 'bedroom', 'bookshelf', 'thread', 'mop_bucket', 'tvstand', 'faucet', 'mousepad', 'towel', 'powersocket', 'bed', 'coffe_maker', 'television', 'oven_mitts', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'maindoor', 'home_office', 'bathroom_cabinet', 'table']  Task:Pick up phone  response:  {       thoughts : Enter living room. Walk to telephone. Pick up from hook.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher']  Task:Make coffee  response:

{  Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker. }


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', 'toilet', 'chair', 'walllamp', 'bathroom', 'ground_coffee', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'foundation', 'mousepad', 'wall', 'cup', 'newspaper', 'bed', 'coffe_maker', 'doorjamb', 'dresser', 'conditioner', 'door', 'light', 'dishwasher', 'tooth_paste']  Task:Change TV channel  response:  {       thoughts : take remote control, push  change channel  button,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']  }     Scene_Objects:['pot', 'juice', 'food_ice_cream', 'beer', 'food_oatmeal', 'microwave', 'freezer', 'walllamp', 'ground_coffee', 'milk', 'knifeblock', 'drawing', 'food_egg', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'food_peanut_butter', 'candle', 'pillow', 'bowl', 'wall', 'bench', 'cup', 'newspaper', 'food_food', 'coffe_maker', 'check', 'food_onion', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'table', 'dishwasher', 'laser_pointer']  Task:Cook some food  response:

{  Put oatmeal into a bowl.  Add milk.  Heat in a microwave.  Put pod of coffee into a coffee maker.  Activate.  Pour juice into a glass. }


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:['scissors', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'thread', 'stovefan', 'mat', 'faucet', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'bench', 'nightstand', 'check', 'coffee_filter', 'tray', 'shaving_cream', 'towel_rack', 'pencil', 'mouse', 'sink', 'bathroom_cabinet', 'soap']  Task:Wash hands  response:  {       thoughts : I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[LOOKAT] <sink>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <soap>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>']  }     Scene_Objects:['glue', 'pot', 'tablelamp', 'detergent', 'cat', 'knife', 'drawing', 'hanger', 'bathroom_counter', 'desk', 'food_cake', 'purse', 'envelope', 'piano_bench', 'stovefan', 'toaster', 'stereo', 'balanceball', 'floor_lamp', 'powersocket', 'love_seat', 'newspaper', 'bed', 'photoframe', 'video_game_controller', 'diary', 'maindoor', 'light', 'soap', 'board_game']  Task:Read  response:

{  Sit on an easy chair.  Turn on music.  Take a book and read.  Turn on lamp at night. }


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', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'window', 'mousepad', 'form', 'dining_room', 'wall', 'cutting_board', 'bed', 'clothes_gloves', 'check', 'television', 'oven_mitts', 'curtain', 'mouse', 'hair', 'napkin', 'vase', 'instrument_violin', 'laser_pointer']  Task:Gaze out window  response:  {       thoughts : Look at the yard from the window,       actions : ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']  }     Scene_Objects:['mop', 'bathroom', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'bedroom', 'thread', 'computer', 'brush', 'plate', 'picture', 'window', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'box', 'bed', 'television', 'curtain', 'food_onion', 'kitchen_counter', 'maindoor', 'table', 'light', 'clothes_shirt', 'dirt', 'teeth']  Task:Read book  response:

{  Climb into bed, then read the novel }


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', 'tablelamp', 'microwave', 'freezer', 'trashcan', 'drawing', 'orchid', 'ceiling', 'bedroom', 'mail', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'basket_for_clothes', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'door', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on.,       actions : ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'mousepad', 'couch', 'wall', 'bed', 'food_food', 'tray', 'after_shave', 'rag', 'doorjamb', 'maindoor', 'bathroom_cabinet', 'dishwasher', 'vase']  Task:Put away groceries  response:

{  Place groceries in refrigerator from shopping at the grocery store. }


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', 'fork', 'tablelamp', 'tea', 'band-aids', 'bathroom', 'drawing', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'remote_control', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'wall', 'standingmirror', 'television', 'curtain', 'doorjamb', 'table', 'soap']  Task:Change TV channel  response:  {       thoughts : I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[TOUCH] <remote_control>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'phone', 'desk', 'stamp', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'bench', 'check', 'doorjamb', 'mouse', 'controller', 'maindoor', 'light', 'dishwasher']  Task:Research  response:

{  I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc. }


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:['freezer', 'walllamp', 'bathroom', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'shampoo', 'tvstand', 'faucet', 'stereo', 'clothes_socks', 'couch', 'clothes_pants', 'cutting_board', 'basket_for_clothes', 'photoframe', 'food_food', 'video_game_controller', 'coffe_maker', 'coffee_filter', 'television', 'tray', 'curtain', 'shaving_cream', 'laundry_detergent', 'maindoor', 'spoon', 'home_office', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['measuring_cup', 'microwave', 'toilet', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'phone', 'food_cake', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'stereo', 'electric_shaver', 'homework', 'balanceball', 'picture', 'window', 'dining_room', 'powersocket', 'cup', 'photoframe', 'mirror', 'tray', 'pencil', 'shoes', 'conditioner', 'sink', 'creditcard']  Task:Shave  response:

{  Pick up razor.  Push the button to turn it on.  Move it in a linear motion against the beard growth.  Make sure to get the bottom of your chin, your cheeks, and mustache area. }


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', 'juice', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'picture', 'homework', 'mousepad', 'wall', 'oven', 'toy', 'newspaper', 'check', 'television', 'mouse', 'laundry_detergent', 'conditioner', 'laser_pointer']  Task:Push in desk chair  response:  {       thoughts : Push the desk chair until it is under the desk.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[TOUCH] <chair>', '[PUSH] <chair>']  }     Scene_Objects:['fork', 'pot', 'food_bread', 'scissors', 'microwave', 'freezer', 'milk', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'food_kiwi', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'diary', 'dishrack', 'controller', 'conditioner', 'home_office']  Task:Get glass of milk  response:

{  Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass. }


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', 'tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard']  Task:Turn on light  response:  {       thoughts : I go home and it's dark so I can not see anything,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'walllamp', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'bills', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'fax_machine', 'doorjamb', 'mouse', 'light', 'dishwasher', 'printing_paper']  Task:Print out papers  response:

{  Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print. }


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', '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:  {       thoughts : I go to the the living room, sit down on the sofa, and then I switch on the TV with the TV remote,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['pot', 'tablelamp', 'toilet', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'wall', 'video_game_controller', 'television', 'coin', 'curtain', 'kitchen_counter', 'headset', 'dresser', 'controller', 'table', 'dishwasher', 'soap']  Task:Watch TV  response:

{  I sit down on sofa, get the remote, turn on tv, change channel to show I want to 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:['tablelamp', 'food_salt', 'toilet', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'tvstand', 'foundation', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'food_rice', 'doorjamb', 'shoes', 'dresser', 'door', 'light', 'clothes_skirt']  Task:Turn on light  response:  {       thoughts : I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[LOOKAT] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['ironing_board', 'dry_pasta', 'food_salt', 'toilet', 'freezer', 'band-aids', 'nail_polish', 'detergent', 'food_carrot', 'knifeblock', 'longboard', 'clothes_jacket', 'mat', 'iron', 'mousepad', 'form', 'towel', 'dining_room', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'television', 'ice', 'doorjamb', 'towel_rack', 'home_office', 'light', 'vase', 'clothes_shirt']  Task:Iron shirt  response:

{  Set up an ironing board and an iron.  Lay a shirt on board.  Run iron over shirt until it is free of wrinkles. }


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', 'tablelamp', 'mop', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'stereo', 'window', 'wall', 'bed', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'spoon', 'light', 'dishwasher', 'table', 'coffee']  Task:Make coffee  response:  {       thoughts : Go to the kitchen and make coffee.,       actions : ['[RUN] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[PUTOBJBACK] <coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'detergent', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'wall', 'bench', 'love_seat', 'food_food', 'check', 'television', 'coffe_maker', 'curtain', 'table', 'dishwasher']  Task:Watch TV  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', 'chair', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'orchid', 'drawing', 'bedroom', 'tea_bag', 'bookshelf', 'envelope', 'alcohol', 'computer', 'ceilinglamp', 'mat', 'shower', 'deck_of_cards', 'food_noodles', 'microphone', 'bowl', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'dresser', 'napkin', 'table', 'clothes_shirt']  Task:Pet cat  response:  {       thoughts : First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'food_salt', 'toilet', 'freezer', 'detergent', 'bills', 'orchid', 'hanger', 'ceiling', 'envelope', 'table_cloth', 'brush', 'mat', 'ceilinglamp', 'shower', 'stovefan', 'nightstand', 'powersocket', 'bench', 'photoframe', 'check', 'food_food', 'wooden_spoon', 'sink', 'napkin', 'instrument_guitar', 'table', 'coffee']  Task:Pull up carpet  response:

{  Pry up a corner of your old dirty carpet.  Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt. }


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', 'tablelamp', 'measuring_cup', 'walllamp', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'broom', 'wall', 'newspaper', 'light_bulb', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'cupboard', 'table', 'light']  Task:Change TV channel  response:  {       thoughts : Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']  }     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:

{  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. }


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:['water_glass', 'blender', 'food_salt', 'chair', 'walllamp', 'nail_polish', 'bathroom', 'milk', 'drawing', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'stamp', 'envelope', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'closetdrawer', 'form', 'coffe_maker', 'water', 'mouse', 'dresser', 'hairbrush', 'cupboard', 'table']  Task:Drink  response:  {       thoughts : walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <water>', '[GRAB] <water>', '[WALK] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['food_bread', 'scissors', 'crayon', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'window', 'homework', 'couch', 'wall', 'child', 'bench', 'photoframe', 'newspaper', 'coffe_maker', 'razor', 'television', 'kitchen_counter', 'cupboard', 'table', 'coffee']  Task:Let baby learn how to walk  response:

{  The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe. }


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', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'cupboard', 'bathtub', 'sink', 'table']  Task:Work  response:  {       thoughts : go to home office. turn the computer on. begin working,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['measuring_cup', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'teeth', 'towel', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'television', 'food_donut', 'tray', 'cards', 'towel_rack', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Hand washing  response:

{  Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands. }


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', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'toaster', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'doorjamb', 'pencil', 'dresser', 'door', 'home_office', 'table', 'light']  Task:Change TV channel  response:  {       thoughts : Change the channel on the TV in the living room,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'blow_dryer', 'cat', 'trashcan', 'toothbrush', 'drawing', 'floor', 'character', 'desk', 'wine_glass', 'ceilinglamp', 'plate', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'food_cheese', 'bed', 'food_food', 'check', 'television', 'coffee_filter', 'curtain', 'door', 'spoon', 'table']  Task:Entertain  response:

{  Give guests wine, cheese, crackers and sit and talk }


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', 'food_bread', 'toilet', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'towel', 'wall', 'bench', 'cup', 'photoframe', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'clothes_skirt', 'soap']  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:['sponge', 'pot', 'sheets', 'food_ice_cream', 'food_salt', 'measuring_cup', 'microwave', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'floor', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'plate', 'window', 'floor_lamp', 'mousepad', 'couch', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'television', 'food_rice', 'doorjamb', 'table']  Task:Read book  response:

{  A person brings a book into the living room and sits down in a comfortable chair.  If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read.  The person begins reading the book until they need to stop for some reason. }


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', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'novel', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Browse internet  response:  {       thoughts : I walk to the home office. I sit on the chair. I switch on the computer. I look at my monitor. I open the browsing application by click the application using mouse. I type the book that I need to searching for (using keyboard). I found the book that I need. I read the book. I switch on the printer. I print the information that I get. I read carefully the book information that I got. I switch off the printer. I switch of the computer.,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[SWITCHOFF] <fax_machine>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['fork', 'crayon', 'chair', 'food_butter', 'food_carrot', 'ceilingfan', 'drawing', 'knife', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'thread', 'brush', 'plate', 'wall', 'bench', 'powersocket', 'oven', 'check', 'food_food', 'doorjamb', 'console', 'dresser', 'cupboard', 'door', 'maindoor', 'table', 'light']  Task:Eat  response:

{  I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food }