Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'laundry_detergent', 'door', 'table', 'light', 'soap']  Task:Watch TV  response:  {       thoughts : turn tv on, watch TV,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['microwave', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'faucet', 'shower', 'window', 'towel', 'wall', 'newspaper', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'hands_both']  Task:Wash hands  response:

{  I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'chair', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'plate', 'shower', 'iron', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'oven', 'basket_for_clothes', 'coffe_maker', 'check', 'tray', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'dishwasher', 'board_game', 'dirt']  Task:Wash dishes with dishwasher  response:  {       thoughts : I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet..,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>', '[GRAB] <plate>', '[WIPE] <plate>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[PUTOBJBACK] <dishrack>']  }     Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'laundry_detergent', 'door', 'table', 'light', 'soap']  Task:Watch TV  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_bread', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'desk', 'food_cake', 'stovefan', 'ceilinglamp', 'toaster', 'food_orange', 'wall', 'pasta', 'oven', 'tape', 'tray', 'wooden_spoon', 'centerpiece', 'kitchen_counter', 'cupboard', 'napkin', 'dishwasher', 'clothes_shirt']  Task:Cook some food  response:  {       thoughts : Walk into the kitchen. Open the fridge. Take out the chicken. Open the kitchen cabinet. Take out the frying pan. Put the chicken in the frying pan. Put the frying pan on the stove. Turn on the stove. Cook the chicken.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[CLOSE] <freezer>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>', '[SWITCHON] <oven>']  }     Scene_Objects:['glue', 'tablelamp', 'drawing', 'knife', 'wallshelf', 'orchid', 'floor', 'bookshelf', 'mail', 'mat', 'tvstand', 'shower', 'window', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'food_food', 'coffe_maker', 'food_rice', 'tray', 'shoes', 'door', 'clothes_scarf', 'bathtub', 'bathroom_cabinet', 'light']  Task:Read book  response:

{  I would go lie down in my bed and open the book and start reading. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'trashcan', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'stereo', 'window', 'couch', 'dining_room', 'nightstand', 'wall', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'bathtub', 'bathroom_cabinet', 'home_office', 'dishwasher', 'table']  Task:Pick up phone  response:  {       thoughts : walk into room, grab phone,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['pot', 'food_bread', 'microwave', 'chair', 'knifeblock', 'drawing', 'keyboard', 'button', 'stovefan', 'toaster', 'shower', 'window', 'dustpan', 'pillow', 'dining_room', 'nightstand', 'tape', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'doorjamb', 'kitchen_counter', 'cupboard', 'clothes_dress', 'sink', 'bathroom_cabinet', 'light', 'dishwasher']  Task:Browse internet  response:

{  I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'nail_polish', 'food_carrot', 'drawing', 'knife', 'floor', 'ceiling', 'desk', 'mat', 'stereo', 'shower', 'clothes_socks', 'candle', 'pillow', 'dining_room', 'nightstand', 'bench', 'newspaper', 'check', 'video_game_controller', 'doorjamb', 'cards', 'chessboard', 'pajamas', 'clothes_dress', 'table', 'light', 'board_game', 'laser_pointer', 'coffee']  Task:Play games  response:  {       thoughts : I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours.,       actions : ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'bathroom', 'cat', 'milk', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'bookshelf', 'computer', 'plate', 'stereo', 'clothes_pants', 'pillow', 'oven', 'food_food', 'razor', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'shoes', 'dresser', 'cupboard', 'bathtub', 'light', 'dishwasher', 'laser_pointer']  Task:Give milk to cat  response:

{  Grab milk and pour it into the plate so that the cat can drink }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'chair', 'freezer', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'tvstand', 'shoe-shine_kit', 'faucet', 'window', 'mousepad', 'couch', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'towel_rack', 'sink', 'light', 'laser_pointer']  Task:Gaze out window  response:  {       thoughts : Look at the yard from the window,       actions : ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']  }     Scene_Objects:['glue', 'food_ice_cream', 'tea', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'dining_room', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'cupboard', 'light', 'dishwasher']  Task:Change TV channel  response:

{  Walk to the living room. Find the television. Switch on the television. Find the remote control. Grab the remote control. Point at television. Find the button. Push button. }


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

{  Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'tablelamp', 'crayon', 'tea', 'mop', 'ground_coffee', 'detergent', 'drawing', 'floor', 'phone', 'ceilinglamp', 'laptop', 'shower', 'iron', 'window', 'oil', 'couch', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'toilet_paper', 'television', 'door', 'sink', 'table', 'scrabble', 'dirt']  Task:Read book  response:  {       thoughts : Bring book, lie on the sofa, read book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>']  }     Scene_Objects:['fork', 'filing_cabinet', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'tvstand', 'shower', 'faucet', 'towel', 'wall', 'cup', 'keys', 'food_food', 'television', 'water', 'curtain', 'lighter', 'kitchen_counter', 'shoes', 'door', 'table', 'light', 'soap', 'teeth']  Task:Take shower  response:

{  go to a bathroom, open the shower, let water wash your body }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']  Task:Take shower  response:  {       thoughts : go to a bathroom, open the shower, let water wash your body,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']  }     Scene_Objects:['sponge', 'filing_cabinet', 'toilet', 'chair', 'knife', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'bookmark', 'plate', 'towel', 'pillow', 'photoframe', 'novel', 'coffe_maker', 'check', 'coffee_filter', 'curtain', 'doorjamb', 'towel_rack', 'sink', 'home_office', 'table', 'soap', 'teeth']  Task:Wash hands  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt']  Task:Get dressed  response:  {       thoughts : Get some clothes together that make an appropriate outfit.  Put them on,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'bathroom_counter', 'shampoo', 'floor', 'bookshelf', 'food_cake', 'mail', 'stovefan', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'wall', 'photoframe', 'toothbrush_holder', 'towel_rack', 'pencil', 'door', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'tooth_paste', 'coffee']  Task:Brush teeth  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:['ground_coffee', 'nail_polish', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'button', 'mail', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'tape', 'television', 'curtain', 'food_onion', 'cupboard', 'table', 'shoe_rack']  Task:Watch TV  response:  {       thoughts : Go to the living room, sit on the couch, find the remote, switch on the TV and watch,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'chair', 'bathroom', 'orchid', 'knifeblock', 'floor', 'phone', 'desk', 'keyboard', 'food_cake', 'foundation', 'floor_lamp', 'pillow', 'nightstand', 'powersocket', 'box', 'basket_for_clothes', 'razor', 'tray', 'doorjamb', 'cupboard', 'bathtub', 'spoon', 'home_office', 'table', 'bathroom_cabinet', 'light', 'dishwasher']  Task:Turn on light  response:

{  walk to living room, find lamp, switch 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:['food_bread', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'toaster', 'ceilinglamp', 'window', 'homework', 'food_noodles', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'powersocket', 'toy', 'food_food', 'toilet_paper', 'tray', 'curtain', 'food_onion', 'shoes', 'door', 'table']  Task:Relax on sofa  response:  {       thoughts : Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['fork', 'measuring_cup', 'walllamp', 'knifeblock', 'knife', 'drawing', 'floor', 'ceiling', 'character', 'toaster', 'mat', 'plate', 'shower', 'dish_soap', 'clothes_socks', 'wall', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dishrack', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'bathtub']  Task:Wash dishes with dishwasher  response:

{  put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser 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:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt']  Task:Get dressed  response:  {       thoughts : Get some clothes together that make an appropriate outfit.  Put them on,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']  }     Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table']  Task:Change TV channel  response:

{  Walk into living room. Find television remote control. Pick up remote control. Press button. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'food_carrot', 'woman', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'child', 'bed', 'television', 'curtain', 'towel_rack', 'dresser', 'table']  Task:Watch movie  response:  {       thoughts : Sitting and watching  a movie with family,       actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TURNTO] <child>', '[LOOKAT] <child>', '[GREET] <child>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']  }     Scene_Objects:['water_glass', 'pot', 'juice', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'cpuscreen', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'dining_room', 'wall', 'nightstand', 'oven', 'photoframe', 'novel', 'water', 'kitchen_counter', 'cupboard', 'hairdryer', 'sink', 'door']  Task:Drink  response:

{  Opening the kitchen cabinet to grab water glass and pour water from the faucet into it to drink. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Pay bills  response:  {       thoughts : Check my bills, on the computer, open the appropriate sites, pay my due bills,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'light', 'table']  Task:Watch TV  response:

{  walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table']  Task:Draft home  response:  {       thoughts : Using mathematics and CAD software design a home,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']  Task:Watch TV  response:

{  I come home and go to the sofa for turn off the tv and relax }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', '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:  {       thoughts : Turn on radio, put on favorite channel, listen to music.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[LIE] <bed>']  }     Scene_Objects:['mop', 'microwave', 'cd_player', 'walllamp', 'drawing', 'orchid', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'button', 'piano_bench', 'stovefan', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'ice', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'table', 'light']  Task:Listen to music  response:

{  Walk to living room, walk to cd player, turn on cd player, press play button, walk to sofa, sit in sofa and 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:['scissors', 'freezer', 'walllamp', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'bookshelf', 'keyboard', 'ceilinglamp', 'plate', 'stereo', 'clothes_socks', 'clothes_pants', 'pillow', 'bowl', 'powersocket', 'cutting_board', 'basket_for_clothes', 'razor', 'coin', 'wine', 'curtain', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'laundry_detergent', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'cup', 'television', 'doorjamb', 'mouse', 'shoes', 'door', 'sink', 'napkin', 'clothes_scarf', 'table', 'light', 'dishwasher', 'colander']  Task:Relax on sofa  response:

{  walk to living room ,find sofa ,sit on sofa }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'dough', 'woman', 'knifeblock', 'bathroom_counter', 'floor', 'character', 'desk', 'tea_bag', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'wall', 'child', 'coffe_maker', 'video_game_controller', 'television', 'towel_rack', 'kettle', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'instrument_violin', 'clothes_shirt']  Task:Greet guests  response:  {       thoughts : Go to the kitchen, greet your family members,       actions : ['[WALK] <dining_room>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <chair>', '[SIT] <chair>']  }     Scene_Objects:['beer', 'bathroom', 'orchid', 'knifeblock', 'food_egg', 'clothes_underwear', 'shampoo', 'bedroom', 'tvstand', 'shoe-shine_kit', 'pillow', 'dining_room', 'bench', 'powersocket', 'coffe_maker', 'video_game_controller', 'television', 'food_rice', 'tray', 'after_shave', 'food_onion', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'comb', 'cupboard', 'bathroom_cabinet', 'light', 'tooth_paste']  Task:Turn on light  response:

{  I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'tea', 'walllamp', 'cat', 'trashcan', 'food_butter', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'shower', 'closetdrawer', 'couch', 'dining_room', 'oven', 'bench', 'bed', 'food_food', 'television', 'food_onion', 'doorjamb', 'cupboard', 'sink', 'bathtub', 'soap', 'laser_pointer']  Task:Walk to room  response:  {       thoughts : Leave the living room and enter the hall,       actions : ['[WALK] <home_office>', '[WALK] <home_office>']  }     Scene_Objects:['toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'floor', 'bedroom', 'keyboard', 'stovefan', 'tvstand', 'homework', 'window', 'microphone', 'food_orange', 'pillow', 'dining_room', 'powersocket', 'bench', 'newspaper', 'bed', 'coffe_maker', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'spoon', 'home_office', 'bathroom_cabinet']  Task:Pick up phone  response:

{  Enter the Home office, then walk to the phone, pickup the phone. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap']  Task:Read book  response:  {       thoughts : Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']  }     Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'clothes_underwear', 'floor', 'ceiling', 'thread', 'computer', 'bookmark', 'toaster', 'stovefan', 'couch', 'wall', 'powersocket', 'cup', 'food_food', 'razor', 'water', 'tray', 'centerpiece', 'pencil', 'kitchen_counter', 'chessboard', 'cupboard', 'clothes_scarf', 'light', 'table', 'dishwasher']  Task:Drink  response:

{  Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar']  Task:Turn on light  response:  {       thoughts : I walk into the living room and then I walk to the light switch in there and turn the lights on,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'towel_rack', 'door', 'light', 'table']  Task:Watch TV  response:

{  Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'tea_bag', 'keyboard', 'food_bacon', 'stovefan', 'tvstand', 'faucet', 'couch', 'microphone', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'mouse', 'door', 'bathtub', 'sink', 'table', 'light', 'dishwasher']  Task:Relax on sofa  response:  {       thoughts : Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'food_bread', 'tablelamp', 'juice', 'cd_player', 'band-aids', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'homework', 'food_orange', 'nightstand', 'bench', 'bed', 'newspaper', 'photoframe', 'coffe_maker', 'check', 'food_onion', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathtub', 'light']  Task:Listen to music  response:

{  I walk in the living room, then I go the the stereo and the cd player and turn them on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'shoe_rack', 'food_salt', 'beer', 'measuring_cup', 'microwave', 'trashcan', 'food_carrot', 'orchid', 'drawing', 'bookshelf', 'envelope', 'alcohol', 'ceilinglamp', 'plate', 'food_jam', 'pillow', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'lighter', 'doorjamb', 'coffee_pot', 'towel_rack', 'cupboard', 'hairdryer', 'creditcard']  Task:Pet cat  response:  {       thoughts : find a cat, touch it gently,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'deck_of_cards', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'box', 'cup', 'toilet_paper', 'rag', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'bathtub', 'table', 'home_office']  Task:Drink  response:

{  I walk the kitchen and walk up to the kitchen cabinet. I open the cabinet and take out a cup. I walk to sink and I turn the faucet on using the cold water handle. I put my cup under the running water until it is full. I turn off the cold water handle and bring the cup to my mouth and take a drink. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'toilet', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'keyboard', 'tvstand', 'stereo', 'balanceball', 'picture', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'bed', 'toilet_paper', 'coffe_maker', 'cards', 'mouse', 'kitchen_counter', 'cd', 'vase']  Task:Go to toilet  response:  {       thoughts : Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'window', 'pillow', 'wall', 'powersocket', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bathtub', 'light', 'teeth', 'shoe_rack']  Task:Go to toilet  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'fork', 'filing_cabinet', 'toilet', 'detergent', 'food_butter', 'orchid', 'needle', 'bills', 'stereo', 'window', 'dining_room', 'bench', 'oven', 'bed', 'novel', 'check', 'coffee_filter', 'tray', 'wooden_spoon', 'centerpiece', 'headset', 'conditioner', 'food_steak', 'napkin', 'home_office', 'soap', 'scrabble', 'dirt', 'coffee']  Task:File documents  response:  {       thoughts : I file all of my paperwork (including bills, receipts, documents, device instructions, etc.) in my black paperwork case that has many different files in order to organize.  I place each piece of paper in its' corresponding subject (as indicated by printed words on each tab).,       actions : ['[WALK] <home_office>', '[WALK] <bills>', '[FIND] <bills>', '[GRAB] <bills>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTIN] <bills> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>']  }     Scene_Objects:['water_glass', 'tablelamp', 'juice', 'food_ice_cream', 'measuring_cup', 'chair', 'freezer', 'nail_polish', 'detergent', 'food_carrot', 'toothbrush', 'drawing', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'bookmark', 'toaster', 'couch', 'wall', 'keys', 'toilet_paper', 'television', 'kitchen_counter', 'headset', 'cupboard', 'door', 'home_office', 'light']  Task:Drink  response:

{  walk to kitchen ,find fridge ,open fridge ,find water  glass , drink from water 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:['fork', 'microwave', 'freezer', 'knife', 'food_egg', 'wallshelf', 'kitchen_cabinet', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'stovefan', 'plate', 'faucet', 'shower', 'mat', 'wall', 'oven', 'bench', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'napkin', 'dishwasher']  Task:Unload dishwasher  response:  {       thoughts : Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <drinking_glass> <cupboard>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <fork> <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTIN] <knife> <kitchen_cabinet>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTIN] <spoon> <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>']  }     Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'conditioner', 'door', 'table', 'light']  Task:Relax on sofa  response:

{  For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'toilet', 'jelly', 'freezer', 'walllamp', 'bathroom', 'hanger', 'folder', 'bedroom', 'desk', 'tvstand', 'window', 'food_jam', 'microphone', 'dining_room', 'wall_clock', 'powersocket', 'bench', 'shelf', 'bed', 'video_game_controller', 'food_donut', 'water', 'doorjamb', 'cards', 'towel_rack', 'mouse', 'sink', 'colander', 'hands_both']  Task:Wash hands  response:  {       thoughts : walk to bathroom, look at the water, wash hands,       actions : ['[WALK] <bathroom>', '[WALK] <water>', '[FIND] <water>', '[TURNTO] <water>', '[LOOKAT] <water>', '[FIND] <hands_both>', '[WASH] <hands_both>']  }     Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'trashcan', 'orchid', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'faucet', 'couch', 'clothes_pants', 'form', 'wall', 'cutting_board', 'photoframe', 'check', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:

{  Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_salt', 'toilet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'bowl', 'wall', 'television', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'light', 'table', 'board_game']  Task:Write an email  response:  {       thoughts : Turn on PC and log onto email account. Type email and send it. Switch off computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'window', 'clothes_hat', 'dining_room', 'wall', 'bench', 'powersocket', 'photoframe', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'table', 'light', 'tooth_paste']  Task:Pick up phone  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'mop', 'microwave', 'toilet', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'piano_bench', 'ceilinglamp', 'plate', 'deck_of_cards', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'bed', 'novel', 'television', 'doorjamb', 'door', 'coffee_cup', 'table', 'light']  Task:Relax on sofa  response:  {       thoughts : you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']  }     Scene_Objects:['food_salt', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'stovefan', 'tvstand', 'food_peanut_butter', 'nightstand', 'wall', 'oven', 'powersocket', 'coffe_maker', 'toothbrush_holder', 'after_shave', 'curtain', 'coffee_pot', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'bathtub', 'sink', 'home_office', 'dishwasher', 'tooth_paste']  Task:Brush teeth  response:

{  today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth 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:['tablelamp', 'juice', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'balanceball', 'mat', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'light', 'dishwasher']  Task:Work  response:  {       thoughts : Go to office, sit at desk, turn on computer, enter password, open application and begin work,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['pot', 'tablelamp', 'blender', 'microwave', 'toilet', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'keyboard', 'computer', 'brush', 'mat', 'laptop', 'faucet', 'ceilinglamp', 'window', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'towel_rack', 'mouse', 'kitchen_counter', 'pajamas', 'dishwasher']  Task:Go to sleep  response:

{  go to bedroom, put pajamas on, lie in bed, sleep }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'walllamp', 'detergent', 'orchid', 'drawing', 'cpuscreen', 'keyboard', 'envelope', 'computer', 'stovefan', 'faucet', 'electric_shaver', 'couch', 'candle', 'microphone', 'broom', 'nightstand', 'oven', 'bench', 'tape', 'cup', 'light_bulb', 'food_rice', 'wine', 'wooden_spoon', 'hair', 'maindoor', 'table', 'dishwasher', 'vase']  Task:Dust  response:  {       thoughts : Get a broom or duster with long handle. Dust blades of ceiling fan.,       actions : ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>']  }     Scene_Objects:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin']  Task:Wash dishes with dishwasher  response:

{  I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'blow_dryer', 'walllamp', 'nail_polish', 'bathroom', 'toothbrush', 'drawing', 'hanger', 'floor', 'shampoo', 'character', 'desk', 'bookshelf', 'purse', 'envelope', 'mat', 'ceilinglamp', 'window', 'towel', 'wall', 'powersocket', 'toy', 'cup', 'food_food', 'coffe_maker', 'sink', 'duster']  Task:Dust  response:  {       thoughts : Apply duster to shelves and clean them until dust is gone,       actions : ['[WALK] <home_office>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[FIND] <filing_cabinet>', '[WIPE] <filing_cabinet>', '[PUTOBJBACK] <duster>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'knife', 'knifeblock', 'orchid', 'drawing', 'floor', 'phone', 'character', 'bedroom', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'dining_room', 'powersocket', 'newspaper', 'ice', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'home_office', 'table']  Task:Change TV channel  response:

{  I pick up the remote. I press button on remote. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'piano_bench', 'stovefan', 'ceilinglamp', 'faucet', 'electric_shaver', 'window', 'teeth', 'food_orange', 'pillow', 'wall', 'powersocket', 'food_food', 'tray', 'curtain', 'dresser', 'hair', 'controller', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off.,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['microwave', 'walllamp', 'orchid', 'ceiling', 'desk', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'form', 'dining_room', 'oven', 'basket_for_clothes', 'keys', 'novel', 'food_food', 'coffe_maker', 'food_rice', 'tray', 'doorjamb', 'cards', 'mouse', 'pajamas', 'home_office', 'light', 'bathroom_cabinet']  Task:Listen to music  response:

{  Find the playback device you want to listen to. turn on. press play. enjoyu 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:['food_salt', 'microwave', 'detergent', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'shoe-shine_kit', 'faucet', 'clothes_socks', 'closetdrawer', 'mousepad', 'dining_room', 'broom', 'wall', 'nightstand', 'photoframe', 'television', 'water', 'tray', 'cards', 'paper_towel', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <water>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>']  }     Scene_Objects:['walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'pencil', 'dresser', 'cupboard', 'hair', 'light', 'table']  Task:Change TV channel  response:

{  Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table']  Task:Watch TV  response:  {       thoughts : I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'tooth_paste']  Task:Watch TV  response:

{  I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'table_cloth', 'stovefan', 'mat', 'faucet', 'foundation', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'toy', 'hands_both', 'tray', 'doorjamb', 'towel_rack', 'shaving_cream', 'door', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'teeth']  Task:Wash teeth  response:  {       thoughts : I need to rinse my dentures off and put them back in my mouth.,       actions : ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[GRAB] <teeth>', '[WASH] <teeth>', '[PUTOBJBACK] <teeth>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <towel>', '[SWITCHOFF] <light>']  }     Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'tvstand', 'faucet', 'stereo', 'window', 'couch', 'form', 'wall', 'powersocket', 'light_bulb', 'razor', 'vacuum_cleaner', 'controller', 'door', 'home_office', 'light', 'dishwasher', 'bathroom_cabinet', 'colander']  Task:Go to toilet  response:

{  I walk into the bath room and go to the toilet }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'chair', 'blow_dryer', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'stamp', 'keyboard', 'computer', 'food_bacon', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'coffe_maker', 'wooden_spoon', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'controller', 'light', 'soap']  Task:Vacuum  response:  {       thoughts : Plug in vacuum. Walk around with vacuum, covering all of the floor. Unplug vacuum.,       actions : ['[WALK] <bedroom>', '[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:['fork', 'spectacles', 'chair', 'freezer', 'walllamp', 'knife', 'wallshelf', 'floor', 'alcohol', 'bookmark', 'toaster', 'plate', 'candle', 'wall', 'nightstand', 'novel', 'coffe_maker', 'food_food', 'television', 'water', 'curtain', 'after_shave', 'diary', 'kitchen_counter', 'dresser', 'cupboard', 'bathtub', 'spoon', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'sheets', 'food_salt', 'tea', 'blow_dryer', 'wallshelf', 'ceiling', 'character', 'food_cake', 'computer', 'tvstand', 'window', 'mousepad', 'cutting_board', 'basket_for_clothes', 'cup', 'newspaper', 'light_bulb', 'novel', 'photoframe', 'coin', 'food_donut', 'rag', 'cards', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'maindoor', 'bag', 'creditcard']  Task:Clean  response:  {       thoughts : Clean the welcome mat,       actions : ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']  }     Scene_Objects:['fork', 'crayon', 'microwave', 'chair', 'cloth_napkin', 'freezer', 'walllamp', 'drawing', 'knife', 'floor', 'phone', 'character', 'food_cake', 'mat', 'ceilinglamp', 'plate', 'window', 'mousepad', 'microphone', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'video_game_controller', 'doorjamb', 'controller', 'door', 'table', 'teeth']  Task:Set up table  response:

{  Walk to dining room, walk to dining table, arrange chairs, set napkin, set plate, set knife, set fork and glass on table. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'hanger', 'ceiling', 'bedroom', 'man', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'couch', 'food_jam', 'pillow', 'pasta', 'powersocket', 'coffe_maker', 'kettle', 'pencil', 'napkin', 'table', 'scrabble', 'creditcard']  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:['fork', 'microwave', 'nail_polish', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'dining_room', 'wall', 'tape', 'cup', 'bed', 'mouthwash', 'after_shave', 'dishrack', 'cupboard', 'door', 'sink', 'table', 'light', 'tooth_paste', 'clothes_shirt']  Task:Turn on light  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'desk', 'brush', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'coffee_filter', 'food_rice', 'doorjamb', 'towel_rack', 'dresser', 'clothes_dress', 'door', 'light', 'table']  Task:Change clothes  response:  {       thoughts : Switch your clothes.,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[CLOSE] <dresser>']  }     Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']  Task:Wash clothes  response:

{  Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'toaster', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'cup', 'photoframe', 'coffee_table', 'novel', 'television', 'doorjamb', 'shoes', 'comb', 'dresser', 'instrument_violin']  Task:Watch TV  response:  {       thoughts : I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['blender', 'mop', 'walllamp', 'trashcan', 'wallshelf', 'floor', 'ceiling', 'folder', 'bedroom', 'tvstand', 'shower', 'foundation', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'television', 'food_donut', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']  Task:Take shower  response:

{  Walk to the bathroom and wash with the shower. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'food_noodles', 'form', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'keys', 'toothbrush_holder', 'rag', 'doorjamb', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'tooth_paste', 'teeth']  Task:Wash teeth  response:  {       thoughts : I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off.,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[PUTOBJBACK] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>', '[RINSE] <toothbrush>', '[PUTOBJBACK] <toothbrush>', '[RINSE] <teeth>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['toilet', 'detergent', 'knifeblock', 'knife', 'bills', 'clothes_underwear', 'shampoo', 'desk', 'piano_bench', 'toaster', 'ceilinglamp', 'window', 'food_peanut_butter', 'clothes_pants', 'clothes_hat', 'basket_for_clothes', 'bed', 'coffe_maker', 'tray', 'doorjamb', 'cards', 'mouse', 'dresser', 'clothes_dress', 'bathtub', 'table', 'dishwasher', 'soap', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  I need to get the dirty clothes basket.  Walk to bathroom.  Put all the clothes in washing machine.  Add soap.  Turn on machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']  Task:Greet guests  response:  {       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', 'tablelamp', 'food_salt', 'microwave', 'toilet', 'freezer', 'walllamp', 'blow_dryer', 'bathroom', 'orchid', 'knifeblock', 'drawing', 'desk', 'bedroom', 'bookshelf', 'mat', 'foundation', 'oil', 'pillow', 'dining_room', 'bench', 'oven', 'novel', 'mouthwash', 'television', 'kitchen_counter', 'shoes', 'controller', 'bathtub', 'home_office']  Task:Write an email  response:

{  Find the computer.  Turn on the computer.  Open the e-mail program.  Create a new message.  Write the message. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'food_pizza', 'filing_cabinet', 'toilet', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'folder', 'keyboard', 'faucet', 'iron', 'mousepad', 'pillow', 'dining_room', 'tape', 'cutting_board', 'cup', 'food_food', 'video_game_controller', 'food_rice', 'food_donut', 'rag', 'kettle', 'mouse', 'kitchen_counter', 'controller', 'food_steak', 'sink', 'dishwasher']  Task:Listen to music  response:  {       thoughts : I walk to the living room. I find a radio there and switch it on to listen to music.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['microwave', 'chair', 'detergent', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'alcohol', 'table_cloth', 'toaster', 'tvstand', 'shower', 'faucet', 'mousepad', 'clothes_hat', 'powersocket', 'oven', 'bench', 'box', 'photoframe', 'novel', 'coffe_maker', 'toilet_paper', 'doorjamb', 'mouse', 'cupboard', 'napkin', 'bathroom_cabinet']  Task:Pet cat  response:

{  I go looking for the cat in the living room where he usually sleeps. Once I find the cat I just pet him for a few minutes. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', 'printing_paper']  Task:Print out papers  response:  {       thoughts : Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,       actions : ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'toaster', 'plate', 'faucet', 'stereo', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bathtub', 'dishwasher', 'clothes_skirt', 'laser_pointer']  Task:Wash dishes with dishwasher  response:

{  Take a dish and put it in the dishwasher to be washed }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'sheets', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'orchid', 'needle', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'toaster', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'food_food', 'television', 'food_onion', 'doorjamb', 'pencil', 'door', 'home_office', 'table', 'light', 'coffee']  Task:Relax on sofa  response:  {       thoughts : Walk to the living room. Walk to the sofa and sit on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light']  Task:Watch TV  response:

{  I walk into my living room, find the remote and sit on my sofa. I look at the remote and switch on the television. I look at the Television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer']  Task:Read book  response:  {       thoughts : I would go lie down in my bed and open the book and start reading.,       actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['pot', 'filing_cabinet', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'pencil', 'door', 'light', 'table']  Task:Change TV channel  response:

{  I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'food_butter', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'button', 'table_cloth', 'stovefan', 'mat', 'brush', 'stereo', 'picture', 'mousepad', 'couch', 'clothes_pants', 'food_jam', 'powersocket', 'oven', 'newspaper', 'cards', 'shoes', 'controller', 'clothes_skirt', 'board_game']  Task:Listen to music  response:  {       thoughts : I go into the living room and turn on the radio.  Then, I select the station I want, which is usually a preset.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['filing_cabinet', 'bathroom', 'detergent', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'tvstand', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'food_food', 'coffe_maker', 'doorjamb', 'dresser', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light', 'home_office']  Task:Relax on sofa  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'beer', 'mop', 'chair', 'freezer', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'shower', 'window', 'food_orange', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'spoon', 'table', 'light', 'coffee']  Task:Put groceries in Fridge  response:  {       thoughts : I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'couch', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'lighter', 'dresser', 'sink', 'light']  Task:Change TV channel  response:

{  Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']  Task:Take shower  response:  {       thoughts : go to a bathroom, open the shower, let water wash your body,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']  }     Scene_Objects:['pot', 'tea', 'microwave', 'chair', 'freezer', 'band-aids', 'orchid', 'drawing', 'floor', 'ceiling', 'shampoo', 'alcohol', 'toaster', 'shower', 'mousepad', 'oil', 'couch', 'wall', 'nightstand', 'bench', 'cutting_board', 'tape', 'cup', 'food_donut', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard']  Task:Put groceries in Fridge  response:

{  Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste']  Task:Pet dog  response:  {       thoughts : Pet my dog in hall,       actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']  }     Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'walllamp', 'detergent', 'knifeblock', 'needle', 'character', 'bookmark', 'mat', 'ceilinglamp', 'faucet', 'pillow', 'powersocket', 'oven', 'tape', 'cutting_board', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt', 'dirt']  Task:Change TV channel  response:

{  I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'desk', 'envelope', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'oven_mitts', 'curtain', 'controller', 'home_office', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk into the living room. I cross the room to the couch. I sit down and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'filing_cabinet', 'ground_coffee', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'toaster', 'stovefan', 'iron', 'couch', 'form', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'hairdryer', 'bathtub', 'dishwasher', 'dirt']  Task:Make coffee  response:

{  I walk into the kitchen. I find the coffee maker and open it. I find the coffee filter, grab it and put it into the coffee maker. I find ground coffee, grab it and put it into the coffee maker. I find some water, then I pour it into the coffee maker. I close the coffee maker, I plug it in and I switch it on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'foundation', 'couch', 'microphone', 'wall', 'powersocket', 'oven', 'bed', 'television', 'wooden_spoon', 'doorjamb', 'lighter', 'dresser', 'door', 'table']  Task:Change TV channel  response:  {       thoughts : I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['spectacles', 'scissors', 'food_ice_cream', 'chair', 'orchid', 'drawing', 'bills', 'knifeblock', 'floor', 'character', 'alcohol', 'mat', 'window', 'couch', 'microphone', 'pillow', 'dining_room', 'wall', 'pasta', 'clothes_gloves', 'check', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'table', 'dishwasher', 'colander', 'coffee']  Task:Set up table  response:

{  walk to entrance hall. find a table. pull table. walk to living rook. push table. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth']  Task:Work  response:  {       thoughts : walk to home office ,find computer ,switch on computer and work,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['filing_cabinet', 'crayon', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'floor', 'ceiling', 'stamp', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'dish_soap', 'wall', 'nightstand', 'basket_for_clothes', 'keys', 'light_bulb', 'coffe_maker', 'novel', 'television', 'curtain', 'kitchen_counter', 'dishrack', 'cupboard', 'home_office', 'dishwasher', 'scrabble']  Task:Wash dishes with dishwasher  response:

{  Walk to the  kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher. }