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', 'detergent', 'dough', 'drawing', 'bills', 'clothes_underwear', 'floor', 'bedroom', 'keyboard', 'piano_bench', 'ceilinglamp', 'balanceball', 'picture', 'window', 'foundation', 'electric_shaver', 'couch', 'dustpan', 'food_kiwi', 'wall', 'keys', 'check', 'television', 'tray', 'rag', 'shoes', 'door', 'table', 'vase', 'coffee']  Task:Relax on sofa  response:  {       thoughts : Relax on the sofa in the living room.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both']  Task:Wash hands  response:

{  I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with 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:['sheets', 'filing_cabinet', 'food_pizza', 'tablelamp', 'blender', 'food_salt', 'blow_dryer', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'purse', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'microphone', 'oven', 'food_food', 'check', 'tray', 'dresser', 'napkin', 'bathroom_cabinet', 'clothes_shirt']  Task:Leave home  response:  {       thoughts : Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.,       actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']  }     Scene_Objects:['toilet', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'dresser', 'door', 'maindoor', 'sink', 'light', 'table', 'soap']  Task:Browse internet  response:

{  go to the office, turn computer on, open an browser or any application to open any website. }


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', 'ceilingfan', 'knifeblock', 'orchid', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'computer', 'couch', 'broom', 'wall', 'coffe_maker', 'video_game_controller', 'wine', 'doorjamb', 'towel_rack', 'cards', 'pencil', 'kitchen_counter', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'board_game']  Task:Turn on light  response:  {       thoughts : Walk over to light switch. Turn on lights.,       actions : ['[WALK] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'button', 'clothes_jacket', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'keys', 'television', 'ice', 'doorjamb', 'mouse', 'pencil', 'headset', 'dresser', 'sink', 'light', 'table']  Task:Write an email  response:

{  Switch on computer, Use keybord and mouse to open e-mail provider, type requested e-mail, click send, close e-mail provider, turn off computer }


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', 'chair', 'ground_coffee', 'wallshelf', 'hanger', 'floor', 'stamp', 'desk', 'bookshelf', 'tea_bag', 'envelope', 'computer', 'mop_bucket', 'mat', 'shower', 'foundation', 'form', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'novel', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'door', 'light']  Task:Read to child  response:  {       thoughts : Read a book out loud to a child,       actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']  }     Scene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'mop', 'bathroom', 'drawing', 'floor', 'phone', 'character', 'desk', 'mail', 'laptop', 'tvstand', 'stereo', 'food_orange', 'dining_room', 'wall', 'oven', 'photoframe', 'television', 'tray', 'towel_rack', 'kettle', 'kitchen_counter', 'dresser', 'sink', 'bathtub', 'table', 'board_game', 'coffee']  Task:Walk through  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:['tablelamp', 'food_salt', 'microwave', 'jelly', 'detergent', 'food_carrot', 'toothbrush', 'needle', 'hanger', 'floor', 'phone', 'shampoo', 'character', 'tvstand', 'iron', 'balanceball', 'stereo', 'mousepad', 'food_jam', 'pillow', 'nightstand', 'toothbrush_holder', 'diary', 'console', 'shaving_cream', 'kitchen_counter', 'sink', 'light', 'dishwasher', 'vase']  Task:Listen to music  response:  {       thoughts : Find the playback device you want to listen to. turn on. press play. enjoyu music.,       actions : ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']  }     Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'bills', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']  Task:Watch  TV  response:

