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', 'juice', 'tea', 'toilet', 'freezer', 'walllamp', 'dough', 'drawing', 'food_egg', 'floor', 'dvd_player', 'character', 'alcohol', 'stovefan', 'mat', 'shower', 'closetdrawer', 'clothes_hat', 'food_jam', 'wall', 'powersocket', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'laundry_detergent', 'door', 'light', 'dishwasher', 'table']  Task:Go to toilet  response:  {       thoughts : I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[TURNTO] <toilet>', '[LOOKAT] <toilet>', '[WALK] <toilet>', '[TURNTO] <toilet>']  }     Scene_Objects:['sponge', 'pot', 'dog', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'computer', 'stovefan', 'faucet', 'oil', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'keys', 'check', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'light']  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:['spectacles', 'pot', 'scissors', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'tvstand', 'faucet', 'dining_room', 'wall', 'bed', 'novel', 'food_food', 'mouthwash', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap', 'shoe_rack']  Task:Added meat to freezer  response:  {       thoughts : After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'freezer', 'knifeblock', 'drawing', 'wallshelf', 'ceiling', 'phone', 'desk', 'keyboard', 'face', 'toaster', 'laptop', 'tvstand', 'shower', 'stereo', 'homework', 'oil', 'towel', 'oven', 'basket_for_clothes', 'tray', 'towel_rack', 'hair', 'cupboard', 'door', 'bathtub', 'clothes_shirt']  Task:Rain welcome  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>']  }     Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'chair', 'bathroom', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'character', 'bookshelf', 'clothes_jacket', 'piano_bench', 'ceilinglamp', 'shower', 'mousepad', 'teeth', 'pillow', 'check', 'toothbrush_holder', 'coin', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee']  Task:Close door  response:

{  Push the door shut until it latches. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer']  Task:Read book  response:  {       thoughts : I would go lie down in my bed and open the book and start reading.,       actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['dry_pasta', 'pot', 'measuring_cup', 'microwave', 'chair', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'cleaning_solution', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'couch', 'clothes_pants', 'coffe_maker', 'mirror', 'curtain', 'rag', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'dishwasher']  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:['pot', 'food_bread', 'microwave', 'chair', 'knifeblock', 'drawing', 'keyboard', 'button', 'stovefan', 'toaster', 'shower', 'window', 'dustpan', 'pillow', 'dining_room', 'nightstand', 'tape', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'doorjamb', 'kitchen_counter', 'cupboard', 'clothes_dress', 'sink', 'bathroom_cabinet', 'light', 'dishwasher']  Task:Browse internet  response:  {       thoughts : I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[TOUCH] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>']  }     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:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink', 'light', 'table', 'creditcard']  Task:Browse internet  response:  {       thoughts : Walk to home office. Walk to computer. Switch on Computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['filing_cabinet', 'mop', 'chair', 'bathroom', 'food_carrot', 'woman', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'keyboard', 'mat', 'faucet', 'window', 'foundation', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'towel_rack', 'cd', 'dresser', 'sink', 'clothes_scarf', 'light']  Task:Greet guests  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack']  Task:Read book  response:  {       thoughts : 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.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']  }     Scene_Objects:['microwave', 'dog', 'freezer', 'walllamp', 'cat', 'knifeblock', 'bills', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'clothes_hat', 'broom', 'powersocket', 'bench', 'coffe_maker', 'food_food', 'television', 'mirror', 'rag', 'lighter', 'towel_rack', 'mouse', 'dresser', 'sink', 'table', 'clothes_skirt', 'shoe_rack']  Task:Clean mirror  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['measuring_cup', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']  Task:Pet cat  response:  {       thoughts : Find Cat in living room.  Walk to cat.  Pet cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['fork', 'pot', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'knifeblock', 'bathroom_counter', 'keyboard', 'computer', 'brush', 'tvstand', 'shower', 'faucet', 'mousepad', 'wall', 'bench', 'cup', 'bed', 'photoframe', 'clothes_gloves', 'tray', 'wooden_spoon', 'towel_rack', 'dresser', 'cupboard', 'door', 'bathtub', 'napkin', 'bathroom_cabinet']  Task:Wash monitor  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'cat', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'phone', 'ceiling', 'dvd_player', 'desk', 'stovefan', 'faucet', 'shower', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'bed', 'tray', 'mouse', 'dresser', 'home_office']  Task:Keep cats out of room  response:  {       thoughts : Stand in the doorway and create a loud noise so the cats will stay out.,       actions : ['[WALK] <bedroom>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>']  }     Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'mat', 'plate', 'faucet', 'ceilinglamp', 'dish_soap', 'mousepad', 'couch', 'dining_room', 'wall', 'oven', 'bench', 'basket_for_clothes', 'towel_rack', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light']  Task:Wash dirty dishes  response:

{  Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack. }


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', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'keys', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Write an email  response:  {       thoughts : I need to send an email to my friend so I go into my office and sit down at the desk. I turn on the computer and type the email.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[TURNTO] <desk>', '[LOOKAT] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'knife', 'cpuscreen', 'ceiling', 'bedroom', 'bookshelf', 'brush', 'stovefan', 'toaster', 'window', 'couch', 'wall_clock', 'powersocket', 'toy', 'bed', 'television', 'ice', 'curtain', 'mouse', 'dresser', 'controller', 'bathroom_cabinet', 'shoe_rack']  Task:Pick up toys  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'window', 'electric_shaver', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'table', 'light']  Task:Watch TV  response:  {       thoughts : watching TV from sofa,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['filing_cabinet', 'tea', 'chair', 'knifeblock', 'knife', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'desk', 'bedroom', 'bookshelf', 'food_bacon', 'mat', 'shoe-shine_kit', 'food_jam', 'wall', 'powersocket', 'oven', 'photoframe', 'novel', 'mouthwash', 'coffee_filter', 'tray', 'curtain', 'vacuum_cleaner', 'dresser', 'bathtub', 'soap']  Task:Read to child  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'shelf', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office', 'light', 'table', 'laser_pointer']  Task:Write an email  response:  {       thoughts : Find the computer.  Turn on the computer.  Open the e-mail program.  Create a new message.  Write the message.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table']  Task:Pick up toys  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'bookmark', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'oil', 'food_peanut_butter', 'broom', 'wall', 'novel', 'diary', 'mouse', 'cupboard', 'clothes_dress', 'door', 'table', 'light', 'dirt']  Task:Browse internet  response:  {       thoughts : Go to office. Turn on computer. Pull out chair. Sit in chair. Use keyboard and mouse.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>']  }     Scene_Objects:['filing_cabinet', 'beer', 'crayon', 'freezer', 'walllamp', 'bathroom', 'detergent', 'wallshelf', 'floor', 'ceiling', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'photoframe', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Wipe down baseboards please  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'chair', 'ground_coffee', 'food_butter', 'dough', 'drawing', 'floor', 'desk', 'bookmark', 'mat', 'faucet', 'floor_lamp', 'window', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'novel', 'television', 'curtain', 'doorjamb', 'chessboard', 'controller', 'maindoor', 'home_office', 'table']  Task:Read book  response:  {       thoughts : First I walk into the living room, I find the lamp and switch it on. Then I find a book, grab it, sit in the sofa, open the book and read it. When I'm finished, I find a bookmark, grab it and put it in the book. Then I close the book, put it back, and switch off the lamp.,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>', '[SWITCHOFF] <floor_lamp>']  }     Scene_Objects:['sponge', 'pot', 'microwave', 'walllamp', 'cat', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'toaster', 'faucet', 'window', 'dish_soap', 'dining_room', 'wall', 'oven', 'cup', 'drinking_glass', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'dishrack', 'shoes', 'dresser', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'bathtub']  Task:Clean dishes  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'tablelamp', 'microwave', 'dog', 'walllamp', 'trashcan', 'knifeblock', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bag', 'dishwasher', 'colander']  Task:Unload dishwasher  response:  {       thoughts : Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <drinking_glass> <cupboard>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <fork> <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTIN] <knife> <kitchen_cabinet>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTIN] <spoon> <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>']  }     Scene_Objects:['sheets', 'food_ice_cream', 'toilet', 'walllamp', 'dough', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'basket_for_clothes', 'bed', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dishrack', 'door', 'home_office', 'light', 'bathroom_cabinet']  Task:Turn off light  response:

{  Grasp light switch, flip light switch. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_bread', 'tablelamp', 'juice', 'cd_player', 'band-aids', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'homework', 'food_orange', 'nightstand', 'bench', 'bed', 'newspaper', 'photoframe', 'coffe_maker', 'check', 'food_onion', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathtub', 'light']  Task:Listen to music  response:  {       thoughts : I walk in the living room, then I go the the stereo and the cd player and turn them on.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']  }     Scene_Objects:['sponge', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookmark', 'mat', 'mousepad', 'couch', 'food_orange', 'pillow', 'wall', 'wall_clock', 'bed', 'photoframe', 'coffe_maker', 'check', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'home_office', 'table', 'light', 'instrument_guitar', 'scrabble']  Task:Read magazine  response:

{  Please sit on the couch and read a magazine }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light']  Task:Put groceries in Fridge  response:  {       thoughts : Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_vegetable> <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTIN] <food_carrot> <freezer>', '[FIND] <food_cereal>', '[GRAB] <food_cereal>', '[PUTIN] <food_cereal> <freezer>', '[FIND] <food_oatmeal>', '[GRAB] <food_oatmeal>', '[PUTIN] <food_oatmeal> <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[FIND] <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['glue', 'pot', 'filing_cabinet', 'walllamp', 'orchid', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'computer', 'brush', 'toaster', 'mat', 'shower', 'faucet', 'electric_shaver', 'mousepad', 'dining_room', 'nightstand', 'oven', 'toy', 'cup', 'food_onion', 'mouse', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']  Task:Put toys away  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'microwave', 'freezer', 'bathroom', 'cpuscreen', 'desk', 'tea_bag', 'alcohol', 'tvstand', 'oven', 'tape', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'toilet_paper', 'television', 'coffee_filter', 'wooden_spoon', 'mouse', 'cd', 'controller', 'maindoor', 'sink', 'home_office', 'light', 'dishwasher', 'soap', 'dirt', 'shoe_rack']  Task:Listen to music  response:  {       thoughts : Walk into living room. Turn on radio.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['pot', 'food_bread', 'juice', 'food_ice_cream', 'food_oatmeal', 'microwave', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'milk', 'knifeblock', 'drawing', 'knife', 'floor', 'ceiling', 'stovefan', 'toaster', 'mat', 'faucet', 'ceilinglamp', 'bowl', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'food_donut', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dishwasher']  Task:Cook some food  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'detergent', 'ceilingfan', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'picture', 'couch', 'wall', 'pasta', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'maindoor', 'table', 'light', 'vase', 'tooth_paste']  Task:Watch TV  response:  {       thoughts : I sit on my couch and watch TV in my living room,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'dough', 'drawing', 'wallshelf', 'floor', 'character', 'bedroom', 'purse', 'mat', 'ceilinglamp', 'couch', 'food_jam', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'bed', 'food_food', 'coffe_maker', 'tray', 'towel_rack', 'mouse', 'headset', 'laundry_detergent', 'sink', 'home_office', 'table']  Task:Read book  response:

{  Climb into bed, then read the novel }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard']  Task:Turn on light  response:  {       thoughts : I go home and it's dark so I can not see anything,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['glue', 'filing_cabinet', 'crayon', 'mop', 'toilet', 'chair', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'stovefan', 'toaster', 'tvstand', 'faucet', 'stereo', 'electric_shaver', 'wall', 'oven', 'food_food', 'television', 'mirror', 'curtain', 'lighter', 'coffee_pot', 'cupboard', 'hairdryer', 'bathroom_cabinet', 'dishwasher']  Task:Shave  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'detergent', 'trashcan', 'dough', 'clothes_underwear', 'folder', 'stamp', 'bookshelf', 'clothes_jacket', 'table_cloth', 'mousepad', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'nightstand', 'bench', 'oven', 'cutting_board', 'bed', 'food_food', 'check', 'doorjamb', 'console', 'cupboard', 'home_office', 'table']  Task:Pick up phone  response:  {       thoughts : i go find the phone. i pick up the phone,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['tablelamp', 'chair', 'freezer', 'food_carrot', 'milk', 'knifeblock', 'floor', 'ceiling', 'phone', 'bedroom', 'purse', 'toaster', 'stovefan', 'shower', 'faucet', 'couch', 'form', 'pillow', 'wall', 'oven', 'food_food', 'oven_mitts', 'shaving_cream', 'kitchen_counter', 'cd', 'dresser', 'cupboard', 'bathtub', 'table', 'tooth_paste']  Task:Get glass of milk  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'crayon', 'microwave', 'food_carrot', 'orchid', 'knifeblock', 'bills', 'floor', 'bedroom', 'stamp', 'envelope', 'clothes_jacket', 'bookmark', 'toaster', 'faucet', 'towel', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'video_game_controller', 'tray', 'lighter', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'soap', 'scrabble', 'hands_both']  Task:Wash hands  response:  {       thoughts : I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['ironing_board', 'sheets', 'tablelamp', 'detergent', 'knifeblock', 'bathroom_counter', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'window', 'couch', 'pillow', 'bowl', 'nightstand', 'food_cheese', 'video_game_controller', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'bag', 'dishwasher', 'board_game', 'clothes_shirt']  Task:Iron shirt  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light']  Task:Turn on light  response:  {       thoughts : I walk in to the living room. I find the light switch. I turn on the lights.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'deck_of_cards', 'mousepad', 'couch', 'pillow', 'wall', 'child', 'bed', 'coin', 'coffee_filter', 'doorjamb', 'centerpiece', 'door', 'table', 'light', 'dishwasher']  Task:Let baby learn how to walk  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blow_dryer', 'bathroom', 'food_carrot', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'bedroom', 'food_cake', 'computer', 'shower', 'picture', 'oven', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'towel_rack', 'mouse', 'pencil', 'shoes', 'comb', 'hairbrush', 'cupboard', 'laundry_detergent', 'sink', 'napkin', 'light', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']  }     Scene_Objects:['sheets', 'sponge', 'tablelamp', 'mop', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'stamp', 'wine_glass', 'clothes_socks', 'couch', 'pillow', 'wall', 'nightstand', 'food_cheese', 'bed', 'photoframe', 'food_food', 'check', 'doorjamb', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'light']  Task:Entertain  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'walllamp', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'dish_soap', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'coffe_maker', 'food_food', 'kitchen_counter', 'cupboard', 'controller', 'sink', 'dishwasher', 'soap', 'clothes_shirt', 'teeth']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['pot', 'microwave', 'walllamp', 'nail_polish', 'knifeblock', 'drawing', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'character', 'desk', 'faucet', 'stereo', 'shower', 'mousepad', 'couch', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'chessboard', 'cupboard', 'sink', 'table', 'dirt']  Task:Get glass of water  response:

{  Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office']  Task:Make coffee  response:  {       thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['fork', 'filing_cabinet', 'blender', 'chair', 'freezer', 'walllamp', 'nail_polish', 'detergent', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'desk', 'computer', 'mat', 'ceilinglamp', 'plate', 'faucet', 'mousepad', 'candle', 'microphone', 'bowl', 'wall', 'nightstand', 'bench', 'bed', 'keys', 'food_food', 'table']  Task:Eat  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet']  Task:Listen to music  response:  {       thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['sheets', 'pot', 'microwave', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'orchid', 'wallshelf', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'faucet', 'wall', 'oven', 'powersocket', 'bench', 'after_shave', 'curtain', 'centerpiece', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'soap']  Task:Wipe down counter  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'light']  Task:Work  response:  {       thoughts : you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and work.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt']  Task:Get dressed  response:

{  Get some clothes together that make an appropriate outfit.  Put them 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:['chair', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'stovefan', 'toaster', 'laptop', 'faucet', 'closetdrawer', 'couch', 'bowl', 'dining_room', 'wall', 'oven', 'bench', 'bed', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub']  Task:Cook some food  response:  {       thoughts : I switch on the stove and cook my groceries there.,       actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[SWITCHON] <oven>', '[FIND] <bowl>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <oven>', '[FIND] <food_food>', '[SWITCHOFF] <oven>']  }     Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'bookshelf', 'cleaning_solution', 'mat', 'tvstand', 'faucet', 'shower', 'couch', 'wall', 'nightstand', 'bench', 'toy', 'photoframe', 'mirror', 'tray', 'towel_rack', 'paper_towel', 'door', 'sink', 'clothes_scarf', 'bathroom_cabinet']  Task:Clean mirror  response:

{  First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process. }


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', 'microwave', 'walllamp', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'ceilinglamp', 'plate', 'faucet', 'window', 'dish_soap', 'mousepad', 'bowl', 'wall', 'oven', 'powersocket', 'check', 'mouthwash', 'after_shave', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathtub', 'dishwasher']  Task:Wash dishes by hand  response:  {       thoughts : I go to the kitchen and turn on the faucet. I get dish soap and put it into the sink. I grab a sponge and a bowl and start cleaning it. I put the bowl into the dishrack. I find a plate and clean it as well. I put it into the dishrack, turn off the faucet and put the sponge back.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <bowl>', '[GRAB] <bowl>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <bowl>', '[SCRUB] <bowl>', '[RINSE] <bowl>', '[FIND] <dishrack>', '[PUTBACK] <bowl> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>']  }     Scene_Objects:['pot', 'microwave', 'toilet', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'tea_bag', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'pasta', 'nightstand', 'photoframe', 'novel', 'food_food', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'light', 'board_game']  Task:Read book  response:

{  Bring book, lie on the sofa, read book }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'trashcan', 'orchid', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'faucet', 'couch', 'clothes_pants', 'form', 'wall', 'cutting_board', 'photoframe', 'check', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTBACK] <clothes_jacket> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'drawing', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'keyboard', 'brush', 'ceilinglamp', 'toaster', 'mat', 'window', 'nightstand', 'bench', 'photoframe', 'food_food', 'after_shave', 'diary', 'kettle', 'shoes', 'chessboard', 'dresser', 'door', 'bathroom_cabinet', 'colander']  Task:Dust  response:

{  Using soft brush, carefully dust both Indonesian wedding doll statues. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'freezer', 'trashcan', 'food_carrot', 'orchid', 'floor', 'ceiling', 'thread', 'mail', 'button', 'food_bacon', 'bookmark', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'wall', 'bench', 'cup', 'food_food', 'razor', 'television', 'food_donut', 'towel_rack', 'console', 'kitchen_counter', 'hairbrush', 'cupboard', 'sink', 'vase']  Task:Added meat to freezer  response:  {       thoughts : After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['microwave', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'stovefan', 'mat', 'window', 'electric_shaver', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'bed', 'mouthwash', 'tray', 'doorjamb', 'mouse', 'pencil', 'chessboard', 'door', 'bathtub', 'instrument_guitar', 'light', 'soap']  Task:Turn on light  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'blender', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'orchid', 'character', 'bedroom', 'bookshelf', 'alcohol', 'button', 'toaster', 'stereo', 'homework', 'electric_shaver', 'mousepad', 'couch', 'bowl', 'toy', 'clothes_gloves', 'coffe_maker', 'kitchen_counter', 'conditioner', 'napkin', 'table', 'light', 'dishwasher']  Task:Listen to music  response:  {       thoughts : Walk into living room, look for radio, grab on button,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']  }     Scene_Objects:['tablelamp', 'crayon', 'toilet', 'chair', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'computer', 'tvstand', 'faucet', 'stereo', 'food_orange', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'home_office']  Task:Get dressed  response:

{  I get dressed in my bedroom in the mornings. }


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:['pot', 'juice', 'measuring_cup', 'microwave', 'chair', 'freezer', 'band-aids', 'walllamp', 'detergent', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'couch', 'wall', 'oven', 'cup', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'food_snack', 'sink', 'napkin', 'home_office']  Task:Have snack  response:

{  Pour soda into a glass. Get pretzels out of bag. Eat and drink }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['water_glass', 'pot', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']  Task:Drink  response:  {       thoughts : I need to go to Kitchen.  Get a cup.  Fill cup.  Drink,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['spectacles', 'sheets', 'pot', 'tablelamp', 'tea', 'microwave', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'knifeblock', 'bathroom_counter', 'floor', 'remote_control', 'table_cloth', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'tvstand', 'wall', 'nightstand', 'bed', 'newspaper', 'photoframe', 'television', 'food_rice', 'console', 'pencil', 'bathroom_cabinet']  Task:Watch TV  response:

{  Watching tv with a remote is always fun; lay back, relax and enjoy; }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'dresser', 'sink', 'instrument_violin']  Task:Watch TV  response:  {       thoughts : I go to the the living room, sit down on the sofa, and then I switch on the TV with the TV remote,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['sponge', 'tablelamp', 'chair', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'stereo', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'video_game_controller', 'curtain', 'doorjamb', 'lighter', 'kitchen_counter', 'dresser', 'cupboard', 'bathroom_cabinet', 'instrument_guitar']  Task:Listen to music  response:

{  Put iPhone into speaker holder, open up the Pandora app, listen to music. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'detergent', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'wall_clock', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'table', 'light']  Task:Pet cat  response:  {       thoughts : I see my cat on the couch so I walk over, sit down and pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']  }     Scene_Objects:['sheets', 'tablelamp', 'microwave', 'bathroom', 'detergent', 'wallshelf', 'hanger', 'floor', 'character', 'keyboard', 'envelope', 'clothes_jacket', 'stovefan', 'stereo', 'window', 'food_peanut_butter', 'nightstand', 'clothes_gloves', 'food_food', 'food_donut', 'after_shave', 'centerpiece', 'towel_rack', 'cupboard', 'door', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'table', 'home_office']  Task:Put on coat  response:

{  I remove my scarf from a coat peg in the entrance hall.  I wrap the scarf around my neck }


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', 'beer', 'toilet', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'ceiling', 'phone', 'character', 'keyboard', 'toaster', 'mat', 'floor_lamp', 'oil', 'pillow', 'dining_room', 'nightstand', 'wall_clock', 'bench', 'novel', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table']  Task:Read book  response:  {       thoughts : Turn a light on and read a book in the bedroom.,       actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['fork', 'beer', 'microwave', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'dough', 'orchid', 'dvd_player', 'keyboard', 'piano_bench', 'brush', 'faucet', 'pillow', 'dining_room', 'powersocket', 'newspaper', 'coffe_maker', 'television', 'wine', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'conditioner', 'clothes_scarf', 'bathtub', 'bathroom_cabinet', 'creditcard']  Task:Lock door  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bedroom', 'character', 'ceilinglamp', 'tvstand', 'faucet', 'dustpan', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'photoframe', 'bed', 'food_food', 'television', 'food_donut', 'food_rice', 'doorjamb', 'shaving_cream', 'table', 'vase']  Task:Put groceries in Fridge  response:  {       thoughts : walk to kitchen and seprate the groceries and arrange in fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>']  }     Scene_Objects:['filing_cabinet', 'scissors', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'centerpiece', 'kitchen_counter', 'door', 'table', 'light', 'creditcard']  Task:Watch TV  response:

{  I like to set on my sofa.Turn on the tv. And watch Perry Mason. Monday's through Friday's. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'spectacles', 'food_salt', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'purse', 'computer', 'ceilinglamp', 'window', 'mousepad', 'food_noodles', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'toilet_paper', 'television', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'door', 'light', 'table']  Task:Put groceries in Fridge  response:  {       thoughts : Open the fridge, put the groceries in the fridge and close it.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['pot', 'microwave', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table']  Task:Watch TV  response:

{  Sit on the couch. Get comfortable. Switch on the television. Stare at the television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'computer', 'mat', 'shoe-shine_kit', 'oil', 'pillow', 'wall', 'pasta', 'powersocket', 'cup', 'food_food', 'video_game_controller', 'toothbrush_holder', 'television', 'doorjamb', 'kettle', 'door', 'light', 'clothes_skirt', 'coffee']  Task:Turn on light  response:  {       thoughts : switching on light in an area,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['beer', 'microwave', 'toilet', 'chair', 'freezer', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'window', 'pillow', 'wall', 'powersocket', 'oven', 'bench', 'food_cheese', 'bed', 'photoframe', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'lighter', 'kitchen_counter', 'cupboard', 'home_office']  Task:Eat cheese  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', '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:  {       thoughts : Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done,       actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <pot>', '[TURNTO] <pot>', '[LOOKAT] <pot>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[SWITCHOFF] <oven>']  }     Scene_Objects:['band-aids', 'trashcan', 'woman', 'drawing', 'orchid', 'floor', 'ceiling', 'man', 'envelope', 'tvstand', 'stereo', 'shoe-shine_kit', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'cup', 'food_food', 'coffe_maker', 'razor', 'tray', 'doorjamb', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table', 'light', 'home_office']  Task:Hang with friends  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:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light']  Task:Watch TV  response:  {       thoughts : Walk into the living room. Sit on the couch. Turn on TV.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'detergent', 'drawing', 'knifeblock', 'food_egg', 'floor', 'computer', 'toaster', 'stovefan', 'tvstand', 'stereo', 'window', 'food_noodles', 'mousepad', 'couch', 'pillow', 'dining_room', 'nightstand', 'pasta', 'bed', 'oven_mitts', 'tray', 'curtain', 'lighter', 'towel_rack', 'shoes', 'cd', 'pajamas']  Task:Put clothes away  response:

{  I take clean clothes and either place them in dresser drawers or hang them in a closet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['scissors', 'microwave', 'toilet', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'stovefan', 'mat', 'faucet', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'bench', 'cutting_board', 'shelf', 'food_rice', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer', 'dirt', 'hands_both']  Task:Hand washing  response:  {       thoughts : Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['pot', 'tablelamp', 'ground_coffee', 'walllamp', 'trashcan', 'knifeblock', 'hanger', 'floor', 'phone', 'character', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'mousepad', 'pillow', 'wall', 'oven', 'cutting_board', 'television', 'food_rice', 'water', 'tray', 'kitchen_counter', 'cd', 'dresser', 'cupboard', 'bathroom_cabinet', 'home_office']  Task:Make coffee  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', 'pot', 'filing_cabinet', 'food_ice_cream', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'faucet', 'ceilinglamp', 'wall', 'powersocket', 'photoframe', 'clothes_gloves', 'bed', 'food_food', 'check', 'ice', 'doorjamb', 'pencil', 'kitchen_counter', 'laundry_detergent', 'door', 'napkin', 'home_office', 'light', 'dishwasher']  Task:Turn on light  response:  {       thoughts : switching on the light,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']  Task:Greet guests  response:

{  Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt']  Task:Make coffee  response:  {       thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'man', 'bookshelf', 'clothes_jacket', 'piano_bench', 'toaster', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'coffe_maker', 'doorjamb', 'cupboard', 'door', 'sink', 'home_office', 'table', 'light']  Task:Have conversation with boyfriend  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:['sponge', 'pot', 'tablelamp', 'microwave', 'hanger', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'mousepad', 'couch', 'candle', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'drinking_glass', 'wooden_spoon', 'curtain', 'tray', 'doorjamb', 'kitchen_counter', 'paper_towel', 'cupboard', 'sink', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : wipe loose dirt, place in the dishwasher, turn on the dishwasher,       actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <drinking_glass>', '[RINSE] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['pot', 'mop', 'microwave', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'window', 'laptop', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'check', 'tray', 'rag', 'towel_rack', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet']  Task:Wash dishes  response:

{  Run hot water into tub of dirty dishes in the sink.  Add liquid soap.  Scrub dishes with wash rag. Rinse and place on drying rack. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['scissors', 'chair', 'bathroom', 'drawing', 'wallshelf', 'cpuscreen', 'character', 'desk', 'envelope', 'computer', 'shower', 'faucet', 'electric_shaver', 'dustpan', 'dining_room', 'wall', 'bench', 'tape', 'photoframe', 'check', 'doorjamb', 'centerpiece', 'mouse', 'hairbrush', 'bathroom_cabinet', 'table', 'home_office', 'light', 'instrument_guitar', 'creditcard']  Task:Receive credit card  response:  {       thoughts : hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard,       actions : ['[WALK] <home_office>', '[WALK] <envelope>', '[FIND] <envelope>', '[GRAB] <envelope>', '[WALK] <home_office>', '[WALK] <scissors>', '[FIND] <scissors>', '[OPEN] <envelope>', '[FIND] <creditcard>', '[GRAB] <creditcard>']  }     Scene_Objects:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game']  Task:Write  school paper  response:

{  Writing  and drafting a paper for  class work }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'tablelamp', 'microwave', 'freezer', 'drawing', 'phone', 'bookshelf', 'toaster', 'stovefan', 'tvstand', 'mousepad', 'couch', 'clothes_hat', 'food_orange', 'wall', 'photoframe', 'clothes_gloves', 'bed', 'check', 'television', 'food_rice', 'tray', 'doorjamb', 'dresser', 'hairdryer', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'door']  Task:Listen to music  response:  {       thoughts : I go to my bedroom, and then I switch on the radio,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['scissors', 'ground_coffee', 'trashcan', 'woman', 'knife', 'cpuscreen', 'phone', 'man', 'bookshelf', 'computer', 'stovefan', 'mat', 'brush', 'shower', 'deck_of_cards', 'pillow', 'powersocket', 'bench', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'mouse', 'kitchen_counter', 'chessboard', 'door', 'bathtub', 'bathroom_cabinet', 'coffee']  Task:Greet people  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', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'powersocket', 'clothes_gloves', 'television', 'razor', 'curtain', 'doorjamb', 'console', 'mouse', 'door', 'bag', 'table', 'dishwasher']  Task:Change TV channel  response:  {       thoughts : I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[PUSH] <remote_control>']  }     Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'home_office', 'table', 'light']  Task:Watch TV  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['toilet', 'chair', 'bathroom', 'detergent', 'cat', 'trashcan', 'woman', 'drawing', 'character', 'bedroom', 'man', 'keyboard', 'bookshelf', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'clothes_hat', 'dining_room', 'wall', 'child', 'toy', 'tray', 'curtain', 'mouse', 'cupboard', 'door', 'spoon', 'home_office', 'table']  Task:Greet guests  response:

{  Greet guests when they knock on the door and invite them to enter my home }


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', 'microwave', 'ceilingfan', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'keyboard', 'toaster', 'mat', 'balanceball', 'stereo', 'window', 'microphone', 'bench', 'basket_for_clothes', 'clothes_gloves', 'check', 'oven_mitts', 'kettle', 'dresser', 'cupboard', 'maindoor', 'napkin', 'light', 'clothes_skirt', 'washing_machine', 'shoe_rack']  Task:Wash clothes  response:  {       thoughts : Wash the clothes in the washing machine,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'table_cloth', 'faucet', 'homework', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'bed', 'doorjamb', 'cards', 'cupboard', 'door', 'sink', 'spoon', 'table', 'light']  Task:Arrange furniture  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:['tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'controller', 'door', 'light', 'table']  Task:Work  response:  {       thoughts : Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'jelly', 'chair', 'walllamp', 'detergent', 'trashcan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'keyboard', 'stovefan', 'mat', 'ceilinglamp', 'food_orange', 'wall', 'bench', 'oven', 'food_food', 'oven_mitts', 'doorjamb', 'dresser', 'cupboard', 'home_office', 'table', 'bathroom_cabinet']  Task:Play games  response:

{  I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'food_bread', 'microwave', 'chair', 'band-aids', 'woman', 'needle', 'longboard', 'man', 'keyboard', 'envelope', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'nightstand', 'box', 'light_bulb', 'coffe_maker', 'curtain', 'towel_rack', 'shoes', 'dresser', 'hairbrush', 'door', 'vase', 'instrument_violin', 'creditcard']  Task:Greet guests  response:  {       thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']  }     Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'knifeblock', 'floor', 'ceiling', 'character', 'desk', 'food_cake', 'computer', 'bookmark', 'toaster', 'stovefan', 'mat', 'faucet', 'food_kiwi', 'wall', 'oven', 'powersocket', 'food_vegetable', 'bed', 'food_food', 'oven_mitts', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard']  Task:Cook some food  response:

{  I prepare meals and cook them on the stove. }


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', 'blender', 'chair', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'thread', 'ceilinglamp', 'laptop', 'faucet', 'mousepad', 'couch', 'candle', 'food_jam', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'tray', 'after_shave', 'food_onion', 'shoes', 'cupboard']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room. I sit in the sofa and I relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['blender', 'juice', 'cd_player', 'chair', 'freezer', 'detergent', 'trashcan', 'knife', 'knifeblock', 'drawing', 'floor', 'ceiling', 'bedroom', 'keyboard', 'remote_control', 'computer', 'button', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'nightstand', 'after_shave', 'door', 'bathtub', 'home_office', 'table', 'clothes_skirt', 'instrument_guitar', 'light']  Task:Listen to music  response:

{  Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music. }