Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', '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:  {       thoughts : walk to entrance hall. find a table. pull table. walk to living rook. push table.,       actions : ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[PULL] <table>', '[WALK] <home_office>', '[WALK] <table>', '[PUSH] <table>']  }     Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'mail', 'alcohol', 'toaster', 'ceilinglamp', 'balanceball', 'mousepad', 'food_orange', 'wall', 'nightstand', 'mouthwash', 'doorjamb', 'mouse', 'hairbrush', 'light']  Task:Write an email  response:

{  Turn on PC and log onto email account. Type email and send it. Switch off computer. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'juice', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'picture', 'homework', 'mousepad', 'wall', 'oven', 'toy', 'newspaper', 'check', 'television', 'mouse', 'laundry_detergent', 'conditioner', 'laser_pointer']  Task:Push in desk chair  response:  {       thoughts : Push the desk chair until it is under the desk.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[TOUCH] <chair>', '[PUSH] <chair>']  }     Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'novel', 'check', 'television', 'curtain', 'conditioner', 'hairdryer', 'clothes_dress', 'table']  Task:Watch TV  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'chair', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'door', 'shoe_rack']  Task:Put in chair  response:  {       thoughts : Take a comfortable chair. Place it in the entrance hall,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[GRAB] <chair>', '[WALK] <home_office>', '[WALK] <floor>', '[FIND] <floor>', '[PUTBACK] <chair> <floor>']  }     Scene_Objects:['dog', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'faucet', 'clothes_socks', 'microphone', 'wall', 'bench', 'powersocket', 'photoframe', 'food_rice', 'food_onion', 'towel_rack', 'cd', 'hairbrush', 'controller', 'maindoor', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', 'vase', 'soap', 'instrument_violin', 'laser_pointer', 'hands_both']  Task:Wash hands  response:

{  I go to bathroom, go to sink, turn the water on via faucet, grab soap, use the soap to scrub my hands, put the soap back and wash my hands. Then I stop the water with faucet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'filing_cabinet', 'crayon', 'walllamp', 'bathroom', 'toothbrush', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'faucet', 'electric_shaver', 'dish_soap', 'broom', 'wall', 'oven', 'bench', 'photoframe', 'light_bulb', 'novel', 'coffe_maker', 'television', 'tray', 'towel_rack', 'kettle', 'dishrack', 'table', 'dishwasher', 'tooth_paste']  Task:Wash dishes with dishwasher  response:  {       thoughts : Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['filing_cabinet', 'scissors', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'food_jam', 'wall', 'novel', 'television', 'curtain', 'doorjamb', 'comb', 'clothes_dress', 'sink', 'home_office', 'table']  Task:Change TV channel  response:

{  first i will go to living room and then take the remote and swtitch on television after that il 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:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'microphone', 'form', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'television', 'curtain', 'vacuum_cleaner', 'dishrack', 'dresser', 'hairbrush', 'door', 'table', 'soap']  Task:Watch TV  response:  {       thoughts : I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['sheets', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'mousepad', 'microphone', 'dining_room', 'nightstand', 'basket_for_clothes', 'bed', 'newspaper', 'coffe_maker', 'check', 'tray', 'curtain', 'doorjamb', 'mouse', 'headset', 'laundry_detergent', 'maindoor', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:

{  Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. 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:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'folder', 'desk', 'bookshelf', 'keyboard', 'thread', 'computer', 'mail', 'bookmark', 'mousepad', 'wall', 'nightstand', 'photoframe', 'novel', 'toilet_paper', 'tray', 'towel_rack', 'mouse', 'door', 'light']  Task:Read book  response:  {       thoughts : Walk to the living room. Find a desk and grab a book. Walk to the chair, sit in the chair and read a book.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['filing_cabinet', 'food_ice_cream', 'food_carrot', 'longboard', 'ceiling', 'stamp', 'food_cake', 'stovefan', 'mat', 'oil', 'food_peanut_butter', 'dining_room', 'broom', 'pasta', 'basket_for_clothes', 'bed', 'coffe_maker', 'television', 'razor', 'tray', 'after_shave', 'mouse', 'laundry_detergent', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'dishwasher', 'laser_pointer', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn 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:['jelly', 'freezer', 'dog', 'chair', 'nail_polish', 'bathroom', 'orchid', 'bills', 'food_egg', 'hanger', 'character', 'bedroom', 'thread', 'toaster', 'faucet', 'mousepad', 'oil', 'nightstand', 'cup', 'photoframe', 'standingmirror', 'bed', 'video_game_controller', 'wine', 'doorjamb', 'maindoor', 'bathtub', 'vase', 'clothes_shirt', 'coffee']  Task:Read book  response:  {       thoughts : pick up  the book open the book and read,       actions : ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['food_bread', 'filing_cabinet', 'mop', 'toilet', 'dog', 'freezer', 'longboard', 'floor', 'ceiling', 'purse', 'ceilinglamp', 'balanceball', 'faucet', 'foundation', 'food_jam', 'wall', 'oven', 'cup', 'bed', 'novel', 'food_food', 'coffe_maker', 'coffee_filter', 'curtain', 'console', 'pencil', 'maindoor', 'table', 'light', 'dirt']  Task:Put groceries in Fridge  response:

{  put away groceries in fridge. open the door, put on shelf, close the door. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'freezer', 'dough', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'mat', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'curtain', 'centerpiece', 'doorjamb', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bag', 'dishwasher']  Task:Put groceries in Fridge  response:  {       thoughts : walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>']  }     Scene_Objects:['freezer', 'detergent', 'dough', 'drawing', 'bills', 'clothes_underwear', 'floor', 'bedroom', 'keyboard', 'piano_bench', 'ceilinglamp', 'balanceball', 'picture', 'window', 'foundation', 'electric_shaver', 'couch', 'dustpan', 'food_kiwi', 'wall', 'keys', 'check', 'television', 'tray', 'rag', 'shoes', 'door', 'table', 'vase', 'coffee']  Task:Relax on sofa  response:

{  Relax on the sofa in the living room. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'food_bread', 'freezer', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'thread', 'alcohol', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'wall', 'oven', 'food_food', 'coffe_maker', 'toilet_paper', 'check', 'food_rice', 'tray', 'towel_rack', 'pencil', 'kitchen_counter', 'napkin', 'dishwasher', 'clothes_shirt']  Task:Put groceries in Fridge  response:  {       thoughts : Open the fridge, and put groceries in the fridge. Close the fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['juice', 'bills', 'hanger', 'shampoo', 'phone', 'dvd_player', 'character', 'alcohol', 'mat', 'stereo', 'clothes_socks', 'mousepad', 'wall', 'pasta', 'powersocket', 'tape', 'bed', 'novel', 'food_food', 'tray', 'coffee_pot', 'pencil', 'dishrack', 'cupboard', 'clothes_scarf', 'bathroom_cabinet', 'light', 'home_office', 'vase', 'scrabble']  Task:Pick up phone  response:

{  Walk into the home office. Pick up 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:['pot', 'measuring_cup', 'toilet', 'chair', 'band-aids', 'freezer', 'walllamp', 'food_carrot', 'toothbrush', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'button', 'mat', 'tvstand', 'faucet', 'mousepad', 'food_kiwi', 'wall', 'light_bulb', 'coffe_maker', 'toothbrush_holder', 'rag', 'pencil', 'sink', 'bathroom_cabinet', 'soap', 'tooth_paste', 'teeth']  Task:Brush teeth  response:  {       thoughts : getting ready for bed,       actions : ['[WALK] <bathroom_counter>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <toothbrush> <bathroom_counter>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[GRAB] <toothbrush>', '[SCRUB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <toothbrush_holder>', '[PUTBACK] <toothbrush> <toothbrush_holder>']  }     Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'detergent', 'orchid', 'bathroom_counter', 'character', 'keyboard', 'remote_control', 'bookshelf', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'dustpan', 'nightstand', 'bench', 'tape', 'cup', 'bed', 'coffee_table', 'wooden_spoon', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'hair']  Task:Change TV channel  response:

{  walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the 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:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'picture', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'light']  Task:Watch TV  response:  {       thoughts : Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'computer', 'table_cloth', 'toaster', 'plate', 'faucet', 'dish_soap', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'food_food', 'television', 'wine', 'tray', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'dishwasher', 'vase']  Task:Wash dishes with dishwasher  response:

{  I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'toilet', 'chair', 'jelly', 'cat', 'dough', 'cpuscreen', 'floor', 'desk', 'bedroom', 'keyboard', 'computer', 'laptop', 'mat', 'tvstand', 'mousepad', 'wall', 'nightstand', 'love_seat', 'cup', 'clothes_gloves', 'television', 'towel_rack', 'mouse', 'dresser', 'controller', 'bathroom_cabinet', 'electrical_outlet']  Task:Write book  response:  {       thoughts : Writing a book,       actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <electrical_outlet>', '[PLUGIN] <laptop>', '[WALK] <love_seat>', '[SIT] <love_seat>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['sheets', 'tablelamp', 'measuring_cup', 'dog', 'nail_polish', 'detergent', 'toothbrush', 'drawing', 'hanger', 'desk', 'computer', 'toaster', 'tvstand', 'iron', 'picture', 'window', 'shower', 'food_kiwi', 'bench', 'cup', 'food_cheese', 'photoframe', 'check', 'coffe_maker', 'television', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap']  Task:Read book  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'comb', 'dresser', 'door', 'light']  Task:Work  response:  {       thoughts : Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['food_ice_cream', 'beer', 'toilet', 'band-aids', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'desk', 'mail', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'stereo', 'iron', 'shower', 'pillow', 'nightstand', 'toy', 'bed', 'food_food', 'oven_mitts', 'coffee_filter', 'after_shave', 'curtain', 'lighter', 'cupboard', 'maindoor']  Task:Pet cat  response:

{  I walk to the living room. I find the cat. I pet the cat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_pizza', 'tablelamp', 'juice', 'food_salt', 'measuring_cup', 'ceilingfan', 'orchid', 'shampoo', 'bedroom', 'desk', 'table_cloth', 'toaster', 'tvstand', 'stereo', 'plate', 'bench', 'basket_for_clothes', 'coffee_filter', 'ice', 'tray', 'pencil', 'headset', 'cupboard', 'maindoor', 'napkin', 'bag', 'light', 'soap', 'washing_machine', 'creditcard']  Task:Wash clothes  response:  {       thoughts : Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['sheets', 'pot', 'tablelamp', 'freezer', 'walllamp', 'trashcan', 'food_butter', 'toothbrush', 'orchid', 'longboard', 'phone', 'keyboard', 'shower', 'stereo', 'oil', 'mousepad', 'clothes_pants', 'pillow', 'dining_room', 'nightstand', 'photoframe', 'newspaper', 'food_onion', 'mouse', 'shoes', 'cd', 'cupboard', 'controller', 'dishwasher', 'dirt']  Task:Turn on light  response:

{  I go home and it's dark so I can not see anything }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'dog', 'freezer', 'knife', 'orchid', 'bathroom_counter', 'character', 'bedroom', 'faucet', 'couch', 'food_orange', 'towel', 'nightstand', 'oven', 'powersocket', 'photoframe', 'check', 'video_game_controller', 'food_donut', 'food_rice', 'food_onion', 'diary', 'dresser', 'hairbrush', 'clothes_scarf', 'napkin', 'bathroom_cabinet', 'colander']  Task:Pet cat  response:  {       thoughts : Walk into the living room. Walk up to the cat. Pet the cat with your hand.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['tablelamp', 'microwave', 'bathroom', 'detergent', 'cat', 'drawing', 'floor', 'folder', 'keyboard', 'food_cake', 'table_cloth', 'ceilinglamp', 'deck_of_cards', 'window', 'couch', 'wall', 'wall_clock', 'powersocket', 'newspaper', 'television', 'pencil', 'maindoor', 'clothes_scarf', 'sink', 'home_office', 'table', 'tooth_paste', 'laser_pointer', 'teeth', 'creditcard']  Task:Pet cat  response:

{  walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'cloth_napkin', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'pencil', 'headset', 'dresser', 'door', 'sink']  Task:Clean  response:  {       thoughts : Use a cloth to wipe away any marks on the computer screen.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <cloth_napkin>', '[GRAB] <cloth_napkin>', '[WIPE] <computer>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'envelope', 'computer', 'mail', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'check', 'food_food', 'television', 'tray', 'doorjamb', 'mouse', 'chessboard', 'light']  Task:Browse internet  response:

{  Walk to home office. Walk to computer. Switch on Computer. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'mousepad', 'candle', 'wall', 'nightstand', 'newspaper', 'doorjamb', 'mouse', 'light', 'clothes_skirt']  Task:Browse internet  response:  {       thoughts : Turn on computer, pull up browser, browse the internet,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['sponge', 'pot', 'tablelamp', 'ground_coffee', 'walllamp', 'trashcan', 'knifeblock', 'longboard', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'tvstand', 'wall', 'clothes_gloves', 'keys', 'coffe_maker', 'check', 'video_game_controller', 'coffee_filter', 'toilet_paper', 'food_onion', 'curtain', 'kitchen_counter', 'controller', 'hairdryer', 'dishwasher', 'vase', 'soap']  Task:Make coffee  response:

{  You walk into the kitchen and turn to the coffee maker. You grab the coffee filter and put into the coffee machine, you also grab the ground coffee and put it into the coffee machine. You turn on the coffee 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:['spectacles', 'glue', 'tea', 'chair', 'freezer', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'keyboard', 'bookshelf', 'food_bacon', 'tvstand', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'toilet_paper', 'diary', 'mouse', 'chessboard', 'spoon', 'home_office', 'table', 'light']  Task:Sit in chair  response:  {       thoughts : I sit in a chair to rest and eat.,       actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']  }     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:

{  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. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'trashcan', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'thread', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'bench', 'cup', 'light_bulb', 'coffe_maker', 'toilet_paper', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'table']  Task:Work  response:  {       thoughts : Type on a computer in the home office.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'stereo', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'wall', 'oven', 'tape', 'check', 'television', 'doorjamb', 'mouse', 'pencil', 'cd', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light', 'table', 'instrument_violin']  Task:Relax on sofa  response:

{  I want to relax on the sofa to some relaxing music in the living room. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'jelly', 'trashcan', 'food_egg', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'cleaning_solution', 'bookshelf', 'computer', 'shower', 'window', 'clothes_pants', 'dining_room', 'nightstand', 'pasta', 'oven', 'tape', 'food_cheese', 'bed', 'ice', 'coffee_pot', 'dishrack', 'sink', 'table', 'light', 'hands_both']  Task:Wash hands  response:  {       thoughts : walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands,       actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[FIND] <hands_both>', '[WASH] <hands_both>']  }     Scene_Objects:['sheets', 'juice', 'microwave', 'freezer', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'ceilinglamp', 'plate', 'window', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'powersocket', 'novel', 'food_food', 'mouthwash', 'television', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'comb', 'door', 'laser_pointer']  Task:Put groceries in Fridge  response:

{  Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge, }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher']  Task:Change TV channel  response:  {       thoughts : I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['pot', 'beer', 'microwave', 'ceilingfan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'mat', 'oil', 'couch', 'dining_room', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'kettle', 'door', 'napkin', 'table']  Task:Relax on sofa  response:

{  I walk to my living room and switch on the television, and lay on 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:['microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'character', 'keyboard', 'envelope', 'clothes_jacket', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'wall', 'nightstand', 'bench', 'wall_clock', 'television', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet']  Task:Go to toilet  response:  {       thoughts : I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[TURNTO] <toilet>', '[LOOKAT] <toilet>', '[WALK] <toilet>', '[TURNTO] <toilet>']  }     Scene_Objects:['sponge', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'stamp', 'computer', 'brush', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'television', 'doorjamb', 'vacuum_cleaner', 'hairbrush', 'cupboard', 'table']  Task:Read book  response:  {       thoughts : I pick up a book off the self that I want to read. Then, I sit down on the couch, open the book, and begin reading it.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>']  }     Scene_Objects:['food_ice_cream', 'toilet', 'dog', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'longboard', 'floor', 'phone', 'character', 'purse', 'computer', 'toaster', 'plate', 'balanceball', 'stereo', 'dish_soap', 'food_kiwi', 'wall', 'oven', 'tape', 'coffe_maker', 'mouthwash', 'tray', 'door', 'sink', 'napkin', 'dishwasher', 'vase']  Task:Wash dishes with dishwasher  response:

{  Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'cat', 'trashcan', 'drawing', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'mail', 'toaster', 'mat', 'tvstand', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'powersocket', 'television', 'food_donut', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'dirt']  Task:Pet cat  response:  {       thoughts : My cat looks like it wants attention, so I will go pet it on the couch.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['dry_pasta', 'food_salt', 'microwave', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'bathroom_counter', 'desk', 'clothes_jacket', 'table_cloth', 'stovefan', 'plate', 'stereo', 'couch', 'food_peanut_butter', 'basket_for_clothes', 'photoframe', 'novel', 'mouthwash', 'toothbrush_holder', 'food_donut', 'lighter', 'laundry_detergent', 'conditioner', 'home_office', 'dishwasher', 'soap', 'washing_machine']  Task:Wash clothes  response:

{  Walk to the kitchen and find the basket of clothes. Put the soap and clothes into the washing machine. Turn on the 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', 'detergent', 'drawing', 'orchid', 'floor', 'character', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'coffe_maker', 'kitchen_counter', 'shoes', 'cd', 'hairbrush', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'scrabble', 'hands_both']  Task:Wash hands  response:  {       thoughts : I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'computer', 'stereo', 'shower', 'towel', 'wall', 'wall_clock', 'pasta', 'nightstand', 'bed', 'doorjamb', 'dresser', 'cupboard', 'conditioner', 'door', 'clothes_scarf', 'light', 'clothes_shirt']  Task:Turn on light  response:

{  approach the light switch, raise hand to the switch, flip the switch }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'pot', 'glue', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'floor', 'ceiling', 'phone', 'food_cake', 'table_cloth', 'plate', 'faucet', 'stereo', 'dish_soap', 'towel', 'bowl', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'centerpiece', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'spoon']  Task:Wash dishes by hand  response:  {       thoughts : I enter the kitchen, walk to the sink, turn on the faucet, grab the sponge and get it wet, then apply dish soap to the sponge. I take a dish, scrub it with the sponge, rinse it, and place it on the dish rack to dry, and repeat until all the dishes are clean. I rinse the sponge, put it down, and turn off the faucet.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <sponge>', '[FIND] <dish_soap>', '[GRAB] <sponge>', '[RINSE] <sponge>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[SQUEEZE] <sponge>', '[FIND] <bowl>', '[GRAB] <bowl>', '[SCRUB] <bowl>', '[RINSE] <bowl>', '[FIND] <dishrack>', '[PUTBACK] <bowl> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[SCRUB] <spoon>', '[RINSE] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[RINSE] <sponge>', '[SQUEEZE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'freezer', 'blow_dryer', 'trashcan', 'orchid', 'hanger', 'floor', 'computer', 'button', 'stovefan', 'ceilinglamp', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'bed', 'novel', 'tray', 'curtain', 'after_shave', 'towel_rack', 'pencil', 'maindoor', 'sink', 'light', 'dishwasher']  Task:Go to sleep  response:

{  Walk to bedroom. Walk to bed, lie in bed. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'food_salt', 'food_butter', 'food_carrot', 'drawing', 'food_egg', 'floor', 'phone', 'ceiling', 'character', 'purse', 'mat', 'plate', 'window', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'bed', 'photoframe', 'tray', 'coffee_pot', 'kitchen_counter', 'shoes', 'pajamas', 'sink', 'spoon', 'bathtub', 'table', 'vase']  Task:Set up table  response:  {       thoughts : Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above the plate.,       actions : ['[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[DROP] <plate>', '[FIND] <fork>', '[GRAB] <fork>', '[DROP] <fork>', '[FIND] <spoon>', '[GRAB] <spoon>', '[DROP] <spoon>']  }     Scene_Objects:['fork', 'microwave', 'ceilingfan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'food_cake', 'thread', 'faucet', 'towel', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'water', 'rag', 'lighter', 'cards', 'console', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'table', 'soap', 'laser_pointer', 'hands_both']  Task:Wash hands  response:

{  Go into the bathroom and go over to the sink. Grab soap and turn on the water. Wet your hands and rub them together so that the soap lathers. Rub the soap all over your hands thoroughly. Rinse off the soap with water and turn off the sink. Dry your hands with a towel. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'alcohol', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'curtain', 'rag', 'doorjamb', 'dresser', 'table', 'clothes_skirt']  Task:Watch TV  response:  {       thoughts : go to living room, sit on couch, get remote, switch on tv, watch tv,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['beer', 'walllamp', 'ceilingfan', 'orchid', 'hanger', 'longboard', 'floor', 'ceiling', 'character', 'bedroom', 'folder', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'candle', 'wall', 'oven', 'bench', 'box', 'cup', 'clothes_gloves', 'coffe_maker', 'tray', 'console', 'maindoor', 'door', 'napkin', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'scissors', 'chair', 'freezer', 'trashcan', 'knife', 'longboard', 'floor', 'shampoo', 'computer', 'button', 'tvstand', 'stereo', 'window', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'nightstand', 'bed', 'novel', 'check', 'wine', 'curtain', 'cupboard', 'hair', 'sink', 'bathroom_cabinet', 'soap', 'creditcard']  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:['chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'desk', 'food_cake', 'stovefan', 'toaster', 'deck_of_cards', 'faucet', 'candle', 'pillow', 'dining_room', 'oven', 'photoframe', 'check', 'food_food', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'board_game', 'clothes_shirt']  Task:Pet cat  response:

{  Walk to living room. Find cat. Walk to cat. Pull cat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'filing_cabinet', 'cat', 'food_butter', 'hanger', 'floor', 'ceiling', 'food_cake', 'ceilinglamp', 'deck_of_cards', 'tvstand', 'homework', 'mousepad', 'closetdrawer', 'teeth', 'food_jam', 'nightstand', 'powersocket', 'bed', 'check', 'video_game_controller', 'mouthwash', 'towel_rack', 'mouse', 'console', 'cd', 'cupboard', 'instrument_guitar', 'coffee', 'shoe_rack']  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:['pot', 'chair', 'freezer', 'food_butter', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bedroom', 'desk', 'bookshelf', 'button', 'bookmark', 'toaster', 'ceilinglamp', 'deck_of_cards', 'iron', 'tvstand', 'pillow', 'pasta', 'bench', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'mouse', 'dresser', 'controller']  Task:Pick up phone  response:

{  walk into living room, look at the phone when it ringing, grab the phone or 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:['tablelamp', 'toilet', 'chair', 'freezer', 'bathroom', 'detergent', 'ceilingfan', 'milk', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_rice', 'mouse', 'pencil', 'pajamas', 'maindoor', 'board_game', 'teeth', 'shoe_rack']  Task:Wipe down baseboards please  response:  {       thoughts : Use a rag to get all the dust off the baseboards please.,       actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'stereo', 'mousepad', 'food_noodles', 'form', 'food_kiwi', 'wall', 'nightstand', 'photoframe', 'check', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'light']  Task:Work  response:

{  Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bench', 'food_food', 'water', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both', 'shoe_rack']  Task:Wash hands  response:  {       thoughts : I turn on faucet. I hold out my hands. I get my hands wet.,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>']  }     Scene_Objects:['filing_cabinet', 'juice', 'microwave', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'clothes_jacket', 'button', 'ceilinglamp', 'mat', 'window', 'couch', 'food_jam', 'wall', 'nightstand', 'cutting_board', 'cup', 'television', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'table', 'vase', 'coffee']  Task:Pet cat  response:

{  Walk into bedrrom and to the sofa. Sit on the sofa and touch cat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Browse internet  response:  {       thoughts : I walk into my home office and walk up to my desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on the google icon. I enter Disney Cruise Line into the search bar and browse the internet.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['fork', 'sponge', 'scissors', 'microwave', 'ground_coffee', 'dough', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'tea_bag', 'food_cake', 'toaster', 'stovefan', 'tvstand', 'food_orange', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'coffee_filter', 'hairbrush', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'vase']  Task:Make coffee  response:

{  Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and 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:['spectacles', 'tablelamp', 'blender', 'food_ice_cream', 'toothbrush', 'knifeblock', 'hanger', 'dvd_player', 'alcohol', 'button', 'stovefan', 'stereo', 'homework', 'mousepad', 'powersocket', 'cup', 'food_cheese', 'bed', 'food_donut', 'tray', 'after_shave', 'doorjamb', 'lighter', 'dresser', 'home_office', 'light', 'bathroom_cabinet', 'dishwasher', 'soap', 'creditcard']  Task:Pet cat  response:  {       thoughts : I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['filing_cabinet', 'tea', 'chair', 'freezer', 'bathroom', 'trashcan', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'bedroom', 'computer', 'plate', 'stereo', 'window', 'food_kiwi', 'wall', 'nightstand', 'box', 'bed', 'clothes_gloves', 'coffe_maker', 'wooden_spoon', 'curtain', 'shoes', 'dishwasher', 'creditcard']  Task:Listen to music  response:

{  I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'character', 'bedroom', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'pasta', 'bench', 'cup', 'bed', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'headset', 'cupboard', 'instrument_guitar', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk into the living room. I bend down. I sit on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'microwave', 'ground_coffee', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'button', 'toaster', 'tvstand', 'shower', 'picture', 'couch', 'food_jam', 'food_orange', 'dining_room', 'wall', 'powersocket', 'coffe_maker', 'toilet_paper', 'coffee_filter', 'water', 'centerpiece', 'cupboard', 'door', 'sink', 'bag', 'table', 'dishwasher', 'tooth_paste']  Task:Make coffee  response:

{  Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the 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', 'microwave', 'toilet', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'tea_bag', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'pasta', 'nightstand', 'photoframe', 'novel', 'food_food', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'light', 'board_game']  Task:Read book  response:  {       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:['glue', 'food_pizza', 'filing_cabinet', 'juice', 'toilet', 'freezer', 'trashcan', 'toothbrush', 'character', 'remote_control', 'tvstand', 'faucet', 'picture', 'deck_of_cards', 'clothes_socks', 'clothes_hat', 'pillow', 'oven', 'coffe_maker', 'coin', 'curtain', 'rag', 'towel_rack', 'dishrack', 'dresser', 'cupboard', 'laundry_detergent', 'light', 'clothes_skirt', 'teeth']  Task:Watch TV  response:

{  I walk to the living room and sit on the couch.  I grab the TV remote.  I press the power button on the TV remote and the TV turns on.  I grab the surround sound remote.  I press the power button on the surround sound remote and the system turns 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:['sheets', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'window', 'mousepad', 'form', 'dining_room', 'wall', 'cutting_board', 'bed', 'clothes_gloves', 'check', 'television', 'oven_mitts', 'curtain', 'mouse', 'hair', 'napkin', 'vase', 'instrument_violin', '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:['microwave', 'walllamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'phone', 'bedroom', 'bookshelf', 'electric_shaver', 'window', 'towel', 'wall', 'nightstand', 'oven', 'powersocket', 'basket_for_clothes', 'newspaper', 'check', 'oven_mitts', 'after_shave', 'towel_rack', 'mouse', 'kettle', 'dresser', 'laundry_detergent', 'bag', 'table', 'dishwasher', 'washing_machine', 'shoe_rack']  Task:Wash clothes  response:

{  Pick up my dirty clothes, load the washer, add detergent, turn on washer }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'nail_polish', 'trashcan', 'milk', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'computer', 'faucet', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'check', 'coffe_maker', 'wine', 'after_shave', 'towel_rack', 'comb', 'controller', 'sink', 'bathroom_cabinet', 'light', 'table', 'instrument_violin', 'teeth']  Task:Get toilet paper  response:  {       thoughts : There are extra toilet papers in the bottom cabinet.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']  }     Scene_Objects:['sponge', 'beer', 'microwave', 'chair', 'ceilingfan', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'shampoo', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'dining_room', 'wall', 'pasta', 'oven', 'photoframe', 'television', 'curtain', 'coffee_pot', 'comb', 'controller', 'table']  Task:Change TV channel  response:

{  walk to living room ,find television ,find remote control ,switch on remote control and 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:['sponge', 'pot', 'food_pizza', 'scissors', 'tablelamp', 'microwave', 'band-aids', 'floor', 'folder', 'food_cake', 'mail', 'computer', 'table_cloth', 'toaster', 'brush', 'plate', 'shower', 'dish_soap', 'wall', 'coffe_maker', 'oven_mitts', 'food_donut', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'home_office', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['tea', 'toilet', 'chair', 'detergent', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'character', 'bookshelf', 'purse', 'envelope', 'toaster', 'tvstand', 'shower', 'window', 'pillow', 'tape', 'cup', 'coffe_maker', 'check', 'oven_mitts', 'curtain', 'rag', 'lighter', 'mouse', 'pencil', 'hairbrush', 'table', 'vase']  Task:Pet cat  response:

{  find the cat, go near the cat and pet the cat }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'beer', 'microwave', 'ceilingfan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'mat', 'oil', 'couch', 'dining_room', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'kettle', 'door', 'napkin', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk to my living room and switch on the television, and lay on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>']  }     Scene_Objects:['walllamp', 'ceilingfan', 'drawing', 'needle', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table', 'laser_pointer']  Task:Watch TV  response:

{  Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch 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:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink', 'light', 'table', 'creditcard']  Task:Browse internet  response:  {       thoughts : Walk to home office. Walk to computer. Switch on Computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['tablelamp', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'longboard', 'bedroom', 'keyboard', 'clothes_jacket', 'bookmark', 'toaster', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'pillow', 'nightstand', 'wall', 'photoframe', 'food_food', 'mouthwash', 'tray', 'diary', 'comb', 'pajamas', 'maindoor', 'bag', 'spoon', 'light']  Task:Pet cat  response:

{  Go to the living room where the cat sleeps. Find cat. Proceed to petting cat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'freezer', 'bathroom', 'cat', 'cpuscreen', 'bathroom_counter', 'bedroom', 'food_cake', 'computer', 'alcohol', 'toaster', 'stovefan', 'ceilinglamp', 'mousepad', 'closetdrawer', 'clothes_hat', 'nightstand', 'wall_clock', 'newspaper', 'coffee_filter', 'oven_mitts', 'kettle', 'kitchen_counter', 'dresser', 'hair', 'sink', 'napkin', 'bag', 'light']  Task:Pet cat  response:  {       thoughts : find the cat, go near the cat and pet the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'board_game', 'freezer', 'food_butter', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'keyboard', 'faucet', 'stereo', 'window', 'food_peanut_butter', 'towel', 'dining_room', 'wall', 'bench', 'photoframe', 'towel_rack', 'kitchen_counter', 'coffee', 'sink', 'bathroom_cabinet', 'dishwasher', 'tooth_paste', 'teeth', 'creditcard']  Task:Wash teeth  response:

{  I go to sleep and i eat the dinner so i have to clean my mouth }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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:['chair', 'freezer', 'trashcan', 'ceilingfan', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'oil', 'food_orange', 'pillow', 'bowl', 'wall', 'wall_clock', 'bench', 'keys', 'light_bulb', 'food_food', 'check', 'television', 'drinking_glass', 'water', 'centerpiece', 'dishrack', 'hairbrush']  Task:Drink  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'filing_cabinet', 'mop', 'microwave', 'trashcan', 'drawing', 'ceiling', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'tvstand', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'form', 'pillow', 'nightstand', 'newspaper', 'bed', 'curtain', 'towel_rack', 'dishrack', 'home_office', 'light', 'dishwasher', 'table', 'scrabble']  Task:Wash dishes by hand  response:  {       thoughts : walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <dishrack>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <dishrack> <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['food_salt', 'microwave', 'trashcan', 'drawing', 'floor', 'dvd_player', 'desk', 'envelope', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'check', 'television', 'coin', 'colander', 'after_shave', 'cd', 'cupboard', 'table', 'vase', 'soap']  Task:Relax on sofa  response:

{  Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. 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:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'table', 'light']  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] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUTOBJBACK] <remote_control>', '[WATCH] <television>']  }     Scene_Objects:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer']  Task:Pet cat  response:

{  I walk into the living room and I pet the cat }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'filing_cabinet', 'microwave', 'chair', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'mail', 'computer', 'toaster', 'mat', 'stovefan', 'faucet', 'mousepad', 'dining_room', 'wall', 'nightstand', 'coffe_maker', 'water', 'food_rice', 'drinking_glass', 'curtain', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher']  Task:Drink  response:  {       thoughts : I walk to the kitchen and approach the sink. I take a drinking glass and set it under the faucet. I turn the faucet until the water fills the glass, then turn it back. Finally I lift the glass out of the sink and drink the water.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>'] }     Scene_Objects:['sheets', 'pot', 'chair', 'ground_coffee', 'orchid', 'knifeblock', 'longboard', 'floor', 'ceiling', 'stamp', 'computer', 'toaster', 'picture', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'bed', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'vase', 'colander']  Task:Make coffee  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:['toilet', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'dvd_player', 'desk', 'bedroom', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'tray', 'curtain', 'controller', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'light']  Task:Listen to music  response:  {       thoughts : walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music,       actions : ['[WALK] <home_office>', '[WALK] <dvd_player>', '[FIND] <dvd_player>', '[TURNTO] <dvd_player>', '[LOOKAT] <dvd_player>', '[SWITCHON] <dvd_player>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sponge', 'food_salt', 'chair', 'detergent', 'trashcan', 'dough', 'drawing', 'character', 'computer', 'button', 'brush', 'mat', 'couch', 'clothes_pants', 'clothes_hat', 'wall', 'nightstand', 'basket_for_clothes', 'food_cheese', 'rag', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'laundry_detergent', 'conditioner', 'sink', 'home_office', 'table', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee']  Task:Bring dirty plate to sink  response:  {       thoughts : Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink.,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>']  }     Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'crayon', 'bills', 'knifeblock', 'hanger', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'form', 'wall', 'nightstand', 'coffe_maker', 'food_food', 'razor', 'coin', 'video_game_controller', 'check', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'spoon', 'napkin', 'dishwasher', 'vase']  Task:Read book  response:

{  walk to living room ,find a book ,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:['blender', 'tea', 'microwave', 'jelly', 'band-aids', 'freezer', 'bathroom', 'needle', 'ceiling', 'character', 'keyboard', 'mop_bucket', 'ceilinglamp', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'check', 'television', 'cards', 'laundry_detergent', 'clothes_dress', 'home_office', 'table']  Task:Put umbrella away  response:  {       thoughts : Place the umbrella in the umbrella bucket point first.,       actions : ['[WALK] <home_office>', '[WALK] <mop_bucket>']  }     Scene_Objects:['fork', 'microwave', 'freezer', 'blow_dryer', 'food_carrot', 'milk', 'drawing', 'floor', 'phone', 'keyboard', 'bookshelf', 'button', 'piano_bench', 'laptop', 'plate', 'oil', 'mousepad', 'wall', 'bench', 'photoframe', 'keys', 'food_food', 'check', 'tray', 'kitchen_counter', 'dishrack', 'hair', 'table', 'soap', 'teeth']  Task:Set up table  response:

{  I walk to the table. I put down the dish. I put down the silverware. I put down the napkin. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'dustpan', 'pillow', 'broom', 'wall', 'powersocket', 'cup', 'video_game_controller', 'television', 'doorjamb', 'hairbrush', 'door', 'sink', 'bag', 'table']  Task:Watch TV  response:  {       thoughts : Walk to living room.  Find remote control.  Find television.  Point remote at television.  Press  on  button.  Watch.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'jelly', 'trashcan', 'food_egg', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'cleaning_solution', 'bookshelf', 'computer', 'shower', 'window', 'clothes_pants', 'dining_room', 'nightstand', 'pasta', 'oven', 'tape', 'food_cheese', 'bed', 'ice', 'coffee_pot', 'dishrack', 'sink', 'table', 'light', 'hands_both']  Task:Wash hands  response:

{  walk to bathroom , find cleaning solution , squeeze cleaning solution , wash 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:['tablelamp', 'microwave', 'chair', 'jelly', 'ground_coffee', 'nail_polish', 'detergent', 'orchid', 'needle', 'drawing', 'hanger', 'character', 'envelope', 'ceilinglamp', 'shower', 'electric_shaver', 'tooth_paste', 'mousepad', 'food_kiwi', 'powersocket', 'oven', 'tape', 'cup', 'photoframe', 'wooden_spoon', 'cards', 'kitchen_counter', 'cd', 'instrument_violin', 'laser_pointer']  Task:Wash dishes with dishwasher  response:  {       thoughts : grab the vesseles and wash,       actions : ['[WALK] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dining_room>', '[WASH] <bowl>', '[WALK] <detergent>', '[FIND] <detergent>', '[RINSE] <detergent>']  }     Scene_Objects:['dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'detergent', 'ceilingfan', 'orchid', 'drawing', 'bathroom_counter', 'character', 'bookshelf', 'stovefan', 'tvstand', 'balanceball', 'electric_shaver', 'window', 'clothes_socks', 'oven', 'light_bulb', 'television', 'food_rice', 'tray', 'after_shave', 'wooden_spoon', 'towel_rack', 'kettle', 'mouse', 'dishrack', 'dresser', 'instrument_violin']  Task:Pet cat  response:

{  Go into the living room and pet the cat }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'milk', 'floor', 'ceiling', 'shampoo', 'purse', 'ceilinglamp', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'tape', 'novel', 'food_food', 'food_donut', 'wooden_spoon', 'mouse', 'kitchen_counter', 'door', 'home_office', 'bathroom_cabinet', 'vase', 'soap', 'instrument_violin', 'creditcard']  Task:Put groceries in Fridge  response:  {       thoughts : I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['microwave', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'remote_control', 'mop_bucket', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'form', 'food_kiwi', 'wall', 'oven', 'powersocket', 'cutting_board', 'cup', 'bed', 'toilet_paper', 'food_food', 'television', 'curtain', 'centerpiece', 'maindoor', 'napkin', 'table', 'vase']  Task:Watch TV  response:

{  Walk to living room. Sit on the sofa. Grab the remote control and plug in TV. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'curtain', 'shoes', 'cd', 'vacuum_cleaner', 'dresser', 'cupboard', 'clothes_dress', 'home_office', 'table', 'shoe_rack']  Task:Take off shoes  response:  {       thoughts : Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area.,       actions : ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>']  }     Scene_Objects:['toilet', 'walllamp', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'purse', 'stovefan', 'ceilinglamp', 'stereo', 'faucet', 'window', 'balanceball', 'electric_shaver', 'couch', 'wall', 'bench', 'food_food', 'television', 'curtain', 'diary', 'mouse', 'dresser', 'hair', 'bathroom_cabinet', 'table', 'home_office', 'vase', 'teeth', 'shoe_rack']  Task:Relax on sofa  response:

{  Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'shampoo', 'ceiling', 'button', 'deck_of_cards', 'shower', 'clothes_pants', 'food_kiwi', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'home_office', 'light', 'clothes_skirt', 'dishwasher', 'coffee']  Task:Grab things  response:  {       thoughts : The robot will need some kind of hands or grabbing device to transport objects.,       actions : ['[WALK] <novel>', '[TURNTO] <novel>', '[GRAB] <novel>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'scissors', 'freezer', 'ceilingfan', 'knifeblock', 'knife', 'hanger', 'phone', 'desk', 'clothes_jacket', 'toaster', 'ceilinglamp', 'electric_shaver', 'window', 'mousepad', 'couch', 'candle', 'cutting_board', 'food_cheese', 'food_rice', 'food_onion', 'pencil', 'cd', 'comb', 'door', 'maindoor', 'napkin', 'soap']  Task:Pet cat  response:

{  You walk to the living room and find the cat. You look at the cat and touch it to pet 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', 'beer', 'toilet', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'folder', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'microphone', 'wall', 'bench', 'light_bulb', 'television', 'curtain', 'food_steak', 'sink', 'napkin', 'home_office', 'table']  Task:Watch TV  response:  {       thoughts : 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.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['dry_pasta', 'blender', 'knife', 'orchid', 'drawing', 'longboard', 'character', 'desk', 'computer', 'button', 'toaster', 'tvstand', 'faucet', 'clothes_socks', 'dirt', 'cutting_board', 'basket_for_clothes', 'cup', 'photoframe', 'bed', 'novel', 'coffe_maker', 'razor', 'curtain', 'mouse', 'pencil', 'table', 'dishwasher', 'soap', 'washing_machine']  Task:Wash clothes  response:

{  put clothes and soap in the washing machine, turn it on }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'ice', 'rag', 'doorjamb', 'mouse', 'controller', 'door', 'light', 'table', 'scrabble', 'dirt']  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:['drawing', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'computer', 'button', 'mat', 'ceilinglamp', 'shower', 'faucet', 'tvstand', 'food_peanut_butter', 'towel', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'curtain', 'mouse', 'kitchen_counter', 'shoes', 'laundry_detergent', 'food_steak', 'sink', 'bag', 'bathroom_cabinet', 'door', 'vase', 'soap']  Task:Take shower  response:

{  I want to take a shower so I go to the bathroom, turn on the shower, get the soap, lather and wash, then I rinse, turn off shower, get a towel and dry off. }