{  Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'floor', 'character', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'coffe_maker', 'kitchen_counter', 'shoes', 'cd', 'hairbrush', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'scrabble', 'hands_both']  Task:Wash hands  response:  {       thoughts : I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['sheets', 'walllamp', 'bathroom', 'trashcan', 'dough', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'faucet', 'window', 'food_noodles', 'mousepad', 'pillow', 'dining_room', 'wall', 'bed', 'food_food', 'razor', 'rag', 'console', 'mouse', 'towel_rack', 'kitchen_counter', 'door', 'sink', 'bathtub', 'bathroom_cabinet']  Task:Clean sink  response:

{  Take a premoistened cleaning wipe and wipe down top of sink and faucet.  Next clean the sink bowl.  Let air dry. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'nail_polish', 'bathroom', 'detergent', 'knife', 'cpuscreen', 'dvd_player', 'bedroom', 'computer', 'table_cloth', 'mop_bucket', 'brush', 'toaster', 'shower', 'window', 'couch', 'dining_room', 'wall', 'pasta', 'cup', 'photoframe', 'after_shave', 'pencil', 'kitchen_counter', 'dresser', 'clothes_dress', 'sink', 'instrument_guitar', 'light', 'creditcard']  Task:Sit  response:  {       thoughts : We sit at the dining room table,       actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']  }     Scene_Objects:['pot', 'tea', 'microwave', 'bathroom', 'trashcan', 'orchid', 'knife', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'envelope', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'food_food', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'table', 'light', 'dishwasher']  Task:Put out flowers  response:

{  Place a flower centrepiece on the entrance hall 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:['walllamp', 'food_carrot', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'window', 'oil', 'couch', 'clothes_pants', 'pillow', 'wall', 'tape', 'cup', 'novel', 'tray', 'curtain', 'mouse', 'chessboard', 'controller', 'table']  Task:Read book  response:  {       thoughts : Sit on a couch, grab a book, open it, and scan the pages,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']  }     Scene_Objects:['food_pizza', 'tablelamp', 'toilet', 'chair', 'detergent', 'trashcan', 'orchid', 'floor', 'ceiling', 'stamp', 'man', 'bookshelf', 'purse', 'toaster', 'mat', 'oil', 'mousepad', 'nightstand', 'cup', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'mouse', 'headset', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']  Task:Answer door  response:

{  Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined. }


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', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'window', 'shower', 'mousepad', 'wall', 'powersocket', 'bench', 'clothes_gloves', 'television', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathtub', 'table']  Task:Work  response:  {       thoughts : I walk into home office. I walk to desk. I sit at chair. I turn on computer.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['sponge', 'pot', 'microwave', 'chair', 'walllamp', 'bathroom', 'knifeblock', 'needle', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'plate', 'faucet', 'dish_soap', 'pillow', 'wall', 'oven', 'box', 'coffe_maker', 'coin', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'home_office', 'table']  Task:Wash dishes  response:

{  Turn water on and run over dishes while scrubbing with a soapy sponge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble']  Task:Wash dishes  response:  {       thoughts : Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[SWITCHON] <faucet>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[GRAB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['spectacles', 'filing_cabinet', 'food_salt', 'mop', 'microwave', 'band-aids', 'freezer', 'walllamp', 'bathroom', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'bookshelf', 'computer', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'tray', 'curtain', 'doorjamb', 'shoes', 'door', 'bathroom_cabinet', 'light', 'shoe_rack']  Task:Turn light off  response:

{  Put the light switch into the down, or off, position. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'juice', 'measuring_cup', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'pencil', 'cupboard', 'door', 'maindoor', 'home_office', 'light', 'dishwasher', 'creditcard']  Task:Work  response:  {       thoughts : turn computer on, open application to work with,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'toilet', 'band-aids', 'knifeblock', 'orchid', 'bedroom', 'keyboard', 'thread', 'clothes_jacket', 'faucet', 'food_noodles', 'food_orange', 'pillow', 'dining_room', 'oven', 'bench', 'powersocket', 'cup', 'newspaper', 'bed', 'check', 'coffe_maker', 'ice', 'tray', 'towel_rack', 'bathtub', 'home_office', 'dishwasher']  Task:Walk through  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', 'mop', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'wall_clock', 'bench', 'television', 'wine', 'curtain', 'coffee_pot', 'door', 'sink', 'spoon', 'table']  Task:Watch TV  response:  {       thoughts : I watch Netflix from about 8:30 to 10:30 every night. I usually watch TV shows.,       actions : ['[WALK] <home_office>', '[WALK] <wall_clock>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['fork', 'pot', 'microwave', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'knife', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'toaster', 'stovefan', 'plate', 'faucet', 'tvstand', 'wall', 'nightstand', 'oven', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'home_office', 'dishwasher']  Task:Unload dishwasher  response:

{  Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher 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:['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:  {       thoughts : Bend down and pick up the toys off of the floor.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']  }     Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'milk', 'knifeblock', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'iron', 'couch', 'wall', 'oven', 'food_food', 'television', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'laser_pointer', 'scrabble']  Task:Cook some food  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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door']  Task:Watch youtube  response:  {       thoughts : Go to youtube.Com watch videos,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste']  Task:Pet dog  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:['tablelamp', 'food_ice_cream', 'freezer', 'cat', 'knifeblock', 'longboard', 'floor', 'ceiling', 'keyboard', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'tvstand', 'electric_shaver', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'cup', 'food_food', 'doorjamb', 'conditioner', 'clothes_scarf', 'home_office', 'table', 'light', 'vase']  Task:Put groceries in Fridge  response:  {       thoughts : I get my groceries and go to the fridge. I open the fridge and put the groceries there.,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['sponge', 'pot', 'bathroom', 'knifeblock', 'bathroom_counter', 'shampoo', 'phone', 'mail', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'window', 'clothes_socks', 'couch', 'clothes_pants', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'mouse', 'shoes', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt']  Task:Get dressed  response:

{  Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes. }


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', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Watch youtube  response:  {       thoughts : Go to youtube.Com watch videos,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['chair', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathtub', 'light', 'table', 'instrument_violin']  Task:Straighten pictures on wall  response:

{  Move the pictures/paintings until they are 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:['sheets', 'spectacles', 'filing_cabinet', 'food_salt', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'character', 'shower', 'stereo', 'microphone', 'wall', 'toy', 'cutting_board', 'cup', 'novel', 'food_food', 'check', 'food_onion', 'coffee_pot', 'console', 'shaving_cream', 'towel_rack', 'shoes', 'cd', 'hairbrush', 'maindoor', 'soap', 'coffee']  Task:Read  response:  {       thoughts : Read a book in the living room,       actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>']  }     Scene_Objects:['pot', 'food_pizza', 'tea', 'toilet', 'walllamp', 'nail_polish', 'cpuscreen', 'floor', 'phone', 'ceiling', 'keyboard', 'toaster', 'mat', 'oil', 'pillow', 'bowl', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'rag', 'doorjamb', 'headset', 'door', 'sink', 'home_office', 'light', 'bathroom_cabinet', 'coffee']  Task:Turn light off  response:

{  Put the light switch into the down, or off, position. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'chair', 'freezer', 'detergent', 'hanger', 'bathroom_counter', 'shampoo', 'ceiling', 'desk', 'bedroom', 'computer', 'stovefan', 'toaster', 'tvstand', 'shower', 'homework', 'closetdrawer', 'bench', 'oven', 'toy', 'cup', 'bed', 'photoframe', 'toilet_paper', 'coffe_maker', 'oven_mitts', 'pencil', 'dresser', 'bag', 'bathroom_cabinet']  Task:Pet cat  response:  {       thoughts : I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['chair', 'trashcan', 'orchid', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'window', 'food_noodles', 'couch', 'pillow', 'wall', 'photoframe', 'toothbrush_holder', 'curtain', 'doorjamb', 'chessboard', 'door', 'bathtub', 'bag', 'home_office', 'light', 'table', 'dishwasher', 'instrument_violin']  Task:Admire art  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'microwave', 'chair', 'cat', 'dough', 'bathroom_counter', 'phone', 'bookshelf', 'ceilinglamp', 'tvstand', 'stereo', 'candle', 'bowl', 'dining_room', 'wall', 'newspaper', 'coffe_maker', 'food_food', 'coffee_filter', 'tray', 'curtain', 'diary', 'towel_rack', 'pencil', 'dresser', 'food_steak', 'sink', 'napkin', 'door', 'dishwasher']  Task:Pick up phone  response:  {       thoughts : I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['microwave', 'walllamp', 'trashcan', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'light', 'table']  Task:Watch TV  response:

{  I sit down on the couch, get the tv remote, click the on button, and change the channel to the 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:['filing_cabinet', 'cd_player', 'blow_dryer', 'bathroom', 'detergent', 'orchid', 'bills', 'bathroom_counter', 'phone', 'bedroom', 'remote_control', 'thread', 'button', 'mat', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'broom', 'wall_clock', 'powersocket', 'bench', 'box', 'coffe_maker', 'razor', 'towel_rack', 'vacuum_cleaner', 'bathtub', 'dishwasher', 'soap']  Task:Listen to music  response:  {       thoughts : I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton,       actions : ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'shoes', 'door', 'table', 'light', 'creditcard']  Task:Watch  TV  response:

{  Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'glue', 'filing_cabinet', 'microwave', 'jelly', 'freezer', 'ceilingfan', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'desk', 'thread', 'mat', 'laptop', 'deck_of_cards', 'faucet', 'foundation', 'pillow', 'nightstand', 'powersocket', 'basket_for_clothes', 'food_food', 'lighter', 'sink', 'home_office', 'vase', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine.,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['tablelamp', 'bathroom', 'trashcan', 'orchid', 'drawing', 'wallshelf', 'floor', 'character', 'bedroom', 'tea_bag', 'keyboard', 'toaster', 'mat', 'stovefan', 'tvstand', 'couch', 'dining_room', 'wall', 'nightstand', 'child', 'bed', 'photoframe', 'novel', 'food_onion', 'after_shave', 'cupboard', 'bathtub', 'napkin', 'bathroom_cabinet', 'board_game']  Task:Story reading time  response:

{  Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures }


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', 'scissors', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'food_kiwi', 'wall', 'oven', 'powersocket', 'cup', 'light_bulb', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'kitchen_counter', 'dresser', 'table', 'light']  Task:Watch TV  response:  {       thoughts : walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>']  }     Scene_Objects:['tablelamp', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'centerpiece', 'shoes', 'door', 'table', 'light']  Task:Watch TV  response:

{  TURN ON TV, SIT ON COUCH ACROSS THE ROOM, USE REMOTE TO LOOK FOR SHOW 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:['measuring_cup', 'chair', 'walllamp', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'envelope', 'computer', 'mat', 'ceilinglamp', 'stereo', 'mousepad', 'wall', 'toothbrush_holder', 'food_rice', 'ice', 'after_shave', 'mouse', 'headset', 'dresser', 'door', 'home_office', 'table', 'board_game']  Task:Work  response:  {       thoughts : Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'dough', 'woman', 'knifeblock', 'bathroom_counter', 'floor', 'character', 'desk', 'tea_bag', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'wall', 'child', 'coffe_maker', 'video_game_controller', 'television', 'towel_rack', 'kettle', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'instrument_violin', 'clothes_shirt']  Task:Greet guests  response:

{  Go to the kitchen, greet your family members }


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', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'bedroom', 'computer', 'alcohol', 'mat', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'bench', 'cutting_board', 'standingmirror', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'chessboard', 'dresser', 'table', 'clothes_skirt']  Task:Watch TV  response:  {       thoughts : Walk into the living room. Sit on the couch. Turn on TV.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['sheets', 'pot', 'mop', 'walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'remote_control', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'box', 'love_seat', 'photoframe', 'television', 'curtain', 'doorjamb', 'dresser', 'clothes_dress', 'bathtub', 'light']  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:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'faucet', 'wall', 'cup', 'photoframe', 'keys', 'ice', 'tray', 'rag', 'towel_rack', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'dishwasher', 'table', 'laser_pointer']  Task:Wipe down sink  response:

{  Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well. }


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:['measuring_cup', 'food_carrot', 'drawing', 'floor', 'thread', 'toaster', 'mat', 'picture', 'oil', 'towel', 'nightstand', 'powersocket', 'toy', 'shelf', 'box', 'cup', 'cutting_board', 'bed', 'photoframe', 'novel', 'toilet_paper', 'check', 'television', 'tray', 'food_onion', 'curtain', 'dresser', 'door', 'hairdryer', 'tooth_paste']  Task:Listen to music  response:  {       thoughts : Find the radio; switch on the radio and listen to music.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'door', 'table', 'light']  Task:Watch TV  response:

{  In the evenings after dinner, we sit on the couch, turn on the television, cue up Netflix and watch our favorite shows. }


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', 'beer', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'mousepad', 'candle', 'wall', 'nightstand', 'newspaper', 'doorjamb', 'mouse', 'light', 'clothes_skirt']  Task:Browse internet  response:  {       thoughts : Turn on computer, pull up browser, browse the internet,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'chair', 'freezer', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'tvstand', 'shoe-shine_kit', 'faucet', 'window', 'mousepad', 'couch', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'towel_rack', 'sink', 'light', 'laser_pointer']  Task:Gaze out window  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', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table']  Task:Pick up toys  response:  {       thoughts : Bend down and pick up the toys off of the floor.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']  }     Scene_Objects:['tea', 'microwave', 'toilet', 'freezer', 'walllamp', 'ground_coffee', 'blow_dryer', 'knifeblock', 'cpuscreen', 'bedroom', 'computer', 'stovefan', 'faucet', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'love_seat', 'newspaper', 'television', 'after_shave', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'conditioner', 'bathtub']  Task:Read  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_ice_cream', 'measuring_cup', 'freezer', 'nail_polish', 'food_carrot', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'plate', 'mat', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'powersocket', 'bench', 'food_vegetable', 'food_food', 'doorjamb', 'mouse', 'door', 'light', 'table', 'scrabble']  Task:Fix snack  response:  {       thoughts : Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'food_cake', 'computer', 'mat', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'bench', 'box', 'check', 'coffee_filter', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'home_office']  Task:Wipe down sink  response:

{  Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tea', 'microwave', 'bathroom', 'trashcan', 'orchid', 'knife', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'envelope', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'food_food', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'table', 'light', 'dishwasher']  Task:Put out flowers  response:  {       thoughts : Place a flower centrepiece on the entrance hall table.,       actions : ['[WALK] <home_office>', '[WALK] <centerpiece>', '[FIND] <centerpiece>', '[GRAB] <centerpiece>', '[WALK] <table>', '[PUTBACK] <centerpiece> <table>']  }     Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'cupboard', 'door', 'light', 'table']  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', 'filing_cabinet', 'crayon', 'microwave', 'walllamp', 'dough', 'knifeblock', 'wallshelf', 'floor', 'phone', 'shampoo', 'desk', 'keyboard', 'bookmark', 'mat', 'shoe-shine_kit', 'floor_lamp', 'mousepad', 'pillow', 'powersocket', 'novel', 'curtain', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'table', 'clothes_skirt', 'colander']  Task:Read book  response:  {       thoughts : Turn a light on and read a book in the bedroom.,       actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['tablelamp', 'bathroom', 'drawing', 'knifeblock', 'floor', 'character', 'keyboard', 'stovefan', 'mat', 'ceilinglamp', 'stereo', 'shower', 'window', 'toaster', 'wall', 'nightstand', 'box', 'food_cheese', 'bed', 'after_shave', 'lighter', 'diary', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'food_steak', 'light', 'dishwasher', 'clothes_shirt']  Task:Listen to music  response:

{  Turn on radio, put on favorite channel, listen to music. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : Sit on an easy chair.  Turn on music.  Take a book and read.  Turn on lamp at night.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <newspaper>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'knifeblock', 'needle', 'wallshelf', 'bathroom_counter', 'phone', 'desk', 'food_cake', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'window', 'shower', 'stereo', 'food_peanut_butter', 'clothes_pants', 'pillow', 'bench', 'newspaper', 'bed', 'coffe_maker', 'television', 'lighter', 'dresser', 'cupboard', 'clothes_dress', 'table']  Task:Get ready for school  response:

{  Take clothes out of dressers and get dressed for school. }


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', 'jelly', 'walllamp', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'envelope', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'wall', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table']  Task:Work  response:  {       thoughts : Go into the office and sit down at the desk in front of the computer. Turn on the computer and look at it while clicking with the mouse and typing with the keyboard.,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'napkin', 'spoon', 'table', 'light']  Task:Watch TV  response:

{  Sit on the couch and use the remote control to change channels }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'pot', 'toilet', 'chair', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'drawing', 'floor', 'mat', 'window', 'couch', 'clothes_hat', 'form', 'pillow', 'bench', 'food_food', 'check', 'coffe_maker', 'toilet_paper', 'ice', 'centerpiece', 'doorjamb', 'cupboard', 'home_office', 'table', 'light', 'bathroom_cabinet', 'scrabble']  Task:Eat dinner  response:  {       thoughts : In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat.,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>']  }     Scene_Objects:['pot', 'food_bread', 'chair', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'character', 'bedroom', 'keyboard', 'food_bacon', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'picture', 'window', 'pillow', 'bench', 'love_seat', 'photoframe', 'novel', 'coin', 'curtain', 'towel_rack', 'mouse', 'pencil', 'sink', 'light', 'table', 'instrument_violin']  Task:Read book  response:

{  Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book 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:['tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'food_bacon', 'mat', 'ceilinglamp', 'shower', 'wall', 'wall_clock', 'cup', 'photoframe', 'bed', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'coffee']  Task:Drink  response:  {       thoughts : Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup,       actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>']  }     Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'window', 'oil', 'couch', 'wall', 'bench', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'after_shave', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'light']  Task:Open bathroom window  response:

{  Make sure bathroom window is unlocked. Lift up bathroom window so it is open. }


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', 'tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'bed', 'coffe_maker', 'television', 'curtain', 'dresser', 'door', 'instrument_guitar', 'table']  Task:Watch TV  response:  {       thoughts : I go to the living room, switch on the tv, take the remote and sit on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'television', 'curtain', 'doorjamb', 'cd', 'pajamas', 'door', 'table', 'light', 'dishwasher']  Task:Watch TV  response:

{  Sitting on the couch watching my favorite television show. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'microwave', 'walllamp', 'milk', 'clothes_underwear', 'character', 'bedroom', 'keyboard', 'clothes_socks', 'candle', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'curtain', 'diary', 'shoes', 'headset', 'laundry_detergent', 'sink', 'home_office', 'table', 'colander', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[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>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['pot', 'tea', 'microwave', 'chair', 'freezer', 'walllamp', 'milk', 'knifeblock', 'knife', 'drawing', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'stovefan', 'toaster', 'faucet', 'food_jam', 'pillow', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'tray', 'kitchen_counter', 'cupboard', 'controller', 'sink']  Task:Get something to drink  response:

{  Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tea', 'chair', 'detergent', 'toothbrush', 'orchid', 'knifeblock', 'cpuscreen', 'kitchen_cabinet', 'floor', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'dish_soap', 'food_jam', 'food_orange', 'pillow', 'wall', 'oven', 'bed', 'novel', 'coffe_maker', 'kitchen_counter', 'dishrack', 'cupboard', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTIN] <dish_soap> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['pot', 'filing_cabinet', 'dog', 'bathroom', 'knife', 'phone', 'character', 'desk', 'clothes_jacket', 'mat', 'ceilinglamp', 'window', 'mousepad', 'pillow', 'dining_room', 'photoframe', 'keys', 'coffe_maker', 'food_food', 'check', 'ice', 'tray', 'towel_rack', 'mouse', 'shoes', 'cupboard', 'bathtub', 'home_office', 'light', 'bathroom_cabinet']  Task:Get ready to leave  response:

{  Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave }


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', 'mop', 'dog', 'jelly', 'drawing', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'computer', 'stovefan', 'faucet', 'oil', 'dining_room', 'wall', 'nightstand', 'oven', 'cutting_board', 'photoframe', 'check', 'tray', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'dirt', 'hands_both']  Task:Wash hands  response:  {       thoughts : go to the bathroom and wash your hands,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[SQUEEZE] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>']  }     Scene_Objects:['sheets', 'toilet', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'newspaper', 'coffee_table', 'novel', 'bed', 'oven_mitts', 'doorjamb', 'pencil', 'chessboard', 'dresser', 'door', 'food_steak', 'table', 'light']  Task:Read magazine  response:

{  Get magazine off coffee table. Sit in arm chair. Open magazine to first page. Read until finished. }


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', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'oven', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'table']  Task:Use computer  response:  {       thoughts : Sit at desk, use the computer mouse,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[TURNTO] <computer>', '[POINTAT] <computer>']  }     Scene_Objects:['tablelamp', 'blender', 'chair', 'bathroom', 'detergent', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'mat', 'tvstand', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'novel', 'check', 'keys', 'tray', 'after_shave', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'tooth_paste']  Task:Read  response:

