Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'ground_coffee', 'bathroom', 'dough', 'wallshelf', 'phone', 'character', 'keyboard', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'mousepad', 'couch', 'powersocket', 'cutting_board', 'bed', 'food_food', 'food_rice', 'tray', 'wooden_spoon', 'pencil', 'headset', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher']  Task:Pet cat  response:  {       thoughts : find the cat, go near the cat and pet the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light']  Task:Work  response:

{  Walk to over to desk, sit down on chair and face the computer, turn the computer on, use arms to place hands on the keyboard, type work into the computer and use eyes to review. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste']  Task:Hang up car keys  response:  {       thoughts : Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,       actions : ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']  }     Scene_Objects:['filing_cabinet', 'juice', 'walllamp', 'food_carrot', 'knife', 'orchid', 'cpuscreen', 'phone', 'dvd_player', 'desk', 'mop_bucket', 'toaster', 'laptop', 'tvstand', 'closetdrawer', 'food_jam', 'pillow', 'dining_room', 'food_food', 'television', 'oven_mitts', 'water', 'after_shave', 'pencil', 'hairbrush', 'clothes_dress', 'door', 'table', 'dishwasher', 'light']  Task:Drink  response:

{  I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dog', 'freezer', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'computer', 'stovefan', 'tvstand', 'faucet', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'curtain', 'rag', 'doorjamb', 'towel_rack', 'sink', 'bathroom_cabinet', 'table', 'light']  Task:Wipe down sink  response:  {       thoughts : Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>', '[CLOSE] <bathroom_cabinet>']  }     Scene_Objects:['chair', 'bathroom', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'food_bacon', 'button', 'toaster', 'tvstand', 'shower', 'plate', 'food_noodles', 'clothes_socks', 'dustpan', 'pillow', 'nightstand', 'pasta', 'wall_clock', 'bed', 'novel', 'food_donut', 'towel_rack', 'kitchen_counter', 'comb', 'cupboard', 'door', 'table', 'light']  Task:Listen to music  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:['blow_dryer', 'trashcan', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookmark', 'toaster', 'stovefan', 'tvstand', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'coffee_filter', 'tray', 'after_shave', 'curtain', 'cd', 'chessboard', 'cupboard', 'sink', 'dishwasher', 'scrabble', 'coffee']  Task:Make coffee  response:  {       thoughts : Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'electric_shaver', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:

{  Walk to home office. Sit on chair. Switch on computer. type in keyboard. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[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', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'headset', 'dresser', 'door']  Task:Browse internet  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:['dry_pasta', 'toilet', 'chair', 'freezer', 'detergent', 'food_butter', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'remote_control', 'button', 'piano_bench', 'toaster', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'clothes_pants', 'pillow', 'towel', 'wall', 'novel', 'razor', 'diary', 'conditioner', 'table', 'coffee']  Task:Change TV channel  response:  {       thoughts : Take the Tv Remote Control  in the Living Room table And Press the Channel Change Button to change the channel,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[PUTOBJBACK] <remote_control>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'keys', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  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', 'tablelamp', 'microwave', 'detergent', 'knife', 'bills', 'bathroom_counter', 'phone', 'folder', 'bedroom', 'character', 'computer', 'toaster', 'stovefan', 'mat', 'window', 'mousepad', 'pillow', 'oven', 'check', 'coffe_maker', 'razor', 'after_shave', 'mouse', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'sink', 'bag']  Task:Get dressed  response:  {       thoughts : I get dressed in my bedroom in the mornings.,       actions : ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:

{  Find home office. Walk to home office. Find computer. Find chair at desk. Sit in chair. Switch on computer. Work on 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:['pot', 'food_bread', 'juice', 'microwave', 'chair', 'freezer', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'shower', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'newspaper', 'coffe_maker', 'television', 'ice', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'cupboard', 'table', 'dishwasher', 'creditcard']  Task:Grab some juice  response:  {       thoughts : I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>']  }     Scene_Objects:['pot', 'tablelamp', 'crayon', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'mail', 'food_bacon', 'clothes_jacket', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'food_jam', 'nightstand', 'powersocket', 'novel', 'food_food', 'centerpiece', 'diary', 'console', 'cupboard', 'bathroom_cabinet', 'table', 'light']  Task:Pick up phone  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', 'microwave', 'chair', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'purse', 'computer', 'toaster', 'mat', 'tvstand', 'clothes_socks', 'food_peanut_butter', 'microphone', 'food_jam', 'pillow', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'pajamas', 'laundry_detergent', 'door', 'light', 'tooth_paste']  Task:Turn on light  response:  {       thoughts : Coming home turning on lights.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'table_cloth', 'mat', 'tvstand', 'iron', 'wall', 'powersocket', 'oven', 'bed', 'television', 'tray', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'door', 'home_office', 'light', 'dishwasher']  Task:Turn on light  response:

{  Walk to living room.  Find light switch.  Switch on light switch. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'tablelamp', 'chair', 'detergent', 'toothbrush', 'floor', 'ceiling', 'food_cake', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'ceilinglamp', 'dish_soap', 'closetdrawer', 'pillow', 'bowl', 'dining_room', 'wall', 'powersocket', 'cup', 'food_cheese', 'clothes_gloves', 'coffe_maker', 'after_shave', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']  Task:Wash dishes  response:  {       thoughts : Turn water on and run over dishes while scrubbing with a soapy sponge.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['tablelamp', 'microwave', 'chair', 'jelly', 'ground_coffee', 'nail_polish', 'detergent', 'orchid', 'needle', 'drawing', 'hanger', 'character', 'envelope', 'ceilinglamp', 'shower', 'electric_shaver', 'tooth_paste', 'mousepad', 'food_kiwi', 'powersocket', 'oven', 'tape', 'cup', 'photoframe', 'wooden_spoon', 'cards', 'kitchen_counter', 'cd', 'instrument_violin', 'laser_pointer']  Task:Wash dishes with dishwasher  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:['spectacles', 'mop', 'dog', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'mat', 'closetdrawer', 'couch', 'food_jam', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'food_cheese', 'keys', 'food_food', 'video_game_controller', 'television', 'ice', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher']  Task:Put groceries in Fridge  response:  {       thoughts : Walk to kitchen. Open fridge. Put groceries in fridge.,       actions : ['[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Write an email  response:

{  I go to home office, sit in the desk, switch on the computer and write a message }


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', 'microwave', 'band-aids', 'drawing', 'longboard', 'floor', 'ceiling', 'folder', 'computer', 'clothes_jacket', 'alcohol', 'ceilinglamp', 'balanceball', 'window', 'foundation', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'television', 'wine', 'towel_rack', 'pencil', 'shoes', 'dresser', 'cupboard', 'table', 'light', 'dishwasher']  Task:Arrange furniture  response:  {       thoughts : Move furniture where you want it.,       actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[PUSH] <coffee_table>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>']  }     Scene_Objects:['blender', 'chair', 'blow_dryer', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'stamp', 'keyboard', 'computer', 'food_bacon', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'coffe_maker', 'wooden_spoon', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'controller', 'light', 'soap']  Task:Vacuum  response:

{  Plug in vacuum. Walk around with vacuum, covering all of the floor. Unplug vacuum. }


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', 'tablelamp', 'juice', 'microwave', 'toilet', 'walllamp', 'orchid', 'bathroom_counter', 'bookshelf', 'bookmark', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'wall_clock', 'food_food', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'home_office', 'bathroom_cabinet']  Task:Drink  response:  {       thoughts : Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.,       actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'milk', 'floor', 'desk', 'bedroom', 'food_cake', 'stovefan', 'tvstand', 'picture', 'window', 'clothes_socks', 'couch', 'microphone', 'oven', 'bench', 'toy', 'cutting_board', 'photoframe', 'coffe_maker', 'mouthwash', 'tray', 'pencil', 'controller', 'door', 'bathtub', 'home_office', 'light', 'bathroom_cabinet']  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:['microwave', 'freezer', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'alcohol', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'television', 'coffe_maker', 'ice', 'kitchen_counter', 'cupboard', 'hair', 'table', 'scrabble']  Task:Put groceries in Fridge  response:  {       thoughts : I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['sheets', 'juice', 'microwave', 'freezer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'tea_bag', 'keyboard', 'computer', 'button', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'closetdrawer', 'couch', 'wall', 'oven', 'cutting_board', 'toilet_paper', 'television', 'curtain', 'diary', 'pencil', 'shoes', 'dresser', 'table']  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', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'door', 'light', '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:['dry_pasta', 'blender', 'beer', 'mop', 'chair', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'ceiling', 'keyboard', 'alcohol', 'ceilinglamp', 'faucet', 'window', 'powersocket', 'toy', 'food_cheese', 'check', 'tray', 'console', 'mouse', 'pencil', 'kitchen_counter', 'hairbrush', 'hair', 'food_steak', 'bathtub', 'bathroom_cabinet', 'vase']  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:['sponge', 'pot', 'food_bread', 'toilet', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'longboard', 'shampoo', 'desk', 'stamp', 'keyboard', 'toaster', 'mat', 'deck_of_cards', 'faucet', 'foundation', 'mousepad', 'form', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'cupboard', 'door', 'bathroom_cabinet', 'light']  Task:Go to toilet  response:  {       thoughts : Travel through the house and locate the bathroom, and proceed to the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>']  }     Scene_Objects:['filing_cabinet', 'food_bread', 'dog', 'milk', 'floor', 'bedroom', 'computer', 'mail', 'alcohol', 'bookmark', 'mat', 'tvstand', 'window', 'couch', 'dustpan', 'pillow', 'dining_room', 'wall', 'wall_clock', 'coffee_table', 'novel', 'food_food', 'television', 'coin', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'maindoor', 'table']  Task:Read book  response:

{  Sit down in recliner.  Pick up novel off of coffee table.  Open novel to last read page.  Begin reading }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tea', 'chair', 'freezer', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'stovefan', 'mousepad', 'wall', 'keys', 'check', 'oven_mitts', 'doorjamb', 'mouse', 'pencil', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'napkin', 'home_office', 'light']  Task:Turn on light  response:  {       thoughts : turn on the light for room,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[FIND] <chair>', '[SIT] <chair>']  }     Scene_Objects:['drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'mail', 'mat', 'ceilinglamp', 'faucet', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'shelf', 'standingmirror', 'television', 'curtain', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'sink', 'table', 'clothes_shirt']  Task:Watch TV  response:

{  Turn TV on to TV channel and sit down on the couch and watch TV. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'scissors', 'microwave', 'toilet', 'chair', 'walllamp', 'drawing', 'floor', 'ceiling', 'shampoo', 'computer', 'mat', 'food_orange', 'bowl', 'dining_room', 'wall', 'powersocket', 'oven', 'toy', 'shelf', 'cup', 'light_bulb', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'maindoor', 'bathtub', 'light', 'vase']  Task:Turn on light  response:  {       thoughts : I walk into the kitchen, I find the light switch, and then i switch on the lights in the kitchen.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'walllamp', 'nail_polish', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'computer', 'mat', 'couch', 'clothes_pants', 'form', 'wall', 'toy', 'box', 'basket_for_clothes', 'light_bulb', 'novel', 'food_food', 'check', 'television', 'coffee_filter', 'toothbrush_holder', 'tray', 'laundry_detergent', 'clothes_dress', 'table', 'clothes_shirt', 'washing_machine']  Task:Do laundry  response:

{  Collecting laundry from the children's hamper }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'dog', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'food_jam', 'pillow', 'wall', 'nightstand', 'cutting_board', 'novel', 'television', 'toothbrush_holder', 'mouse', 'door', 'dirt']  Task:Read book  response:  {       thoughts : I pick up a book. I sit in a chair. I open the book.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>']  }     Scene_Objects:['food_bread', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'piano_bench', 'shower', 'faucet', 'electric_shaver', 'closetdrawer', 'bowl', 'wall_clock', 'cutting_board', 'toilet_paper', 'check', 'tray', 'towel_rack', 'kettle', 'napkin', 'light', 'soap', 'creditcard']  Task:Greet guests  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', 'beer', 'microwave', 'jelly', 'freezer', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'purse', 'computer', 'iron', 'window', 'mousepad', 'oil', 'wall', 'powersocket', 'bed', 'keys', 'mouthwash', 'wine', 'doorjamb', 'mouse', 'cupboard', 'door', 'sink', 'light']  Task:Turn on light  response:  {       thoughts : walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']  }     Scene_Objects:['jelly', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'shelf', 'standingmirror', 'keys', 'television', 'curtain', 'doorjamb', 'cards', 'napkin', 'home_office', 'table', 'light', 'coffee']  Task:Watch TV  response:

