Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table', 'clothes_skirt']  Task:Write an email  response:  {       thoughts : enter office, find computer, turn it on,,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['sheets', 'toilet', 'freezer', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'button', 'bookmark', 'ceilinglamp', 'window', 'couch', 'microphone', 'pillow', 'wall', 'pasta', 'tape', 'box', 'novel', 'curtain', 'doorjamb', 'hairbrush', 'door', 'home_office', 'table', 'bathroom_cabinet', 'soap', 'tooth_paste', 'clothes_shirt']  Task:Text friends while sitting on couch  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'couch', 'candle', 'clothes_hat', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'curtain', 'diary', 'towel_rack', 'mouse', 'dishrack', 'home_office', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['sponge', 'food_pizza', 'juice', 'crayon', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mat', 'tvstand', 'faucet', 'wall', 'powersocket', 'bench', 'tape', 'photoframe', 'clothes_gloves', 'food_donut', 'after_shave', 'doorjamb', 'dishrack', 'door', 'sink', 'bathroom_cabinet', 'soap']  Task:Clean sink  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'scissors', 'crayon', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'window', 'homework', 'couch', 'wall', 'child', 'bench', 'photoframe', 'newspaper', 'coffe_maker', 'razor', 'television', 'kitchen_counter', 'cupboard', 'table', 'coffee']  Task:Let baby learn how to walk  response:  {       thoughts : The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.,       actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>']  }     Scene_Objects:['food_salt', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'ceiling', 'character', 'toaster', 'ceilinglamp', 'tvstand', 'stereo', 'deck_of_cards', 'oil', 'wall', 'bench', 'powersocket', 'novel', 'coffe_maker', 'food_food', 'television', 'tray', 'rag', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'scrabble']  Task:Make popcorn  response:

{  Lay popcorn bag flat inside microwave and press popcorn button to start. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'chair', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'phone', 'folder', 'man', 'keyboard', 'mop_bucket', 'tvstand', 'faucet', 'picture', 'plate', 'mousepad', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'check', 'food_onion', 'clothes_scarf', 'spoon', 'light', 'dishwasher']  Task:Greet guests  response:  {       thoughts : When someone knocks I n the door walk through the hallway and greet them.,       actions : ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']  }     Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'food_butter', 'toothbrush', 'knifeblock', 'floor', 'character', 'bookshelf', 'food_cake', 'mat', 'shoe-shine_kit', 'shower', 'mousepad', 'couch', 'microphone', 'cup', 'newspaper', 'mouthwash', 'television', 'coffee_filter', 'food_donut', 'console', 'kitchen_counter', 'headset', 'dresser', 'cupboard', 'clothes_dress', 'home_office']  Task:Answer door  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'sponge', 'scissors', 'chair', 'dog', 'drawing', 'bills', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'ceilinglamp', 'shoe-shine_kit', 'window', 'foundation', 'couch', 'wall', 'bench', 'basket_for_clothes', 'bed', 'novel', 'television', 'kitchen_counter', 'dresser', 'cupboard', 'bathroom_cabinet', 'light', 'table']  Task:Read book  response:  {       thoughts : Grab book.  Read it.,       actions : ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <dresser>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']  }     Scene_Objects:['fork', 'tablelamp', 'microwave', 'jelly', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'character', 'table_cloth', 'toaster', 'stovefan', 'mat', 'iron', 'pillow', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'coffe_maker', 'television', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'door', 'dishwasher', 'clothes_skirt']  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:['pot', 'scissors', 'beer', 'microwave', 'bathroom', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'toaster', 'brush', 'plate', 'shower', 'clothes_socks', 'dining_room', 'wall', 'powersocket', 'tape', 'box', 'cup', 'coffe_maker', 'food_food', 'doorjamb', 'centerpiece', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['beer', 'walllamp', 'drawing', 'orchid', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'keys', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'table']  Task:Watch movie  response:

{  Sit down on couch in front of TV.  Use remote to turn on the TV }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_pizza', 'ground_coffee', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'faucet', 'oil', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'after_shave', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'dishwasher']  Task:Make coffee  response:  {       thoughts : Get my coffee pot going,       actions : ['[WALK] <dining_room>', '[WALK] <coffee_pot>', '[FIND] <coffee_pot>', '[GRAB] <coffee_pot>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffee_pot>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffee_pot>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <oven>', '[PUTBACK] <coffee_pot> <oven>', '[SWITCHON] <oven>']  }     Scene_Objects:['pot', 'filing_cabinet', 'jelly', 'freezer', 'walllamp', 'ground_coffee', 'knife', 'knifeblock', 'cpuscreen', 'orchid', 'needle', 'floor', 'ceiling', 'desk', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'clothes_hat', 'wall', 'oven', 'cup', 'food_food', 'toothbrush_holder', 'tray', 'rag', 'kitchen_counter', 'cupboard', 'sink', 'bag']  Task:Clean  response:

{  Take out a rag. Turn on faucet and get water on the rag. Clean counter off. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'food_pizza', 'food_salt', 'freezer', 'drawing', 'knife', 'cpuscreen', 'knifeblock', 'floor', 'character', 'bookshelf', 'laptop', 'plate', 'mousepad', 'candle', 'dining_room', 'wall', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'kitchen_counter', 'chessboard', 'dishrack', 'shoes', 'cupboard', 'laundry_detergent', 'dishwasher', 'instrument_violin']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['tablelamp', 'measuring_cup', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'face', 'computer', 'bookmark', 'mat', 'faucet', 'mousepad', 'clothes_hat', 'towel', 'dining_room', 'wall', 'wall_clock', 'nightstand', 'face_soap', 'basket_for_clothes', 'newspaper', 'tray', 'rag', 'mouse', 'dishrack', 'sink', 'bathroom_cabinet']  Task:Wash face  response:

{  Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'detergent', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'tvstand', 'shower', 'homework', 'oil', 'dustpan', 'dining_room', 'wall', 'powersocket', 'bench', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'home_office', 'light']  Task:Turn on light  response:  {       thoughts : Walk into the bedroom and walk to the light switch. Flip the switch.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     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:

{  Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'food_food', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'sink']  Task:Wash dishes by hand  response:  {       thoughts : Walk to Kitchen, find sink, find dishes and dish soap. Put soap on plate. open faucet, rinse dishes close faucet.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <plate>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <plate>']  }     Scene_Objects:['chair', 'walllamp', 'cat', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'food_noodles', 'mousepad', 'wall', 'oven', 'check', 'video_game_controller', 'television', 'oven_mitts', 'after_shave', 'food_onion', 'centerpiece', 'mouse', 'door', 'table', 'coffee']  Task:Use computer  response:

{  Sit at my desk and grade papers on my computer }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'jelly', 'freezer', 'food_carrot', 'drawing', 'floor', 'ceiling', 'desk', 'envelope', 'table_cloth', 'mat', 'faucet', 'mousepad', 'couch', 'pillow', 'towel', 'wall', 'cup', 'food_food', 'mouthwash', 'television', 'water', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'light', 'dishwasher', 'table']  Task:Drink  response:  {       thoughts : Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup,       actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>']  }     Scene_Objects:['food_carrot', 'milk', 'dough', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'stereo', 'towel', 'pillow', 'wall', 'bench', 'cup', 'bed', 'photoframe', 'coffe_maker', 'wooden_spoon', 'after_shave', 'rag', 'mouse', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:

{  Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_ice_cream', 'microwave', 'toilet', 'chair', 'knifeblock', 'hanger', 'floor', 'toaster', 'stovefan', 'shoe-shine_kit', 'faucet', 'homework', 'food_noodles', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'newspaper', 'coffee_filter', 'food_rice', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'comb', 'cupboard', 'door', 'sink']  Task:Drink  response:  {       thoughts : go to the kitchen, walk to the cabinet, pic up a glass. carry the glass to the sink. turn on the water and fill up the glass. drink the water.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']  }     Scene_Objects:['mop', 'freezer', 'trashcan', 'milk', 'knifeblock', 'orchid', 'clothes_underwear', 'bookshelf', 'purse', 'thread', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'couch', 'microphone', 'wall', 'cutting_board', 'basket_for_clothes', 'keys', 'toothbrush_holder', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'chessboard', 'home_office', 'bathroom_cabinet', 'clothes_skirt', 'light']  Task:Hang up car keys  response:

{  Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'drawing', 'hanger', 'floor', 'phone', 'ceilinglamp', 'plate', 'iron', 'candle', 'pillow', 'wall', 'bench', 'powersocket', 'oven', 'food_food', 'video_game_controller', 'check', 'wooden_spoon', 'after_shave', 'doorjamb', 'shoes', 'dresser', 'cupboard', 'clothes_dress', 'door', 'conditioner', 'sink', 'table', 'light']  Task:Eat dinner  response:  {       thoughts : Put food on the table, sit down, and eat the food.,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <plate> <table>', '[FIND] <chair>', '[SIT] <chair>', '[EAT] <plate>']  }     Scene_Objects:['walllamp', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'microphone', 'pillow', 'wall', 'wall_clock', 'photoframe', 'television', 'toothbrush_holder', 'food_donut', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'sink', 'clothes_scarf', 'napkin', 'table']  Task:Straighten pictures on wall  response:

{  Move the pictures/paintings until they are straight. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'food_pizza', 'dry_pasta', 'walllamp', 'trashcan', 'food_carrot', 'dough', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'wall', 'wall_clock', 'oven', 'food_cheese', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher']  Task:Keep an eye on stove as something is cooking  response:  {       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:['food_ice_cream', 'measuring_cup', 'freezer', 'nail_polish', 'food_carrot', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'plate', 'mat', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'powersocket', 'bench', 'food_vegetable', 'food_food', 'doorjamb', 'mouse', 'door', 'light', 'table', 'scrabble']  Task:Fix snack  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'measuring_cup', 'toilet', 'jelly', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'alcohol', 'mat', 'shower', 'foundation', 'electric_shaver', 'mousepad', 'wall', 'toy', 'basket_for_clothes', 'photoframe', 'wine', 'dresser', 'laundry_detergent', 'food_steak', 'door', 'napkin', 'bathroom_cabinet', 'dishwasher']  Task:Pick up toys  response:  {       thoughts : Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <toy> <dresser>', '[CLOSE] <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['dry_pasta', 'sheets', 'pot', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'tvstand', 'stereo', 'window', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'powersocket', 'pasta', 'oven', 'light_bulb', 'coffe_maker', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'door', 'light']  Task:Turn light off  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['juice', 'toilet', 'chair', 'freezer', 'detergent', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'bedroom', 'piano_bench', 'ceilinglamp', 'mat', 'shower', 'faucet', 'oil', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'check', 'doorjamb', 'vacuum_cleaner', 'door', 'table', 'light']  Task:Put groceries in Fridge  response:  {       thoughts : Put the groceries on the table into the fridge,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTBACK] <food_chicken> <freezer>', '[CLOSE] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_carrot> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['tablelamp', 'walllamp', 'dough', 'drawing', 'orchid', 'needle', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'bookmark', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'food_kiwi', 'wall', 'oven', 'photoframe', 'novel', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office', 'table']  Task:Admire art  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tea', 'microwave', 'toilet', 'jelly', 'bathroom_counter', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'food_noodles', 'clothes_socks', 'mousepad', 'closetdrawer', 'food_kiwi', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'toothbrush_holder', 'television', 'oven_mitts', 'water', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'soap', 'tooth_paste']  Task:Drink  response:  {       thoughts : Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']  }     Scene_Objects:['tablelamp', 'chair', 'dough', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'homework', 'mousepad', 'towel', 'wall', 'nightstand', 'bed', 'novel', 'coffe_maker', 'toothbrush_holder', 'ice', 'diary', 'kettle', 'mouse', 'door', 'spoon', 'instrument_violin']  Task:Study  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['measuring_cup', 'chair', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'shaving_cream', 'mouse', 'comb', 'door', 'napkin', 'table', 'light']  Task:Browse internet  response:  {       thoughts : I turn on computer. I use keyboard to type. I open browser. I search.,       actions : ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'video_game_console', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'candle', 'broom', 'wall', 'powersocket', 'check', 'video_game_controller', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'hairbrush', 'door', 'table', 'dishwasher', 'dirt']  Task:Play games  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'chair', 'bathroom', 'drawing', 'food_egg', 'floor', 'desk', 'bookshelf', 'computer', 'mat', 'stereo', 'shower', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'controller', 'door', 'clothes_scarf', 'light', 'dishwasher', 'board_game']  Task:Pull up carpet  response:  {       thoughts : Pry up a corner of your old dirty carpet.  Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.,       actions : ['[WALK] <home_office>', '[WALK] <mat>', '[FIND] <mat>', '[TOUCH] <mat>', '[PULL] <mat>']  }     Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'band-aids', 'cat', 'food_carrot', 'knife', 'foundation', 'electric_shaver', 'mousepad', 'clothes_socks', 'pillow', 'dining_room', 'nightstand', 'oven', 'toy', 'check', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'chessboard', 'cupboard', 'conditioner', 'door', 'food_steak', 'clothes_skirt', 'duster']  Task:Dust  response:

{  Get a broom or duster with long handle. Dust blades of ceiling fan. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'character', 'video_game_console', 'bedroom', 'computer', 'button', 'table_cloth', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'box', 'video_game_controller', 'television', 'curtain', 'pencil', 'dresser', 'door', 'table']  Task:Play games  response:  {       thoughts : Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video  game remote controller.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'blender', 'toilet', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'cup', 'bed', 'keys', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'door', 'table', 'shoe_rack']  Task:Watch  TV  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'glue', 'tablelamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'clothes_jacket', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'novel', 'mouse', 'shoes', 'dresser', 'clothes_dress', 'light', 'table']  Task:Get ready for day  response:  {       thoughts : Grab shoes, purse etc and head out the door!,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <purse>', '[GRAB] <purse>', '[CLOSE] <dresser>', '[WALK] <home_office>']  }     Scene_Objects:['pot', 'tablelamp', 'drawing', 'needle', 'knife', 'clothes_underwear', 'hanger', 'floor', 'envelope', 'computer', 'ceilinglamp', 'oil', 'mousepad', 'pillow', 'bowl', 'wall', 'nightstand', 'child', 'bed', 'novel', 'food_food', 'coffe_maker', 'television', 'doorjamb', 'dishrack', 'comb', 'laundry_detergent', 'conditioner', 'sink', 'instrument_violin']  Task:Story reading time  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'mop_bucket', 'stovefan', 'mat', 'tvstand', 'toaster', 'foundation', 'mousepad', 'pillow', 'wall', 'standingmirror', 'photoframe', 'toilet_paper', 'oven_mitts', 'tray', 'mouse', 'sink']  Task:Read book  response:  {       thoughts : go to living room,find the text book on the self ,sat on the chair ,open and read the book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'piano_bench', 'mat', 'tvstand', 'faucet', 'shower', 'homework', 'clothes_socks', 'broom', 'wall', 'bench', 'cup', 'rag', 'kitchen_counter', 'laundry_detergent', 'door', 'sink', 'bathroom_cabinet', 'tooth_paste']  Task:Wipe down sink  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'spectacles', 'pot', 'microwave', 'knifeblock', 'floor', 'ceiling', 'folder', 'character', 'toaster', 'plate', 'drying_rack', 'faucet', 'dish_soap', 'couch', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'dirt', 'coffee']  Task:Wash dishes by hand  response:  {       thoughts : I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off.,       actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <sponge>', '[GRAB] <sponge>', '[RINSE] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[FIND] <drying_rack>', '[PUTBACK] <plate> <plate>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['glue', 'microwave', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'purse', 'mail', 'ceilinglamp', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'bed', 'light_bulb', 'check', 'food_food', 'curtain', 'kitchen_counter', 'chessboard', 'dishrack', 'dresser', 'laundry_detergent', 'door', 'light', 'shoe_rack']  Task:Open window  response:

{  Unlock the latch at the top. Push the bottom half of the window upwards. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'dog', 'walllamp', 'clothes_underwear', 'bathroom_counter', 'phone', 'character', 'desk', 'tea_bag', 'envelope', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'food_kiwi', 'nightstand', 'cutting_board', 'photoframe', 'coffe_maker', 'television', 'tray', 'rag', 'doorjamb', 'diary', 'cupboard', 'hairdryer', 'home_office', 'light', 'table', '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:['sheets', 'toilet', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'bathroom_counter', 'purse', 'alcohol', 'bookmark', 'stovefan', 'toaster', 'stereo', 'food_jam', 'dining_room', 'powersocket', 'food_food', 'mouthwash', 'tray', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office', 'laser_pointer']  Task:Walk through  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'trashcan', 'floor', 'tea_bag', 'thread', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'wall', 'bed', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'hair', 'controller', 'bathroom_cabinet', 'dishwasher']  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:['spectacles', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'hanger', 'floor', 'ceiling', 'shampoo', 'bedroom', 'desk', 'envelope', 'table_cloth', 'bookmark', 'brush', 'toaster', 'window', 'couch', 'dustpan', 'food_jam', 'pillow', 'dining_room', 'wall', 'photoframe', 'check', 'tray', 'curtain', 'lighter', 'dresser', 'light']  Task:Gaze out window  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'toilet', 'freezer', 'wallshelf', 'hanger', 'bathroom_counter', 'bookshelf', 'mail', 'brush', 'mat', 'shoe-shine_kit', 'homework', 'closetdrawer', 'couch', 'food_orange', 'towel', 'dining_room', 'wall', 'powersocket', 'box', 'novel', 'check', 'coffe_maker', 'tray', 'doorjamb', 'diary', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap']  Task:Read book  response:  {       thoughts : Pick up the book, open to current page, read the words.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['glue', 'chair', 'bathroom', 'detergent', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'purse', 'face', 'mat', 'tvstand', 'faucet', 'mousepad', 'wall', 'bench', 'face_soap', 'newspaper', 'novel', 'ice', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'conditioner', 'sink', 'bathroom_cabinet', 'light', 'table']  Task:Wash face  response:

{  Run warm water. Cleanse my face with soap. Rinse my face with water. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'walllamp', 'woman', 'drawing', 'phone', 'desk', 'man', 'toaster', 'laptop', 'mat', 'shower', 'electric_shaver', 'oil', 'form', 'pillow', 'dining_room', 'oven', 'shelf', 'bed', 'standingmirror', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'tooth_paste', 'scrabble']  Task:Greet guests  response:  {       thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']  }     Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'measuring_cup', 'walllamp', 'detergent', 'cat', 'milk', 'knifeblock', 'floor', 'ceiling', 'character', 'folder', 'bookshelf', 'piano_bench', 'table_cloth', 'faucet', 'window', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_cheese', 'bed', 'check', 'kitchen_counter', 'cupboard', 'sink', 'clothes_scarf', 'clothes_skirt']  Task:Wipe down sink  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'food_pizza', 'tablelamp', 'mop', 'chair', 'freezer', 'walllamp', 'dough', 'drawing', 'knifeblock', 'wallshelf', 'orchid', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'bowl', 'wall', 'oven', 'bench', 'toy', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink']  Task:Cook some food  response:  {       thoughts : go to the kitchen and cook some thing to eat,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <oven>', '[OPEN] <oven>', '[FIND] <food_pizza>', '[GRAB] <food_pizza>', '[PUTIN] <food_pizza> <oven>', '[SWITCHON] <oven>']  }     Scene_Objects:['pot', 'filing_cabinet', 'scissors', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'faucet', 'mousepad', 'food_orange', 'wall', 'powersocket', 'wooden_spoon', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'table']  Task:Computer work  response:

{  Find the computer, Turn on the computer, find keyboard, find mouse, go online }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'mop', 'toilet', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'food_food', 'mouthwash', 'television', 'food_donut', 'curtain', 'after_shave', 'dresser', 'table']  Task:Look at painting  response:  {       thoughts : Walk to the painting.  Look up at the painting.  Admire it on the wall.,       actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']  }     Scene_Objects:['walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'towel', 'wall', 'powersocket', 'bench', 'newspaper', 'television', 'curtain', 'doorjamb', 'mouse', 'hair', 'door', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Watch TV  response:

{  SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'cat', 'milk', 'orchid', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'toaster', 'ceilinglamp', 'mat', 'stereo', 'picture', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'doorjamb', 'door', 'light', 'table']  Task:Look at painting  response:  {       thoughts : Walk to the painting.  Look up at the painting.  Admire it on the wall.,       actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'bathroom', 'food_butter', 'drawing', 'food_egg', 'floor', 'computer', 'mat', 'tvstand', 'stereo', 'laptop', 'clothes_pants', 'towel', 'wall', 'nightstand', 'tape', 'bed', 'food_food', 'coffe_maker', 'television', 'oven_mitts', 'tray', 'curtain', 'diary', 'cards', 'dishwasher']  Task:Listen to music  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'table_cloth', 'tvstand', 'shower', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'television', 'tray', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'board_game']  Task:Turn on light  response:  {       thoughts : walk into living room, walk to light, turn on light switch.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['food_bread', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'face', 'toaster', 'mat', 'faucet', 'foundation', 'mousepad', 'towel', 'dining_room', 'broom', 'wall', 'bowl', 'bench', 'face_soap', 'food_cheese', 'coin', 'water', 'after_shave', 'rag', 'curtain', 'mouse', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet', 'hands_both']  Task:Wash face  response:

{  Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'tablelamp', 'freezer', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bedroom', 'alcohol', 'computer', 'table_cloth', 'stovefan', 'mat', 'shower', 'oil', 'couch', 'pillow', 'wall', 'cutting_board', 'newspaper', 'food_food', 'television', 'kettle', 'kitchen_counter', 'cupboard', 'clothes_dress', 'shoe_rack']  Task:Put groceries in Fridge  response:  {       thoughts : Walk to kitchen. Find groceries. Grab groceries. Find fridge. Walk to fridge. Put groceries in fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>']  }     Scene_Objects:['food_bread', 'food_ice_cream', 'freezer', 'milk', 'drawing', 'knife', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'stamp', 'desk', 'keyboard', 'computer', 'button', 'mat', 'plate', 'ceilinglamp', 'mousepad', 'candle', 'pillow', 'wall', 'bench', 'powersocket', 'cup', 'food_food', 'doorjamb', 'mouse', 'door', 'napkin', 'table', 'light']  Task:Cut bread  response:

{  I get a slice of bread, grab a knife, and then cut the piece of bread in half. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']  Task:Pick up phone  response:  {       thoughts : Enter the Home office, then walk to the phone, pickup the phone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['pot', 'juice', 'jelly', 'freezer', 'walllamp', 'nail_polish', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'powersocket', 'bench', 'cup', 'food_food', 'food_rice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table', 'board_game']  Task:Grab some juice  response:

{  I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : Grasp light switch, flip light switch.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['pot', 'crayon', 'tea', 'beer', 'microwave', 'toilet', 'trashcan', 'food_carrot', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'bed', 'photoframe', 'doorjamb', 'dishrack', 'cupboard', 'sink', 'home_office']  Task:Open bathroom window  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'bed', 'coffe_maker', 'television', 'food_donut', 'doorjamb', 'mouse', 'door', 'table', 'shoe_rack']  Task:Work  response:  {       thoughts : Walk to living-room. Look at the desk where Computer stays. Sit in chair. Switch on computer. Work on computer. Switch off computer.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[TURNTO] <desk>', '[LOOKAT] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[WATCH] <computer>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['pot', 'food_ice_cream', 'freezer', 'walllamp', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'oven', 'powersocket', 'cup', 'ice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']  Task:Get something to drink  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game']  Task:vacuum carpet  response:  {       thoughts : I bring my vacuum cleaner into the living room.  I plug it into the wall.  I press the on switch on the vacuum cleaner.  I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet.  I turn the vacuum cleaner off.  I take the vacuum cleaner back to the hall closet.,       actions : ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']  }     Scene_Objects:['tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'folder', 'desk', 'keyboard', 'computer', 'faucet', 'stereo', 'mousepad', 'food_peanut_butter', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'check', 'toothbrush_holder', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light']  Task:Read  response:

{  I like to read books in my bedroom. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'tea', 'chair', 'freezer', 'ground_coffee', 'drawing', 'orchid', 'floor', 'purse', 'faucet', 'balanceball', 'food_noodles', 'food_peanut_butter', 'wall', 'powersocket', 'toy', 'bed', 'food_food', 'check', 'food_donut', 'doorjamb', 'pencil', 'laundry_detergent', 'door', 'bag', 'napkin', 'light', 'table']  Task:Pick up toys  response:  {       thoughts : Grab toys off floor.  Put it in a container.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'floor_lamp', 'foundation', 'couch', 'pillow', 'bowl', 'dining_room', 'wall', 'nightstand', 'oven', 'bed', 'food_donut', 'console', 'cupboard', 'bathroom_cabinet']  Task:Turn on lights  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'scissors', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'food_jam', 'wall', 'novel', 'television', 'curtain', 'doorjamb', 'comb', 'clothes_dress', 'sink', 'home_office', 'table']  Task:Change TV channel  response:  {       thoughts : first i will go to living room and then take the remote and swtitch on television after that il change the channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['glue', 'food_bread', 'filing_cabinet', 'bathroom', 'ceiling', 'phone', 'keyboard', 'purse', 'bookshelf', 'laptop', 'ceilinglamp', 'faucet', 'nightstand', 'bench', 'photoframe', 'bed', 'clothes_gloves', 'food_food', 'coffe_maker', 'television', 'toothbrush_holder', 'curtain', 'shaving_cream', 'pencil', 'dresser', 'conditioner', 'door', 'spoon', 'bathroom_cabinet', 'table']  Task:Shut front door  response:

{  Close the storm door. Lock the storm door. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'window', 'clothes_socks', 'couch', 'pillow', 'towel', 'broom', 'wall', 'bench', 'oven', 'toy', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'food_onion', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'scrabble']  Task:Relax on sofa  response:  {       thoughts : Walk to living room. Find couch. Sit on couch,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['tablelamp', 'juice', 'food_ice_cream', 'chair', 'walllamp', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'mousepad', 'clothes_hat', 'towel', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'shoes', 'door', 'bathroom_cabinet']  Task:Put in chair  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'floor', 'character', 'bookshelf', 'computer', 'toaster', 'mat', 'plate', 'window', 'food_noodles', 'food_orange', 'wall', 'oven', 'photoframe', 'keys', 'bed', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'clothes_dress', 'napkin', 'home_office', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['sponge', 'band-aids', 'toothbrush', 'orchid', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'faucet', 'picture', 'shower', 'mousepad', 'candle', 'food_orange', 'oven', 'basket_for_clothes', 'bed', 'check', 'food_food', 'television', 'tray', 'after_shave', 'headset', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'bathroom_cabinet']  Task:Sit in chair  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'filing_cabinet', 'microwave', 'freezer', 'detergent', 'drawing', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'ceilinglamp', 'iron', 'faucet', 'window', 'homework', 'bowl', 'wall', 'wall_clock', 'bench', 'shelf', 'newspaper', 'mouthwash', 'food_donut', 'doorjamb', 'coffee_pot', 'door', 'sink', 'bathroom_cabinet', 'light', 'board_game']  Task:Turn light off  response:  {       thoughts : Put the light switch into the down, or off, position.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'blow_dryer', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'picture', 'iron', 'mousepad', 'bowl', 'wall', 'powersocket', 'bench', 'photoframe', 'toilet_paper', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'dishrack', 'sink', 'bathroom_cabinet', 'home_office', 'light']  Task:Get toilet paper  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['crayon', 'trashcan', 'orchid', 'cpuscreen', 'ceiling', 'bedroom', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bench', 'bed', 'novel', 'food_food', 'mouthwash', 'coffe_maker', 'oven_mitts', 'curtain', 'doorjamb', 'cards', 'dresser', 'cupboard', 'bathtub', 'home_office', 'light']  Task:Read book  response:  {       thoughts : Go to the book shelf, get a book, open the book and read the book.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['spectacles', 'pot', 'sheets', 'walllamp', 'knifeblock', 'drawing', 'orchid', 'floor', 'bedroom', 'mail', 'food_bacon', 'laptop', 'mat', 'plate', 'faucet', 'food_orange', 'pillow', 'wall', 'bench', 'box', 'bed', 'photoframe', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'tooth_paste']  Task:Bring dirty plate to sink  response:

{  Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'freezer', 'ground_coffee', 'cpuscreen', 'floor', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'food_orange', 'bowl', 'wall', 'wall_clock', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'water', 'doorjamb', 'pencil', 'kitchen_counter', 'hair', 'controller', 'sink', 'soap']  Task:Make coffee  response:  {       thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['sponge', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'bathroom_counter', 'ceiling', 'phone', 'stamp', 'keyboard', 'thread', 'computer', 'stovefan', 'toaster', 'plate', 'shower', 'mousepad', 'form', 'wall', 'food_cheese', 'bed', 'console', 'headset', 'dresser', 'spoon', 'bathroom_cabinet', 'bag']  Task:Walk to room  response:

{  Leave the living room and enter the hall }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'freezer', 'bathroom', 'detergent', 'bathroom_counter', 'floor', 'bedroom', 'toaster', 'plate', 'shower', 'dining_room', 'nightstand', 'oven', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'kitchen_counter', 'dresser', 'door', 'sink', 'bathtub', 'home_office', 'table', 'dishwasher', 'soap', 'board_game']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['juice', 'beer', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'folder', 'keyboard', 'computer', 'ceilinglamp', 'window', 'mousepad', 'couch', 'pillow', 'bowl', 'food_kiwi', 'wall', 'powersocket', 'food_food', 'curtain', 'doorjamb', 'mouse', 'door', 'light', 'table']  Task:Drink  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'toilet', 'chair', 'bathroom', 'drawing', 'knife', 'clothes_underwear', 'floor', 'mail', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'plate', 'deck_of_cards', 'toaster', 'oil', 'wall', 'wall_clock', 'oven', 'cup', 'novel', 'food_food', 'television', 'oven_mitts', 'cards', 'cupboard', 'conditioner', 'table']  Task:Eat dinner  response:  {       thoughts : Sit down at the dinning table with my family and eat dinner.,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[GRAB] <food_food>', '[FIND] <plate>', '[PUTBACK] <food_food> <plate>', '[GRAB] <food_food>', '[PUTOBJBACK] <food_food>', '[FIND] <fork>', '[GRAB] <fork>', '[EAT] <plate>']  }     Scene_Objects:['chair', 'ground_coffee', 'bathroom', 'detergent', 'dough', 'knifeblock', 'drawing', 'food_egg', 'floor', 'bedroom', 'keyboard', 'purse', 'mop_bucket', 'stovefan', 'mousepad', 'food_orange', 'bed', 'check', 'toilet_paper', 'food_rice', 'tray', 'shaving_cream', 'mouse', 'cd', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'clothes_skirt', 'creditcard']  Task:Turn on light  response:

{  Twist the lamp switch until the light goes on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'toilet', 'detergent', 'hanger', 'floor', 'phone', 'stamp', 'toaster', 'balanceball', 'oil', 'pillow', 'dining_room', 'wall_clock', 'toy', 'newspaper', 'keys', 'photoframe', 'food_food', 'clothes_gloves', 'rag', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'cupboard', 'hairdryer', 'spoon', 'table', 'light', 'scrabble']  Task:Pet cat  response:  {       thoughts : Pet Cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['dry_pasta', 'pot', 'jelly', 'freezer', 'bathroom', 'trashcan', 'milk', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'form', 'powersocket', 'bench', 'bed', 'food_food', 'kitchen_counter', 'headset', 'vacuum_cleaner', 'cupboard', 'door', 'clothes_scarf', 'food_steak', 'soap']  Task:Grab things  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bills', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'mouse', 'shoes', 'comb', 'door', 'light']  Task:Check email  response:  {       thoughts : Turn on laptop.  Connect to Internet.  Type in the url.  Check for new email messages.,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>']  }     Scene_Objects:['dry_pasta', 'tablelamp', 'food_salt', 'chair', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'food_noodles', 'garbage_can', 'mousepad', 'microphone', 'wall', 'nightstand', 'food_vegetable', 'bed', 'food_food', 'coffee_filter', 'mouse', 'sink', 'home_office', 'table', 'dishwasher', 'pantry']  Task:Organize pantry  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'filing_cabinet', 'scissors', 'microwave', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'desk', 'bookshelf', 'purse', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'nightstand', 'child', 'cup', 'television', 'curtain', 'centerpiece', 'food_steak', 'hairdryer', 'table', 'vase']  Task:Watch TV  response:  {       thoughts : Turn on tv.  Sit with kids.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['tablelamp', 'juice', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'picture', 'homework', 'mousepad', 'wall', 'oven', 'toy', 'newspaper', 'check', 'television', 'mouse', 'laundry_detergent', 'conditioner', 'laser_pointer']  Task:Push in desk chair  response:

{  Push the desk chair until it is under the desk. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'food_salt', 'chair', 'detergent', 'trashcan', 'dough', 'drawing', 'character', 'computer', 'button', 'brush', 'mat', 'couch', 'clothes_pants', 'clothes_hat', 'wall', 'nightstand', 'basket_for_clothes', 'food_cheese', 'rag', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'laundry_detergent', 'conditioner', 'sink', 'home_office', 'table', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'juice', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'shower', 'faucet', 'window', 'mousepad', 'food_orange', 'wall', 'television', 'curtain', 'after_shave', 'mouse', 'dresser', 'door', 'napkin', 'table']  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:['pot', 'microwave', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'character', 'stamp', 'keyboard', 'toaster', 'plate', 'faucet', 'tvstand', 'bowl', 'wall', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'curtain', 'shaving_cream', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the kitchen. Open the dishwasher and turn on the faucet. Rinse off the dishes. Put the dishes in the dishwasher. Put detergent in the dishwasher. Close the dishwasher. Switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <detergent>', '[GRAB] <detergent>', '[PUTBACK] <detergent> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'mat', 'laptop', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'oven_mitts', 'kettle', 'mouse', 'cd', 'door', 'hairdryer', 'napkin', 'sink', 'table', 'light']  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:['food_pizza', 'tablelamp', 'toilet', 'chair', 'detergent', 'trashcan', 'orchid', 'floor', 'ceiling', 'stamp', 'man', 'bookshelf', 'purse', 'toaster', 'mat', 'oil', 'mousepad', 'nightstand', 'cup', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'mouse', 'headset', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']  Task:Answer door  response:  {       thoughts : Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined.,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'measuring_cup', 'toilet', 'jelly', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'alcohol', 'mat', 'shower', 'foundation', 'electric_shaver', 'mousepad', 'wall', 'toy', 'basket_for_clothes', 'photoframe', 'wine', 'dresser', 'laundry_detergent', 'food_steak', 'door', 'napkin', 'bathroom_cabinet', 'dishwasher']  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:['dog', 'food_egg', 'bathroom_counter', 'folder', 'bedroom', 'computer', 'table_cloth', 'piano_bench', 'stovefan', 'tvstand', 'faucet', 'foundation', 'homework', 'couch', 'nightstand', 'powersocket', 'oven', 'basket_for_clothes', 'cup', 'keys', 'food_food', 'mouthwash', 'after_shave', 'doorjamb', 'shoes', 'controller', 'maindoor', 'bag', 'dirt', 'coffee']  Task:Get ready to leave  response:  {       thoughts : Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave,       actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <keys>', '[GRAB] <keys>']  }     Scene_Objects:['dry_pasta', 'food_ice_cream', 'walllamp', 'nail_polish', 'cat', 'orchid', 'drawing', 'floor', 'ceiling', 'purse', 'alcohol', 'mail', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'towel', 'wall', 'oven', 'cup', 'food_cheese', 'television', 'curtain', 'doorjamb', 'door', 'table', 'clothes_shirt']  Task:Straighten paintings on wall  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'window', 'tvstand', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'water', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'light', 'table']  Task:Drink  response:  {       thoughts : Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.,       actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']  }     Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'toilet', 'chair', 'bathroom', 'food_carrot', 'cpuscreen', 'shampoo', 'phone', 'ceiling', 'bedroom', 'desk', 'computer', 'toaster', 'shower', 'foundation', 'dustpan', 'photoframe', 'coffe_maker', 'food_rice', 'tray', 'curtain', 'doorjamb', 'console', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher', 'creditcard']  Task:Put umbrella away  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['juice', 'toilet', 'chair', 'freezer', 'detergent', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'bedroom', 'piano_bench', 'ceilinglamp', 'mat', 'shower', 'faucet', 'oil', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'check', 'doorjamb', 'vacuum_cleaner', 'door', 'table', 'light']  Task:Put groceries in Fridge  response:  {       thoughts : Put the groceries on the table into the fridge,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTBACK] <food_chicken> <freezer>', '[CLOSE] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_carrot> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'crayon', 'cat', 'food_butter', 'trashcan', 'bathroom_counter', 'floor', 'folder', 'mail', 'tvstand', 'window', 'mousepad', 'towel', 'wall', 'nightstand', 'bench', 'toy', 'basket_for_clothes', 'cup', 'food_cheese', 'light_bulb', 'food_food', 'television', 'curtain', 'shoes', 'dresser', 'door', 'sink']  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:['fork', 'filing_cabinet', 'food_pizza', 'knifeblock', 'food_egg', 'hanger', 'phone', 'desk', 'tea_bag', 'purse', 'envelope', 'clothes_jacket', 'table_cloth', 'faucet', 'window', 'closetdrawer', 'clothes_pants', 'food_jam', 'wall', 'basket_for_clothes', 'bed', 'cd', 'comb', 'laundry_detergent', 'clothes_scarf', 'napkin', 'home_office', 'bathroom_cabinet', 'washing_machine', 'teeth']  Task:Wash clothes  response:  {       thoughts : Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[PLUGIN] <washing_machine>']  }     Scene_Objects:['beer', 'chair', 'band-aids', 'walllamp', 'bathroom', 'detergent', 'food_carrot', 'drawing', 'floor', 'ceiling', 'mat', 'faucet', 'mousepad', 'food_noodles', 'couch', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'novel', 'television', 'coffee_filter', 'tray', 'diary', 'mouse', 'pencil', 'cd', 'chessboard', 'bathroom_cabinet', 'creditcard']  Task:Wipe down baseboards please  response:

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