{  I like to read books in my bedroom. }


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', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office']  Task:Hang up jacket  response:  {       thoughts : I put clothes on hangers and hang them in the closet,       actions : ['[WALK] <bedroom>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[FIND] <hanger>', '[OPEN] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[CLOSE] <dresser>']  }     Scene_Objects:['crayon', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'cat', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'shower', 'window', 'mousepad', 'microphone', 'dining_room', 'wall', 'pasta', 'bench', 'oven', 'newspaper', 'check', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'home_office', 'bathroom_cabinet']  Task:Read newspaper  response:

{  Pull out dining room chair. Sit in dining room chair. Open newspaper to section you'd like to read. Read section. Keep reading all sections you'd like. }


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_ice_cream', 'measuring_cup', 'freezer', 'ceilingfan', 'cpuscreen', 'longboard', 'ceiling', 'character', 'bedroom', 'toaster', 'stereo', 'balanceball', 'oil', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'nightstand', 'photoframe', 'coffe_maker', 'rag', 'doorjamb', 'towel_rack', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'laser_pointer', 'dirt']  Task:Pick up phone  response:  {       thoughts : Go to the living room.  Find the telephone.  Lift up the receiver.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['walllamp', 'knifeblock', 'knife', 'cpuscreen', 'ceiling', 'bookshelf', 'purse', 'face', 'mail', 'mat', 'deck_of_cards', 'tvstand', 'homework', 'pillow', 'dining_room', 'nightstand', 'powersocket', 'box', 'photoframe', 'bed', 'novel', 'check', 'coffe_maker', 'mirror', 'tray', 'hair', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office']  Task:Check appearance in mirror  response:

{  Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_pizza', 'dog', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'shower', 'electric_shaver', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'bed', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room and find the sofa. I sit on the sofa and get comfortable.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['tablelamp', 'chair', 'knifeblock', 'drawing', 'cpuscreen', 'orchid', 'floor', 'phone', 'bedroom', 'keyboard', 'mat', 'tvstand', 'floor_lamp', 'teeth', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'ice', 'tray', 'after_shave', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'light', 'coffee', 'creditcard']  Task:Turn on lights  response:

{  Walk to your lamp, switch it on, and lay on your bed }


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', 'juice', 'freezer', 'blow_dryer', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'bookmark', 'ceilinglamp', 'mat', 'window', 'couch', 'microphone', 'clothes_hat', 'pillow', 'wall', 'bench', 'cup', 'keys', 'television', 'towel_rack', 'cd', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'vase']  Task:Relax on sofa  response:  {       thoughts : Go to the living room and relax on the sofa with a book,       actions : ['[RUN] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[DROP] <bookmark>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'freezer', 'cat', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'stovefan', 'mat', 'tvstand', 'stereo', 'iron', 'food_kiwi', 'powersocket', 'newspaper', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'conditioner', 'bathtub', 'home_office', 'electrical_outlet']  Task:Turn on radio  response:

{  Go to the radio.  Switch on the power button.  Tune the station.  Set the volume.  Listen to the music. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'chair', 'shampoo', 'ceiling', 'folder', 'face', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'oil', 'food_orange', 'dining_room', 'bench', 'box', 'newspaper', 'check', 'video_game_controller', 'mirror', 'curtain', 'towel_rack', 'hair', 'clothes_dress', 'laundry_detergent', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'scrabble']  Task:Check appearance in mirror  response:  {       thoughts : Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed.,       actions : ['[WALK] <bedroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>', '[FIND] <face>', '[TURNTO] <face>', '[LOOKAT] <face>', '[FIND] <hair>', '[TURNTO] <hair>', '[LOOKAT] <hair>', '[FIND] <clothes_dress>', '[TURNTO] <clothes_dress>', '[LOOKAT] <clothes_dress>']  }     Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'toilet', 'band-aids', 'bathroom', 'trashcan', 'wallshelf', 'character', 'computer', 'mat', 'faucet', 'couch', 'dining_room', 'wall', 'newspaper', 'oven_mitts', 'tray', 'curtain', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathroom_cabinet', 'table', 'scrabble']  Task:Shut front door  response:

{  Close the storm door. Lock the storm 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:['tablelamp', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'food_cake', 'mat', 'tvstand', 'shoe-shine_kit', 'homework', 'oil', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'bench', 'oven', 'powersocket', 'toilet_paper', 'kitchen_counter', 'door', 'tooth_paste']  Task:Pick up phone  response:  {       thoughts : walk over and pick up the phone,       actions : ['[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'desk', 'keyboard', 'mat', 'tvstand', 'shower', 'faucet', 'stereo', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'table', 'dishwasher']  Task:Put in chair  response:

{  Take a comfortable chair. Place it in the entrance hall }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouse', 'vacuum_cleaner', 'bathtub', 'sink', 'table']  Task:Pick up phone  response:  {       thoughts : Walk into the living room, walk over to phone, grab the phone, put it to your ear .,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'keys', 'television', 'curtain', 'food_onion', 'doorjamb', 'mouse', 'dresser', 'pajamas', 'sink', 'home_office', 'light', 'instrument_guitar']  Task:Turn off TV  response:

{  Walk over to tv and press power button }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'blender', 'freezer', 'walllamp', 'dough', 'orchid', 'drawing', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'picture', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'dishrack', 'door', 'sink', 'table']  Task:Watch TV  response:  {       thoughts : Turn on the TV, sit on the couch, find a show, and watch it.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['spectacles', 'tablelamp', 'blender', 'microwave', 'chair', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'mail', 'food_bacon', 'mat', 'stereo', 'faucet', 'homework', 'shower', 'dining_room', 'wall', 'oven', 'keys', 'television', 'food_onion', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'laundry_detergent', 'bag', 'spoon', 'table']  Task:Put away keys  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:['tablelamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'mat', 'deck_of_cards', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'bed', 'coffee_filter', 'wine', 'curtain', 'doorjamb', 'kitchen_counter', 'pajamas', 'door', 'food_steak', 'bag', 'light', 'electrical_outlet']  Task:Turn on light  response:  {       thoughts : I walk to the living room. I find the electric outlet. I switch on the light.,       actions : ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['spectacles', 'glue', 'tea', 'chair', 'freezer', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'keyboard', 'bookshelf', 'food_bacon', 'tvstand', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'toilet_paper', 'diary', 'mouse', 'chessboard', 'spoon', 'home_office', 'table', 'light']  Task:Sit in chair  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:['glue', 'tablelamp', 'microwave', 'freezer', 'drawing', 'phone', 'bookshelf', 'toaster', 'stovefan', 'tvstand', 'mousepad', 'couch', 'clothes_hat', 'food_orange', 'wall', 'photoframe', 'clothes_gloves', 'bed', 'check', 'television', 'food_rice', 'tray', 'doorjamb', 'dresser', 'hairdryer', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'door']  Task:Listen to music  response:  {       thoughts : I go to my bedroom, and then I switch on the radio,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['walllamp', 'nail_polish', 'trashcan', 'milk', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'computer', 'faucet', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'check', 'coffe_maker', 'wine', 'after_shave', 'towel_rack', 'comb', 'controller', 'sink', 'bathroom_cabinet', 'light', 'table', 'instrument_violin', 'teeth']  Task:Get toilet paper  response:

{  There are extra toilet papers in the bottom cabinet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table']  Task:Change TV channel  response:  {       thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'tvstand', 'faucet', 'dining_room', 'wall', 'bed', 'novel', 'food_food', 'mouthwash', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap', 'shoe_rack']  Task:Added meat to freezer  response:

{  After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed 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:['jelly', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office']  Task:Turn on light  response:  {       thoughts : I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.,       actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'drawing', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'mat', 'shoe-shine_kit', 'window', 'foundation', 'cup', 'photoframe', 'check', 'coffe_maker', 'centerpiece', 'kitchen_counter', 'shoes', 'bathtub', 'sink', 'bathroom_cabinet', 'light', 'napkin', 'instrument_violin']  Task:Look at mirror  response:

{  I look at my reflection to check my cleanliness. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'mop', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'candle', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'door', 'bathroom_cabinet', 'light']  Task:Relax on sofa  response:  {       thoughts : I go to the living room, switch off the light, sit in the sofa and do nothing.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'walllamp', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'knife', 'bathroom_counter', 'desk', 'keyboard', 'bookshelf', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'mousepad', 'pillow', 'dining_room', 'oven', 'photoframe', 'food_food', 'kitchen_counter', 'dresser', 'sink', 'home_office']  Task:Turn off light  response:

{  Walk to the lamp.  Find the switch.  Click the switch off. }


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', 'microwave', 'chair', 'freezer', 'food_butter', 'drawing', 'food_egg', 'floor', 'ceiling', 'character', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'couch', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'novel', 'ice', 'curtain', 'doorjamb', 'kettle', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'light']  Task:Drink  response:  {       thoughts : Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup,       actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>']  }     Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'photoframe', 'coffe_maker', 'food_rice', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'home_office']  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', 'filing_cabinet', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'floor', 'desk', 'bookshelf', 'plate', 'faucet', 'picture', 'iron', 'window', 'dish_soap', 'food_jam', 'wall', 'nightstand', 'toy', 'cutting_board', 'food_food', 'television', 'curtain', 'pajamas', 'conditioner', 'light', 'dishwasher', 'tooth_paste', 'shoe_rack']  Task:Wash dishes with dishwasher  response:  {       thoughts : Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the soap into the dishwasher.  Close the dishwasher.  Turn on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['tablelamp', 'chair', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste']  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:['walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'keys', 'television', 'curtain', 'food_onion', 'doorjamb', 'mouse', 'dresser', 'pajamas', 'sink', 'home_office', 'light', 'instrument_guitar']  Task:Turn off TV  response:  {       thoughts : Walk over to tv and press power button,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>']  }     Scene_Objects:['fork', 'pot', 'sheets', 'chair', 'freezer', 'walllamp', 'milk', 'knife', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'stovefan', 'window', 'food_jam', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'check', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'table']  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. }