{  We sit all around the television and watch a program. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'scissors', 'blender', 'food_salt', 'crayon', 'chair', 'band-aids', 'ceilingfan', 'needle', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'shower', 'dining_room', 'wall', 'oven', 'powersocket', 'coffe_maker', 'curtain', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'maindoor', 'light']  Task:Dust  response:  {       thoughts : Using soft brush, carefully dust both Indonesian wedding doll statues.,       actions : ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <brush>', '[GRAB] <brush>', '[CLOSE] <dresser>']  }     Scene_Objects:['glue', 'filing_cabinet', 'microwave', 'freezer', 'detergent', 'drawing', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'ceilinglamp', 'iron', 'faucet', 'window', 'homework', 'bowl', 'wall', 'wall_clock', 'bench', 'shelf', 'newspaper', 'mouthwash', 'food_donut', 'doorjamb', 'coffee_pot', 'door', 'sink', 'bathroom_cabinet', 'light', 'board_game']  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:['sheets', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'food_bacon', 'alcohol', 'ceilinglamp', 'pillow', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'kettle', 'mouse', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'creditcard']  Task:Turn on light  response:  {       thoughts : I open the room door and press the light button on,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['sheets', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_socks', 'closetdrawer', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'oven', 'cup', 'newspaper', 'food_food', 'check', 'coffe_maker', 'shaving_cream', 'mouse', 'pencil', 'shoes', 'dresser', 'hair', 'conditioner', 'light', 'clothes_shirt', 'shoe_rack']  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:['sheets', 'fork', 'filing_cabinet', 'toilet', 'detergent', 'food_butter', 'orchid', 'needle', 'bills', 'stereo', 'window', 'dining_room', 'bench', 'oven', 'bed', 'novel', 'check', 'coffee_filter', 'tray', 'wooden_spoon', 'centerpiece', 'headset', 'conditioner', 'food_steak', 'napkin', 'home_office', 'soap', 'scrabble', 'dirt', 'coffee']  Task:File documents  response:  {       thoughts : I file all of my paperwork (including bills, receipts, documents, device instructions, etc.) in my black paperwork case that has many different files in order to organize.  I place each piece of paper in its' corresponding subject (as indicated by printed words on each tab).,       actions : ['[WALK] <home_office>', '[WALK] <bills>', '[FIND] <bills>', '[GRAB] <bills>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTIN] <bills> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>']  }     Scene_Objects:['juice', 'microwave', 'jelly', 'freezer', 'walllamp', 'food_carrot', 'dough', 'orchid', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'mat', 'plate', 'food_jam', 'wall', 'oven', 'bench', 'cutting_board', 'cup', 'food_vegetable', 'food_food', 'coffe_maker', 'ice', 'wine', 'tray', 'kitchen_counter', 'napkin', 'table']  Task:Fix snack  response:

{  Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', '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:['pot', 'food_bread', 'filing_cabinet', 'tablelamp', 'crayon', 'woman', 'wallshelf', 'shampoo', 'floor', 'phone', 'desk', 'man', 'bookshelf', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'child', 'bed', 'photoframe', 'standingmirror', 'toilet_paper', 'oven_mitts', 'towel_rack', 'kitchen_counter', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'vase']  Task:Say goodbye to guests leaving  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'crayon', 'walllamp', 'woman', 'knifeblock', 'hanger', 'ceiling', 'folder', 'character', 'man', 'mop_bucket', 'bookmark', 'shower', 'window', 'electric_shaver', 'pillow', 'dining_room', 'wall_clock', 'cutting_board', 'bed', 'television', 'wine', 'curtain', 'mouse', 'pencil', 'sink', 'home_office', 'light', 'dirt', 'shoe_rack']  Task:Greet people  response:  {       thoughts : Say HI to those that come in.,       actions : ['[WALK] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']  }     Scene_Objects:['sheets', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'stereo', 'mousepad', 'closetdrawer', 'oil', 'clothes_pants', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coin', 'rag', 'kettle', 'mouse', 'chessboard', 'dresser', 'light', 'clothes_shirt']  Task:Get dressed  response:

{  Find dresser, grab pants, grab shirt, put on pants, put on shirt }


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', 'microwave', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'pencil', 'bathtub', 'home_office', 'table']  Task:Browse internet  response:  {       thoughts : For browsing internet walk to home office. Find Computer. Walk to Computer. Find Chair. Sit in a chair and switch on computer. Connect with internet and browse the net.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>']  }     Scene_Objects:['toilet', 'chair', 'food_carrot', 'toothbrush', 'orchid', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'thread', 'stovefan', 'mat', 'toaster', 'shower', 'window', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'rag', 'doorjamb', 'dresser', 'food_steak', 'spoon', 'bathroom_cabinet', 'light', 'table']  Task:Study  response:

{  Do homework or read books while sitting on the chair. }


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', 'microwave', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'keys', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light', 'table']  Task:Relax on sofa  response:  {       thoughts : I want to relax on the sofa to some relaxing music in the living room.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['dry_pasta', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'video_game_console', 'computer', 'button', 'mat', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'cutting_board', 'cup', 'standingmirror', 'video_game_controller', 'television', 'coffee_filter', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table', 'soap', 'dirt']  Task:Play games  response:

{  Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video  game remote controller. }


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', 'walllamp', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'faucet', 'couch', 'dustpan', 'pillow', 'towel', 'wall', 'nightstand', 'oven', 'box', 'bed', 'keys', 'check', 'toilet_paper', 'television', 'kitchen_counter', 'dresser', 'instrument_guitar', 'soap', 'tooth_paste']  Task:Relax on sofa  response:  {       thoughts : Go to living room.  Find sofa.  Sit on sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['food_pizza', 'food_bread', 'microwave', 'freezer', 'walllamp', 'drawing', 'orchid', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'shoe-shine_kit', 'wall', 'bench', 'oven', 'cutting_board', 'food_vegetable', 'food_food', 'coffe_maker', 'coffee_filter', 'wine', 'tray', 'food_onion', 'kitchen_counter', 'controller', 'food_steak', 'table']  Task:Chop vegetables  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', 'filing_cabinet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'longboard', 'floor', 'phone', 'purse', 'computer', 'bookmark', 'brush', 'window', 'wall', 'child', 'powersocket', 'bed', 'novel', 'food_food', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'laundry_detergent', 'door', 'napkin', 'light']  Task:Read book  response:  {       thoughts : Read story to children,       actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']  }     Scene_Objects:['sheets', 'milk', 'knife', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'purse', 'computer', 'mat', 'tvstand', 'foundation', 'window', 'mousepad', 'closetdrawer', 'couch', 'bowl', 'wall', 'powersocket', 'keys', 'coffee_filter', 'mouse', 'dresser', 'home_office', 'light', 'coffee']  Task:Hang keys  response:

{  Remove keys from purse, pocket or hand.  Place in designated area (bowl, or on hook). Leave area }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'button', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'television', 'curtain', 'dresser', 'clothes_dress', 'home_office', 'table']  Task:Change TV channel  response:  {       thoughts : Take TV remote to change TV Channel. Press channel/program +/- button on TV remote.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>']  }     Scene_Objects:['microwave', 'toilet', 'band-aids', 'freezer', 'bathroom', 'dough', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'stovefan', 'mat', 'tvstand', 'faucet', 'towel', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'tray', 'cards', 'console', 'dresser', 'hair', 'sink', 'bathroom_cabinet', 'soap', 'instrument_violin', 'laser_pointer', 'hands_both']  Task:Wash hands  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'oven', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'curtain', 'hairbrush', 'food_steak', 'bag', 'table']  Task:Relax on sofa  response:  {       thoughts : walk to living room, find sofa, sit in sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['food_ice_cream', 'measuring_cup', 'toilet', 'chair', 'drawing', 'food_egg', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'button', 'shoe-shine_kit', 'shower', 'window', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'standingmirror', 'novel', 'coin', 'doorjamb', 'door', 'light', 'table', 'creditcard']  Task:Read  response:

{  We pick out a book from the bookshelf and read it. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'beer', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'character', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'clothes_pants', 'towel', 'bench', 'basket_for_clothes', 'bed', 'coin', 'food_donut', 'curtain', 'towel_rack', 'mouse', 'cd', 'comb', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on.,       actions : ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['microwave', 'bathroom', 'wallshelf', 'character', 'desk', 'mail', 'food_bacon', 'computer', 'mat', 'window', 'oil', 'closetdrawer', 'couch', 'dining_room', 'love_seat', 'cup', 'newspaper', 'standingmirror', 'coffe_maker', 'video_game_controller', 'television', 'centerpiece', 'cards', 'kitchen_counter', 'chessboard', 'maindoor', 'hairdryer', 'bathroom_cabinet', 'table', 'shoe_rack']  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:['pot', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'needle', 'orchid', 'floor', 'stamp', 'keyboard', 'plate', 'faucet', 'shower', 'dish_soap', 'oil', 'wall', 'keys', 'coffe_maker', 'coffee_filter', 'pencil', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'controller', 'pajamas', 'food_steak', 'spoon', 'light', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['dry_pasta', 'microwave', 'bills', 'floor', 'computer', 'toaster', 'stovefan', 'shoe-shine_kit', 'faucet', 'ceilinglamp', 'dustpan', 'microphone', 'food_orange', 'dining_room', 'wall', 'cutting_board', 'toy', 'box', 'coffe_maker', 'food_donut', 'after_shave', 'mouse', 'kitchen_counter', 'shoes', 'hair', 'door', 'sink', 'light', 'soap', 'tooth_paste']  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:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']  Task:Pet cat  response:  {       thoughts : First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['sheets', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap']  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:['dry_pasta', 'tablelamp', 'scissors', 'food_salt', 'toilet', 'chair', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'mail', 'toaster', 'homework', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'coffee_pot', 'mouse', 'home_office', 'table', 'dishwasher', 'vase', 'tooth_paste']  Task:Go to toilet  response:  {       thoughts : Walk to the bathroom. Pull down pants. Use the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[PULL] <clothes_pants>', '[FIND] <toilet>', '[SIT] <toilet>']  }     Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'walllamp', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'stereo', 'shower', 'window', 'mousepad', 'wall', 'nightstand', 'wall_clock', 'toy', 'photoframe', 'coffe_maker', 'curtain', 'lighter', 'towel_rack', 'kitchen_counter', 'controller', 'bathtub', 'bathroom_cabinet', 'table', 'instrument_violin', 'creditcard']  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:['tablelamp', 'food_salt', 'microwave', 'freezer', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'ceiling', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'ceilinglamp', 'faucet', 'picture', 'clothes_socks', 'towel', 'dining_room', 'wall', 'pasta', 'bed', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'light', 'table', 'colander']  Task:Clean screen  response:  {       thoughts : Use a soft rag to wipe the screen until there are no marks on it.,       actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'fork', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'character', 'alcohol', 'faucet', 'mousepad', 'dustpan', 'wall', 'nightstand', 'oven', 'cup', 'photoframe', 'coffe_maker', 'razor', 'after_shave', 'cards', 'dishrack', 'sink', 'spoon', 'bathroom_cabinet', 'clothes_skirt', 'vase', 'clothes_shirt', 'dirt']  Task:Shut off alarm  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', '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:  {       thoughts : Take a premoistened cleaning wipe and wipe down top of sink and faucet.  Next clean the sink bowl.  Let air dry.,       actions : ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[WIPE] <faucet>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['chair', 'walllamp', 'bills', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'television', 'toothbrush_holder', 'wine', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'controller', 'clothes_dress', 'home_office', 'light', 'table']  Task:Turn on computer  response:

{  Press the power button on the computer to turn it on }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer']  Task:Pet cat  response:  {       thoughts : I walk into the living room and I pet the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'jelly', 'chair', 'phone', 'ceiling', 'desk', 'bedroom', 'table_cloth', 'bookmark', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'faucet', 'toaster', 'mousepad', 'powersocket', 'cutting_board', 'shelf', 'food_cheese', 'television', 'wooden_spoon', 'after_shave', 'food_onion', 'doorjamb', 'shoes', 'dishrack', 'vase', '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:['chair', 'walllamp', 'cat', 'food_carrot', 'toothbrush', 'drawing', 'orchid', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'window', 'mousepad', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'photoframe', 'mouthwash', 'tray', 'curtain', 'coffee_pot', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'light', 'tooth_paste']  Task:Relax  response:  {       thoughts : Lie down on the couch.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'knife', 'laptop', 'tvstand', 'faucet', 'shower', 'window', 'mat', 'clothes_socks', 'closetdrawer', 'pillow', 'photoframe', 'standingmirror', 'newspaper', 'toothbrush_holder', 'lighter', 'centerpiece', 'kitchen_counter', 'shoes', 'cd', 'hair', 'conditioner', 'maindoor', 'bathtub', 'sink', 'table', 'vase']  Task:Leave home  response:

{  Put on shoes. Put on coat. Open door and exit through it. Lock door behind you. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'stovefan', 'toaster', 'food_noodles', 'wall', 'oven', 'toy', 'food_vegetable', 'food_food', 'video_game_controller', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'dishwasher', 'scrabble']  Task:Cook some food  response:  {       thoughts : walk to kicthen , find stove , find cooking pot , find vegetables , find water  ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove,       actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[FIND] <pot>', '[FIND] <food_vegetable>', '[FIND] <water>', '[GRAB] <water>', '[WASH] <food_vegetable>', '[POUR] <water> <pot>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <oven>', '[SWITCHON] <oven>']  }     Scene_Objects:['pot', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'bathroom', 'orchid', 'character', 'desk', 'bedroom', 'thread', 'computer', 'brush', 'ceilinglamp', 'faucet', 'stereo', 'closetdrawer', 'dining_room', 'wall', 'pasta', 'toy', 'cup', 'standingmirror', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'clothes_shirt']  Task:Open door  response:

{  Open the door when leaving or coming in. }


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', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'mat', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'check', 'mouthwash', 'food_food', 'food_donut', 'wine', 'curtain', 'doorjamb', 'console', 'dresser', 'door', 'light']  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:['drawing', 'hanger', 'floor', 'ceiling', 'computer', 'brush', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cutting_board', 'shelf', 'toy', 'standingmirror', 'television', 'curtain', 'doorjamb', 'towel_rack', 'controller', 'home_office', 'table', 'soap', 'shoe_rack']  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:['tablelamp', 'toilet', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Browse internet  response:  {       thoughts : I go to the living room, where my computer is. I locate it, switch it on and type desired URL adress in the web browser.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['food_bread', 'microwave', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'alcohol', 'piano_bench', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'oil', 'food_peanut_butter', 'creditcard', 'form', 'wall', 'nightstand', 'oven', 'cutting_board', 'toy', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'dresser', 'sink', 'electrical_outlet']  Task:Toast bread  response:

{  Place two slices of bread in the toaster. Select medium toast on toaster.  Push down button to begin toasting. }


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', 'tablelamp', 'juice', 'scissors', 'beer', 'chair', 'freezer', 'bathroom', 'ceilingfan', 'hanger', 'floor', 'computer', 'food_bacon', 'mat', 'couch', 'creditcard', 'dining_room', 'oven', 'tape', 'bed', 'light_bulb', 'novel', 'food_food', 'mouse', 'cupboard', 'conditioner', 'home_office', 'table', 'scrabble', 'shoe_rack']  Task:Pet dog  response:  {       thoughts : Pet my dog in hall,       actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']  }     Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'mat', 'closetdrawer', 'teeth', 'dining_room', 'wall', 'pasta', 'toy', 'shelf', 'standingmirror', 'novel', 'check', 'television', 'curtain', 'console', 'dresser', 'napkin', 'table', 'light', 'scrabble', 'coffee']  Task:Look at painting  response:

{  Walk to the painting.  Look up at the painting.  Admire it on the wall. }


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', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'photoframe', 'novel', 'television', 'mouse', 'kitchen_counter', 'door', 'sink', 'clothes_skirt', 'clothes_shirt']  Task:Read book  response:  {       thoughts : Go to home office, find the book. Sit in the chair and read the book.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['spectacles', 'measuring_cup', 'blow_dryer', 'ground_coffee', 'bathroom', 'cat', 'phone', 'ceiling', 'character', 'man', 'keyboard', 'computer', 'mat', 'window', 'mousepad', 'clothes_pants', 'powersocket', 'cutting_board', 'cup', 'standingmirror', 'bed', 'coffe_maker', 'television', 'food_rice', 'wine', 'controller', 'sink', 'napkin', 'laser_pointer', 'shoe_rack']  Task:Answer door  response:

{  Walk up to the door.  Open the door and greet whomever is out side }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'filing_cabinet', 'beer', 'chair', 'bills', 'knife', 'hanger', 'bathroom_counter', 'floor', 'computer', 'stovefan', 'mat', 'tvstand', 'window', 'couch', 'pillow', 'towel', 'dining_room', 'food_kiwi', 'wall', 'toy', 'photoframe', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'bag', 'table']  Task:Read book  response:  {       thoughts : Sit on couch. Grab book. Open book. Read book.,       actions : ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['fork', 'beer', 'microwave', 'freezer', 'walllamp', 'dough', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'kitchen_counter', 'maindoor', 'bathtub', 'table']  Task:Drink  response:

{  Get a can of beer, open it, sit on couch, relax }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'orchid', 'hanger', 'phone', 'computer', 'piano_bench', 'nightstand', 'pasta', 'wall_clock', 'powersocket', 'toy', 'food_cheese', 'clothes_gloves', 'check', 'toilet_paper', 'television', 'after_shave', 'doorjamb', 'door', 'hairdryer', 'sink', 'home_office', 'light', 'table', 'clothes_scarf', 'soap']  Task:Read book  response:  {       thoughts : go to bedroom, sit down, pick up book, read,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['sponge', 'scissors', 'tablelamp', 'measuring_cup', 'microwave', 'chair', 'band-aids', 'bathroom', 'milk', 'wallshelf', 'phone', 'character', 'computer', 'mail', 'button', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'standingmirror', 'centerpiece', 'kitchen_counter', 'shoes', 'maindoor', 'sink', 'bathtub', 'bathroom_cabinet', 'table']  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:['chair', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap']  Task:Change TV channels  response:  {       thoughts : Take remote. Change to desired channel by you.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']  }     Scene_Objects:['food_bread', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'mail', 'mat', 'plate', 'faucet', 'stereo', 'couch', 'dustpan', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'cup', 'newspaper', 'standingmirror', 'food_food', 'razor', 'console', 'towel_rack', 'bathtub', 'table']  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', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'toaster', 'plate', 'faucet', 'stereo', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bathtub', 'dishwasher', 'clothes_skirt', 'laser_pointer']  Task:Wash dishes with dishwasher  response:  {       thoughts : Take a dish and put it in the dishwasher to be washed,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['blow_dryer', 'bathroom', 'food_carrot', 'toothbrush', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'mousepad', 'closetdrawer', 'clothes_pants', 'wall', 'powersocket', 'bench', 'cutting_board', 'bed', 'photoframe', 'television', 'food_onion', 'mouse', 'dresser', 'hairbrush', 'controller', 'light', 'clothes_shirt']  Task:Organize closet  response:

{  Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'chair', 'freezer', 'drawing', 'needle', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_food', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kettle', 'dresser', 'light']  Task:Turn on light  response:  {       thoughts : walk into living room, walk to light, turn on light switch.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['tablelamp', 'microwave', 'freezer', 'walllamp', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'mail', 'stovefan', 'laptop', 'window', 'towel', 'dining_room', 'food_kiwi', 'wall', 'oven', 'cutting_board', 'bed', 'coffe_maker', 'food_food', 'check', 'tray', 'kitchen_counter', 'dishrack', 'conditioner', 'food_steak', 'bathtub', 'table', 'vase']  Task:Look in refrigerator  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : Cooking a meal,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <pot> <sink>', '[GRAB] <pot>', '[SWITCHOFF] <faucet>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[CLOSE] <freezer>', '[WALK] <oven>', '[PUTBACK] <food_food> <pot>', '[SWITCHON] <oven>']  }     Scene_Objects:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table']  Task:Switch on lamp  response:

{  Press the button so the light comes on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'filing_cabinet', 'mop', 'microwave', 'dog', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'form', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'centerpiece', 'sink', 'scrabble']  Task:Relax on sofa  response:  {       thoughts : I walk into the living room. I bend down. I sit on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'window', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'cutting_board', 'shelf', 'clothes_gloves', 'food_food', 'coffe_maker', 'wooden_spoon', 'tray', 'kitchen_counter', 'sink', 'bathroom_cabinet']  Task:Keep an eye on stove as something is cooking  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin']  Task:Wash dishes with dishwasher  response:  {       thoughts : I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'blow_dryer', 'walllamp', 'nail_polish', 'bathroom', 'toothbrush', 'drawing', 'hanger', 'floor', 'shampoo', 'character', 'desk', 'bookshelf', 'purse', 'envelope', 'mat', 'ceilinglamp', 'window', 'towel', 'wall', 'powersocket', 'toy', 'cup', 'food_food', 'coffe_maker', 'sink', 'duster']  Task:Dust  response:

{  Apply duster to shelves and clean them until dust is gone }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'microwave', 'trashcan', 'hanger', 'floor', 'bedroom', 'computer', 'button', 'brush', 'mat', 'shower', 'faucet', 'window', 'clothes_hat', 'wall', 'child', 'oven', 'bed', 'newspaper', 'novel', 'curtain', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'hairdryer', 'clothes_scarf', 'vase', 'board_game']  Task:Story reading time  response:  {       thoughts : Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures,       actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>']  }     Scene_Objects:['dry_pasta', 'glue', 'blender', 'food_salt', 'character', 'bedroom', 'mat', 'tvstand', 'food_noodles', 'garbage_can', 'couch', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'toy', 'cutting_board', 'tape', 'food_vegetable', 'food_food', 'food_donut', 'tray', 'mouse', 'pencil', 'door', 'bathtub', 'home_office', 'table', 'colander', 'pantry']  Task:Organize pantry  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_ice_cream', 'freezer', 'walllamp', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'oven', 'powersocket', 'cup', 'ice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']  Task:Get something to drink  response:  {       thoughts : Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[CLOSE] <freezer>', '[POUR] <milk> <cup>', '[DRINK] <cup>']  }     Scene_Objects:['measuring_cup', 'dog', 'chair', 'dough', 'wallshelf', 'hanger', 'cleaning_solution', 'keyboard', 'computer', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'homework', 'clothes_hat', 'nightstand', 'wall_clock', 'cup', 'photoframe', 'novel', 'check', 'oven_mitts', 'curtain', 'rag', 'towel_rack', 'shoes', 'hairbrush', 'maindoor', 'spoon']  Task:Clean mirror  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'milk', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'photoframe', 'check', 'mouthwash', 'razor', 'television', 'coin', 'coffe_maker', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk into the living room and I lie down on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']  }     Scene_Objects:['microwave', 'chair', 'jelly', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'laptop', 'stovefan', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'table']  Task:Use laptop  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'toilet', 'bathroom', 'trashcan', 'milk', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'clothes_jacket', 'toaster', 'stovefan', 'tvstand', 'picture', 'window', 'dustpan', 'pillow', 'dining_room', 'wall', 'box', 'bed', 'wine', 'curtain', 'kettle', 'home_office', 'light', 'dishwasher']  Task:Look out window  response:  {       thoughts : I head into my child's room and look out the window to view the neighborhood from a different area in the house.,       actions : ['[WALK] <bedroom>', '[WALK] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']  }     Scene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'powersocket', 'shelf', 'toilet_paper', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'table', 'vase']  Task:Vacuum  response:

{  Keep my keyboard vacuumed and free of debris. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:  {       thoughts : Type on a computer in the home office.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'powersocket', 'box', 'television', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'door', 'bathtub', 'light', 'table']  Task:Clean screen  response:

{  Use a soft rag to wipe the screen until there are no marks on it. }