Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['mop', 'microwave', 'bathroom', 'detergent', 'wallshelf', 'clothes_underwear', 'hanger', 'ceiling', 'bookshelf', 'tvstand', 'faucet', 'deck_of_cards', 'window', 'clothes_socks', 'clothes_pants', 'cup', 'standingmirror', 'photoframe', 'check', 'tray', 'kitchen_counter', 'hair', 'laundry_detergent', 'door', 'bathroom_cabinet', 'tooth_paste', 'clothes_shirt', 'washing_machine', 'coffee', 'shoe_rack']  Task:Wash clothes  response:  {       thoughts : I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['pot', 'beer', 'microwave', 'jelly', 'freezer', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'purse', 'computer', 'iron', 'window', 'mousepad', 'oil', 'wall', 'powersocket', 'bed', 'keys', 'mouthwash', 'wine', 'doorjamb', 'mouse', 'cupboard', 'door', 'sink', 'light']  Task:Turn on light  response:

{  walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'beer', 'chair', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'cleaning_solution', 'bookmark', 'iron', 'mousepad', 'couch', 'dustpan', 'food_jam', 'tape', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'vase', 'colander', 'teeth']  Task:Clean mirror  response:  {       thoughts : Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.,       actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['food_ice_cream', 'microwave', 'freezer', 'trashcan', 'toothbrush', 'orchid', 'hanger', 'desk', 'keyboard', 'bookmark', 'shoe-shine_kit', 'iron', 'tvstand', 'plate', 'mousepad', 'microphone', 'wall', 'bench', 'toilet_paper', 'television', 'toothbrush_holder', 'ice', 'shoes', 'chessboard', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'tooth_paste', 'teeth', 'creditcard']  Task:Wash teeth  response:

{  walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'glue', 'tablelamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'clothes_jacket', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'novel', 'mouse', 'shoes', 'dresser', 'clothes_dress', 'light', 'table']  Task:Get ready for day  response:  {       thoughts : Grab shoes, purse etc and head out the door!,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <purse>', '[GRAB] <purse>', '[CLOSE] <dresser>', '[WALK] <home_office>']  }     Scene_Objects:['glue', 'fork', 'food_pizza', 'tablelamp', 'crayon', 'measuring_cup', 'dough', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'food_cake', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'powersocket', 'bench', 'cup', 'colander', 'mouse', 'hairbrush', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'soap', 'hands_both']  Task:Wash hands  response:

{  go to the bathroom and wash your 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:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'toaster', 'plate', 'couch', 'wall', 'light_bulb', 'novel', 'coffe_maker', 'food_rice', 'tray', 'food_onion', 'after_shave', 'curtain', 'kettle', 'kitchen_counter', 'shoes', 'cupboard', 'conditioner', 'door', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['spectacles', 'water_glass', 'glue', 'walllamp', 'detergent', 'food_carrot', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'computer', 'ceilinglamp', 'tvstand', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'wall', 'nightstand', 'box', 'curtain', 'pencil', 'headset', 'dresser', 'table', 'board_game', 'shoe_rack']  Task:Relax on sofa  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', 'microwave', 'toilet', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'stovefan', 'faucet', 'towel', 'pillow', 'wall', 'wall_clock', 'bed', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'controller', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Cleaning hands,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['sheets', 'tablelamp', 'blender', 'freezer', 'walllamp', 'dough', 'orchid', 'drawing', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'picture', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'dishrack', 'door', 'sink', 'table']  Task:Watch TV  response:

{  Turn on the TV, sit on the couch, find a show, and watch it. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'juice', 'microwave', 'freezer', 'blow_dryer', 'ground_coffee', 'cat', 'floor', 'legs_both', 'face', 'toaster', 'laptop', 'homework', 'closetdrawer', 'towel', 'feet_both', 'arms_both', 'basket_for_clothes', 'newspaper', 'photoframe', 'coffe_maker', 'mouthwash', 'centerpiece', 'doorjamb', 'headset', 'dresser', 'cupboard', 'napkin', 'soap', 'clothes_shirt']  Task:Try yourself off  response:  {       thoughts : After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing.,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <dresser>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <arms_both>', '[WIPE] <arms_both>', '[FIND] <legs_both>', '[WIPE] <legs_both>', '[FIND] <feet_both>', '[WIPE] <feet_both>', '[FIND] <basket_for_clothes>', '[PUTBACK] <towel> <basket_for_clothes>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'plate', 'homework', 'mousepad', 'dining_room', 'wall', 'bench', 'newspaper', 'novel', 'check', 'mouse', 'kitchen_counter', 'hair', 'door', 'sink', 'home_office', 'table']  Task:Browse internet  response:

{  I sit at my computer desk and open the browser. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toilet', 'chair', 'freezer', 'walllamp', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'food_orange', 'nightstand', 'bench', 'photoframe', 'bed', 'food_food', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'table', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk into laundry room. Open washing machine door. Put dirty clothes into washing machine. Measure laundry detergent and place into washing machine. Turn dial to appropriate wash setting. Power on.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[CLOSE] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[OPEN] <washing_machine>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['fork', 'pot', 'microwave', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'toaster', 'stovefan', 'faucet', 'wall', 'pasta', 'oven', 'coffe_maker', 'food_food', 'check', 'coffee_filter', 'television', 'water', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'clothes_scarf', 'dishwasher']  Task:Make coffee  response:

{  I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'detergent', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'remote_control', 'button', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'clothes_socks', 'couch', 'wall', 'basket_for_clothes', 'light_bulb', 'television', 'razor', 'curtain', 'food_onion', 'towel_rack', 'coffee_pot', 'pencil', 'kitchen_counter', 'bag', 'table']  Task:Watch TV  response:  {       thoughts : turn on the tv,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']  }     Scene_Objects:['scissors', 'blender', 'freezer', 'walllamp', 'trashcan', 'orchid', 'knife', 'bathroom_counter', 'shampoo', 'character', 'desk', 'folder', 'keyboard', 'stovefan', 'mat', 'picture', 'window', 'food_noodles', 'bench', 'toothbrush_holder', 'food_donut', 'after_shave', 'doorjamb', 'cards', 'kitchen_counter', 'vacuum_cleaner', 'dishrack', 'door', 'home_office', 'bathroom_cabinet']  Task:Pick up phone  response:

{  I walk to the home office. I find the telephone. I pick up the telephone handset. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'dog', 'cpuscreen', 'keyboard', 'ceilinglamp', 'plate', 'laptop', 'faucet', 'window', 'stereo', 'oil', 'food_noodles', 'mousepad', 'dining_room', 'nightstand', 'food_food', 'check', 'wine', 'curtain', 'after_shave', 'comb', 'dresser', 'napkin', 'home_office', 'table', 'bathroom_cabinet', 'light']  Task:Listen to music  response:  {       thoughts : I reach out arm. I put hand on radio. I turn on radio. I pick a station.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>']  }     Scene_Objects:['fork', 'microwave', 'chair', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'purse', 'computer', 'toaster', 'mat', 'tvstand', 'clothes_socks', 'food_peanut_butter', 'microphone', 'food_jam', 'pillow', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'pajamas', 'laundry_detergent', 'door', 'light', 'tooth_paste']  Task:Turn on light  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table']  Task:Browse internet  response:  {       thoughts : Walk to the Home Office.  Find the computer.  Turn on the computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['fork', 'pot', 'microwave', 'walllamp', 'trashcan', 'knife', 'drawing', 'floor', 'computer', 'toaster', 'mat', 'plate', 'faucet', 'ceilinglamp', 'stovefan', 'dish_soap', 'oil', 'wall', 'powersocket', 'tape', 'coffe_maker', 'television', 'drinking_glass', 'rag', 'shaving_cream', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_skirt']  Task:Wash dishes with dishwasher  response:

{  Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['scissors', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'television', 'doorjamb', 'dresser', 'soap', 'instrument_violin']  Task:Watch TV  response:  {       thoughts : I sit on my couch and watch TV in my living room,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']  }     Scene_Objects:['toilet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'iron', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'mouse', 'cupboard', 'door', 'clothes_scarf', 'bathroom_cabinet', 'table', 'instrument_guitar']  Task:Work  response:

{  For doing homework walk to home office. Walk to computer. Switch on Computer. Sit in a chair and do homework in 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', 'food_salt', 'beer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'clothes_underwear', 'floor', 'folder', 'man', 'computer', 'toaster', 'ceilinglamp', 'stereo', 'window', 'homework', 'mousepad', 'couch', 'microphone', 'pillow', 'wall', 'nightstand', 'keys', 'food_food', 'wooden_spoon', 'curtain', 'doorjamb', 'hair', 'table']  Task:Have conversation with boyfriend  response:  {       thoughts : Sit on sofa, talk,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <man>', '[GREET] <man>']  }     Scene_Objects:['microwave', 'chair', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'electric_shaver', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'newspaper', 'bed', 'food_food', 'wine', 'doorjamb', 'cards', 'mouse', 'shoes', 'dresser', 'door', 'light', 'dirt']  Task:Put groceries in Fridge  response:

{  walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in 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:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']  Task:Greet guests  response:  {       thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']  }     Scene_Objects:['tablelamp', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'food_cake', 'mat', 'tvstand', 'shoe-shine_kit', 'homework', 'oil', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'bench', 'oven', 'powersocket', 'toilet_paper', 'kitchen_counter', 'door', 'tooth_paste']  Task:Pick up phone  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'freezer', 'knife', 'floor', 'ceiling', 'folder', 'stamp', 'brush', 'mat', 'ceilinglamp', 'shower', 'faucet', 'toaster', 'pillow', 'bowl', 'food_kiwi', 'wall', 'powersocket', 'toilet_paper', 'mouthwash', 'doorjamb', 'door', 'home_office', 'light', 'table']  Task:Turn light off  response:  {       thoughts : Put the light switch into the down, or off, position.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['fork', 'glue', 'board_game', 'toilet', 'bathroom', 'dough', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'mat', 'faucet', 'window', 'wall', 'photoframe', 'food_food', 'toothbrush_holder', 'razor', 'tray', 'after_shave', 'doorjamb', 'vacuum_cleaner', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'tooth_paste']  Task:Wash teeth  response:

{  I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table']  Task:Clean  mirror  response:  {       thoughts : GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR,       actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'walllamp', 'trashcan', 'dough', 'toothbrush', 'floor', 'dvd_player', 'bedroom', 'stovefan', 'mat', 'tvstand', 'window', 'food_noodles', 'dining_room', 'nightstand', 'powersocket', 'oven', 'cutting_board', 'cup', 'light_bulb', 'coffe_maker', 'mouthwash', 'oven_mitts', 'doorjamb', 'diary', 'bag', 'home_office', 'scrabble']  Task:Pick up phone  response:

{  go to living room, find phone, pick up 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:['freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'cpuscreen', 'longboard', 'floor', 'phone', 'bedroom', 'toaster', 'faucet', 'pillow', 'wall', 'bed', 'novel', 'water', 'tray', 'centerpiece', 'cards', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'conditioner', 'sink', 'bag', 'napkin', 'table', 'dishwasher', 'board_game']  Task:Drink  response:  {       thoughts : Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.,       actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']  }     Scene_Objects:['pot', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'mousepad', 'oil', 'wall', 'powersocket', 'oven', 'food_food', 'tray', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']  Task:Cook some food  response:

{  I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'chair', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'floor_lamp', 'mousepad', 'couch', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'doorjamb', 'cd', 'door', 'bathtub', 'home_office', 'light']  Task:Turn on light  response:  {       thoughts : walk to wall, find light switch, turn on lights,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['sheets', 'pot', 'dry_pasta', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'phone', 'character', 'clothes_jacket', 'piano_bench', 'mat', 'shoe-shine_kit', 'stereo', 'window', 'oil', 'nightstand', 'cup', 'clothes_gloves', 'check', 'wine', 'tray', 'console', 'pencil', 'dresser', 'hair', 'door', 'clothes_skirt', 'dishwasher', 'clothes_shirt']  Task:Pet cat  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', '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:  {       thoughts : walk into living room, look at the phone when it ringing, grab the phone or pickup the phone,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>']  }     Scene_Objects:['walllamp', 'toothbrush', 'drawing', 'orchid', 'floor', 'ceiling', 'remote_control', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'box', 'basket_for_clothes', 'novel', 'check', 'television', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'clothes_skirt', 'creditcard']  Task:Change TV channel  response:

{  Walk to living room. Walk to and sit at the sofa. Grab remote control and switch on 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', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'wine', 'doorjamb', 'mouse', 'dresser', 'napkin', 'bathroom_cabinet', 'light']  Task:Clean  response:  {       thoughts : Wipe down computer desk and monitor,       actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <desk>', '[FIND] <computer>', '[WIPE] <computer>', '[WIPE] <desk>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'character', 'toaster', 'plate', 'tvstand', 'foundation', 'dish_soap', 'tooth_paste', 'wall', 'cup', 'coffe_maker', 'food_food', 'food_onion', 'centerpiece', 'cards', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'door', 'sink', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'creditcard']  Task:Wash dishes with dishwasher  response:

{  Wash a plate using the dishwasher in the kitchen. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'sheets', 'pot', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'tvstand', 'stereo', 'window', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'powersocket', 'pasta', 'oven', 'light_bulb', 'coffe_maker', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'door', 'light']  Task:Turn light off  response:  {       thoughts : Put the light switch into the down, or off, position.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['walllamp', 'trashcan', 'toothbrush', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'powersocket', 'television', 'food_rice', 'doorjamb', 'pencil', 'chessboard', 'door', 'hairdryer', 'bathroom_cabinet', 'table', 'scrabble']  Task:Change TV channel  response:

{  I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'chair', 'jelly', 'trashcan', 'toothbrush', 'orchid', 'cpuscreen', 'character', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'faucet', 'shower', 'pillow', 'powersocket', 'bench', 'photoframe', 'bed', 'novel', 'coin', 'kitchen_counter', 'headset', 'chessboard', 'comb', 'dresser', 'table', 'coffee', 'creditcard']  Task:Pick up phone  response:  {       thoughts : Walk to the entrance hall. Find the telephone. Grab the telephone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['pot', 'filing_cabinet', 'chair', 'jelly', 'trashcan', 'toothbrush', 'orchid', 'cpuscreen', 'character', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'faucet', 'shower', 'pillow', 'powersocket', 'bench', 'photoframe', 'bed', 'novel', 'coin', 'kitchen_counter', 'headset', 'chessboard', 'comb', 'dresser', 'table', 'coffee', 'creditcard']  Task:Pick up phone  response:

{  Walk to the entrance hall. Find the telephone. Grab the telephone. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'toilet', 'jelly', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'coffee_filter', 'curtain', 'doorjamb', 'centerpiece', 'door', 'table']  Task:Watch TV  response:  {       thoughts : I sit down on sofa, get the remote, turn on tv, change channel to show I want to watch,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['freezer', 'cat', 'milk', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'towel', 'wall', 'powersocket', 'oven', 'food_food', 'coffe_maker', 'coin', 'doorjamb', 'mouse', 'headset', 'shoes', 'pajamas', 'door', 'light', 'colander', 'coffee']  Task:Put groceries in Fridge  response:

{  I walk to the kitchen, open the fridge and put the groceries in the fridge. Then I close 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:['tablelamp', 'food_salt', 'microwave', 'jelly', 'detergent', 'food_carrot', 'toothbrush', 'needle', 'hanger', 'floor', 'phone', 'shampoo', 'character', 'tvstand', 'iron', 'balanceball', 'stereo', 'mousepad', 'food_jam', 'pillow', 'nightstand', 'toothbrush_holder', 'diary', 'console', 'shaving_cream', 'kitchen_counter', 'sink', 'light', 'dishwasher', 'vase']  Task:Listen to music  response:  {       thoughts : Find the playback device you want to listen to. turn on. press play. enjoyu music.,       actions : ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']  }     Scene_Objects:['pot', 'food_ice_cream', 'freezer', 'bathroom', 'knifeblock', 'hanger', 'character', 'desk', 'bedroom', 'folder', 'toaster', 'mat', 'laptop', 'stereo', 'foundation', 'homework', 'bed', 'newspaper', 'television', 'water', 'wine', 'tray', 'kitchen_counter', 'chessboard', 'laundry_detergent', 'food_steak', 'bag', 'home_office', 'light', 'soap']  Task:Wash hands  response:

{  put soap on hands, scrub it and rinse with water }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'ceilinglamp', 'faucet', 'shower', 'towel', 'dining_room', 'wall', 'powersocket', 'bed', 'check', 'wooden_spoon', 'cards', 'mouse', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[WIPE] <hands_both>']  }     Scene_Objects:['dry_pasta', 'food_pizza', 'scissors', 'band-aids', 'nail_polish', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'thread', 'computer', 'button', 'stereo', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'dining_room', 'toilet_paper', 'tray', 'mouse', 'dishrack', 'comb', 'bag', 'home_office', 'clothes_shirt', 'shoe_rack']  Task:Pick up phone  response:

{  Enter living room. Walk to telephone. Pick up from hook. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'food_bread', 'microwave', 'walllamp', 'ceilingfan', 'food_butter', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'food_orange', 'wall', 'bench', 'photoframe', 'keys', 'check', 'food_food', 'television', 'curtain', 'table']  Task:Change TV channel  response:  {       thoughts : Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[TOUCH] <button>']  }     Scene_Objects:['glue', 'tablelamp', 'tea', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'desk', 'bedroom', 'computer', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'food_donut', 'curtain', 'food_onion', 'mouse', 'pajamas', 'controller', 'table', 'dishwasher', 'light', 'board_game']  Task:Relax on sofa  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_pizza', 'microwave', 'toilet', 'jelly', 'freezer', 'band-aids', 'drawing', 'knifeblock', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'water', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']  Task:Get drink  response:  {       thoughts : I go to the fridge and open the door. I look for the water pitcher, and take it out, making sure to close the fridge door behind me. Then I take a pint glass out of the upper cabinet over the sink and use the water pitcher to pour a full glass of water. Then I return the pitcher to the fridge and shut the door again, and take my glass of water out of the kitche.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[OPEN] <freezer>']  }     Scene_Objects:['filing_cabinet', 'crayon', 'toilet', 'chair', 'walllamp', 'bathroom', 'food_butter', 'drawing', 'orchid', 'hanger', 'floor', 'desk', 'tea_bag', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'window', 'couch', 'candle', 'food_orange', 'pillow', 'wall', 'cup', 'bed', 'curtain', 'kettle', 'pencil', 'pajamas', 'table']  Task:Relax on sofa  response:

{  Walk to living room. Sit on sofa. Lie down on sofa. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'freezer', 'knifeblock', 'knife', 'bathroom_counter', 'shampoo', 'ceiling', 'keyboard', 'stovefan', 'mat', 'stereo', 'clothes_socks', 'oil', 'nightstand', 'powersocket', 'toy', 'novel', 'food_food', 'coffe_maker', 'rag', 'kettle', 'shoes', 'cupboard', 'hair', 'controller', 'door', 'instrument_guitar', 'table', 'light']  Task:Listen to music  response:  {       thoughts : walk into living room, walk to stereo, turn on stereo, listen to music,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['crayon', 'mop', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'ceilinglamp', 'mat', 'faucet', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'bed', 'newspaper', 'food_food', 'coffee_filter', 'mouse', 'pencil', 'door', 'sink', 'table']  Task:Browse internet  response:

{  Go to home office and browse the internet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'ground_coffee', 'bathroom', 'dough', 'wallshelf', 'phone', 'character', 'keyboard', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'mousepad', 'couch', 'powersocket', 'cutting_board', 'bed', 'food_food', 'food_rice', 'tray', 'wooden_spoon', 'pencil', 'headset', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher']  Task:Pet cat  response:  {       thoughts : find the cat, go near the cat and pet the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['food_pizza', 'tablelamp', 'dog', 'cat', 'drawing', 'food_egg', 'floor', 'phone', 'piano_bench', 'mat', 'mousepad', 'oil', 'food_jam', 'pillow', 'wall_clock', 'photoframe', 'coffe_maker', 'food_donut', 'food_rice', 'tray', 'after_shave', 'kitchen_counter', 'clothes_dress', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard']  Task:Pick up phone  response:

{  walk to living room , find phone ,pick up phone 3 }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'pot', 'microwave', 'walllamp', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'ceilinglamp', 'plate', 'faucet', 'window', 'dish_soap', 'mousepad', 'bowl', 'wall', 'oven', 'powersocket', 'check', 'mouthwash', 'after_shave', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathtub', 'dishwasher']  Task:Wash dishes by hand  response:  {       thoughts : I go to the kitchen and turn on the faucet. I get dish soap and put it into the sink. I grab a sponge and a bowl and start cleaning it. I put the bowl into the dishrack. I find a plate and clean it as well. I put it into the dishrack, turn off the faucet and put the sponge back.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <bowl>', '[GRAB] <bowl>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <bowl>', '[SCRUB] <bowl>', '[RINSE] <bowl>', '[FIND] <dishrack>', '[PUTBACK] <bowl> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>']  }     Scene_Objects:['dry_pasta', 'toilet', 'nail_polish', 'detergent', 'cat', 'trashcan', 'milk', 'knifeblock', 'phone', 'ceiling', 'desk', 'keyboard', 'mousepad', 'couch', 'pillow', 'bench', 'oven', 'cup', 'bed', 'light_bulb', 'food_food', 'lighter', 'kitchen_counter', 'hairbrush', 'dresser', 'laundry_detergent', 'table', 'clothes_skirt', 'tooth_paste', 'dirt']  Task:Pet cat  response:

{  Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'mousepad', 'dining_room', 'wall', 'nightstand', 'bench', 'basket_for_clothes', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'wooden_spoon', 'mouse', 'dresser', 'sink', 'dishwasher']  Task:Go to sleep  response:  {       thoughts : go t the bedroom and go to sleep,       actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>']  }     Scene_Objects:['sheets', 'water_glass', 'pot', 'spectacles', 'chair', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'ceiling', 'character', 'stovefan', 'mat', 'faucet', 'food_orange', 'wall', 'oven', 'cutting_board', 'food_food', 'water', 'tray', 'food_onion', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'home_office']  Task:Drink  response:

{  I go to the kitchen, take a glass from the cupboard, fill with water and drink }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light']  Task:Pet cat  response:  {       thoughts : Pet Cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'filing_cabinet', 'tablelamp', 'beer', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'cat', 'cpuscreen', 'phone', 'character', 'food_cake', 'computer', 'piano_bench', 'brush', 'clothes_pants', 'dining_room', 'nightstand', 'cutting_board', 'toilet_paper', 'coffe_maker', 'check', 'curtain', 'kitchen_counter', 'table', 'scrabble', 'creditcard']  Task:Pet cat  response:

{  Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'beer', 'microwave', 'chair', 'drawing', 'hanger', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'bookmark', 'laptop', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'photoframe', 'newspaper', 'razor', 'tray', 'kitchen_counter', 'vacuum_cleaner', 'clothes_dress', 'door', 'bathroom_cabinet', 'tooth_paste']  Task:Write an email  response:  {       thoughts : I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email.,       actions : ['[WALK] <bathroom>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'microwave', 'toilet', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'phone', 'desk', 'envelope', 'table_cloth', 'ceilinglamp', 'plate', 'faucet', 'picture', 'couch', 'clothes_pants', 'powersocket', 'bench', 'newspaper', 'tray', 'rag', 'kitchen_counter', 'laundry_detergent', 'soap', 'scrabble', 'washing_machine']  Task:Wash clothes  response:

{  Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'window', 'pillow', 'wall', 'powersocket', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bathtub', 'light', 'teeth', 'shoe_rack']  Task:Go to toilet  response:  {       thoughts : walk to bathroom , run to toilet,       actions : ['[WALK] <bathroom>', '[RUN] <toilet>']  }     Scene_Objects:['blender', 'band-aids', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'dough', 'drawing', 'bills', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'character', 'desk', 'purse', 'alcohol', 'clothes_jacket', 'toaster', 'mat', 'faucet', 'oil', 'couch', 'broom', 'oven', 'photoframe', 'tray', 'kitchen_counter', 'dresser', 'laser_pointer']  Task:Pet cat  response:

{  Find a cat in the kitchen and touch 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:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table']  Task:Browse internet  response:  {       thoughts : go to the office, turn computer on, open an browser or any application to open any website.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>']  }     Scene_Objects:['food_salt', 'tea', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'picture', 'electric_shaver', 'pillow', 'wall', 'coffe_maker', 'food_food', 'coffee_filter', 'oven_mitts', 'water', 'ice', 'coffee_pot', 'kitchen_counter', 'cd', 'dishrack', 'cupboard', 'instrument_guitar', 'home_office', 'dishwasher']  Task:Make coffee  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:['scissors', 'food_ice_cream', 'walllamp', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'shampoo', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'check', 'television', 'coin', 'curtain', 'doorjamb', 'cards', 'shoes', 'cupboard', 'door', 'sink', '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:['sheets', 'filing_cabinet', 'blender', 'toilet', 'jelly', 'chair', 'drawing', 'bathroom_counter', 'floor', 'character', 'food_bacon', 'mat', 'shoe-shine_kit', 'shower', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'pasta', 'oven', 'newspaper', 'check', 'television', 'ice', 'tray', 'doorjamb', 'pencil', 'comb', 'dresser', 'bathroom_cabinet']  Task:Go to toilet  response:  {       thoughts : Walk to the bathroom. Pull down pants. Use the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[PULL] <clothes_pants>', '[FIND] <toilet>', '[SIT] <toilet>']  }     Scene_Objects:['sheets', 'tablelamp', 'juice', 'walllamp', 'bathroom', 'drawing', 'hanger', 'floor', 'character', 'desk', 'tea_bag', 'mop_bucket', 'plate', 'faucet', 'couch', 'dining_room', 'broom', 'nightstand', 'bench', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'food_food', 'television', 'dresser', 'cupboard', 'home_office', 'tooth_paste', 'coffee']  Task:Listen to music  response:

{  I walk into the living room. I find the stereo and turn it on, and I 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:['pot', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'food_egg', 'cpuscreen', 'floor', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'laptop', 'picture', 'mousepad', 'dining_room', 'wall', 'nightstand', 'photoframe', 'bed', 'mouse', 'kitchen_counter', 'maindoor', 'home_office', 'light', 'clothes_skirt']  Task:Write an email  response:  {       thoughts : walk to home office and switch on laptop and with the useof mouse and keyboard send mail,       actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['pot', 'tablelamp', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet']  Task:Listen to music  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'stereo', 'faucet', 'picture', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'home_office', 'light']  Task:Listen to music  response:  {       thoughts : I go to the bedroom and sit at my desk. I turn my radio on and listen to music.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['fork', 'juice', 'food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'faucet', 'food_noodles', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'box', 'photoframe', 'coffe_maker', 'mouse', 'kitchen_counter', 'door', 'food_steak', 'table', 'colander', 'creditcard']  Task:Work  response:

{  turn computer on, open application to work with }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'door', 'table', 'light', 'coffee']  Task:Watch TV  response:  {       thoughts : I walk into the living room and sit on the sofa to watch tv,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['tea', 'microwave', 'toilet', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'envelope', 'toaster', 'plate', 'shower', 'stereo', 'dish_soap', 'wall', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'food_food', 'mouthwash', 'check', 'curtain', 'kitchen_counter', 'cupboard', 'pajamas', 'conditioner', 'sink', 'spoon', 'home_office', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'blender', 'food_salt', 'toilet', 'walllamp', 'bathroom', 'food_butter', 'drawing', 'hanger', 'shampoo', 'bedroom', 'purse', 'computer', 'stovefan', 'laptop', 'ceilinglamp', 'electric_shaver', 'window', 'homework', 'clothes_socks', 'wall_clock', 'shelf', 'basket_for_clothes', 'bed', 'coffe_maker', 'check', 'wooden_spoon', 'centerpiece', 'lighter', 'kettle']  Task:Browse internet  response:  {       thoughts : The task is browse and surf on the internet regarding a particular topic,       actions : ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']  }     Scene_Objects:['food_bread', 'microwave', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'keyboard', 'computer', 'alcohol', 'toaster', 'stovefan', 'shower', 'dustpan', 'pillow', 'wall', 'nightstand', 'bench', 'coffe_maker', 'check', 'food_food', 'coffee_filter', 'water', 'kitchen_counter', 'cupboard', 'table', 'dishwasher', 'tooth_paste', 'coffee']  Task:Make coffee  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack']  Task:Wash hands  response:  {       thoughts : I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']  }     Scene_Objects:['scissors', 'chair', 'walllamp', 'drawing', 'orchid', 'floor', 'phone', 'keyboard', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'stereo', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'curtain', 'cd', 'dishrack', 'dresser', 'cupboard', 'table', 'laser_pointer', 'clothes_shirt', 'creditcard']  Task:Relax on sofa  response:

{  go to the living room,find the sofa,sat down in the sofa,take some relaxation. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'trashcan', 'dough', 'food_carrot', 'knife', 'drawing', 'clothes_underwear', 'hanger', 'dvd_player', 'character', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'tape', 'food_food', 'television', 'coffee_filter', 'ice', 'wooden_spoon', 'tray', 'lighter', 'chessboard', 'spoon', 'home_office', 'table', 'clothes_shirt']  Task:Pick up phone  response:  {       thoughts : I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>', '[SWITCHON] <phone>']  }     Scene_Objects:['fork', 'food_salt', 'toilet', 'bathroom', 'nail_polish', 'toothbrush', 'phone', 'character', 'mat', 'shower', 'stereo', 'towel', 'dining_room', 'oven', 'basket_for_clothes', 'novel', 'television', 'oven_mitts', 'food_donut', 'tray', 'doorjamb', 'cards', 'kitchen_counter', 'dishrack', 'pajamas', 'door', 'napkin', 'light', 'table', 'soap']  Task:Pet cat  response:

{  Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'mop', 'microwave', 'ground_coffee', 'walllamp', 'cat', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'toaster', 'brush', 'tvstand', 'shower', 'faucet', 'food_jam', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'dishwasher', 'scrabble']  Task:Make coffee  response:  {       thoughts : Make coffee in the kitchen.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[PLUGIN] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'walllamp', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'hanger', 'floor', 'faucet', 'shower', 'clothes_hat', 'wall', 'nightstand', 'tape', 'cup', 'food_food', 'water', 'tray', 'diary', 'pencil', 'kitchen_counter', 'headset', 'hairbrush', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'soap']  Task:Drink  response:

{  Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Wash hands with soap,       actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>']  }     Scene_Objects:['pot', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'mop_bucket', 'table_cloth', 'toaster', 'stovefan', 'plate', 'microphone', 'clothes_pants', 'dining_room', 'wall', 'pasta', 'cup', 'coffe_maker', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'home_office', 'light', 'dishwasher', 'colander', 'tooth_paste']  Task:Wash dishes with dishwasher  response:

{  Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer 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', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'bag', 'light', 'table']  Task:Turn on computer  response:  {       thoughts : Press the power button on the computer to turn it on,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['chair', 'jelly', 'walllamp', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'stamp', 'keyboard', 'food_cake', 'computer', 'mop_bucket', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'bench', 'toy', 'food_cheese', 'novel', 'curtain', 'mouse', 'shoes', 'sink', 'table', 'creditcard']  Task:Read book  response:

{  I walk to home office and search for a book, and sit to the chair with a table, and start reading. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:['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:

{  Walk into the living room. Walk up to the cat. Pet the cat with your hand. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'toilet', 'dog', 'freezer', 'drawing', 'cpuscreen', 'phone', 'tea_bag', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'window', 'oil', 'food_orange', 'food_cheese', 'clothes_gloves', 'toilet_paper', 'food_food', 'television', 'coffee_filter', 'check', 'curtain', 'kettle', 'mouse', 'food_steak', 'spoon', 'instrument_guitar', 'light', 'dishwasher']  Task:Walk to room  response:  {       thoughts : Leave the living room and enter the hall,       actions : ['[WALK] <home_office>', '[WALK] <home_office>']  }     Scene_Objects:['pot', 'water_glass', 'dog', 'walllamp', 'knifeblock', 'bills', 'floor', 'ceiling', 'stovefan', 'brush', 'mat', 'faucet', 'homework', 'wall', 'pasta', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'board_game', 'clothes_shirt', 'dirt']  Task:Drink  response:

{  I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'novel', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'table']  Task:Read  response:  {       thoughts : Read a book in the living room,       actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>']  }     Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'remote_control', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mat', 'picture', 'window', 'faucet', 'couch', 'clothes_hat', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']  Task:Relax on sofa  response:

{  Go into the living room. Walk over to the sofa. Lie down on the sofa. Turn on and watch TV. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'filing_cabinet', 'juice', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'shower', 'faucet', 'window', 'mousepad', 'food_orange', 'wall', 'television', 'curtain', 'after_shave', 'mouse', 'dresser', 'door', 'napkin', 'table']  Task:Clean screen  response:  {       thoughts : Use a soft rag to wipe the screen until there are no marks on it.,       actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['sponge', 'microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'button', 'toaster', 'window', 'mousepad', 'clothes_pants', 'wall', 'basket_for_clothes', 'coffe_maker', 'check', 'television', 'toothbrush_holder', 'ice', 'diary', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'pajamas', 'napkin', 'coffee_cup', 'dishwasher', 'soap', 'coffee']  Task:Make coffee  response:

{  Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'mat', 'ceilinglamp', 'shower', 'oil', 'food_peanut_butter', 'food_orange', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'pencil', 'dresser', 'door', 'napkin', 'light', 'shoe_rack']  Task:Put groceries in Fridge  response:  {       thoughts : put away groceries in fridge. open the door, put on shelf, close the door.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['sheets', 'pot', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'mat', 'faucet', 'couch', 'dining_room', 'wall', 'newspaper', 'toilet_paper', 'television', 'oven_mitts', 'water', 'tray', 'vacuum_cleaner', 'controller', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'instrument_guitar', 'light', 'soap', 'teeth']  Task:Wash teeth  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'food_jam', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'food_vegetable', 'photoframe', 'basket_for_clothes', 'doorjamb', 'mouse', 'door', 'table', 'light']  Task:Chop vegetables  response:  {       thoughts : Cut up veggies with knife,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <cutting_board>', '[GRAB] <cutting_board>', '[CLOSE] <kitchen_cabinet>', '[WALK] <table>', '[PUTBACK] <knife> <table>', '[PUTBACK] <cutting_board> <table>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <food_vegetable> <cutting_board>', '[GRAB] <knife>', '[CUT] <food_vegetable>', '[PUTOBJBACK] <knife>']  }     Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'stovefan', 'homework', 'wall', 'novel', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'after_shave', 'diary', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'food_steak', 'dishwasher']  Task:Make coffee  response:

{  Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch 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:['sponge', 'microwave', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'window', 'dish_soap', 'food_noodles', 'closetdrawer', 'couch', 'towel', 'dining_room', 'wall', 'wine', 'rag', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'conditioner', 'sink', 'table', 'dishwasher', 'soap']  Task:Wash dishes  response:  {       thoughts : Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>']  }     Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'dresser', 'hairbrush', 'clothes_dress', 'door', 'sink', 'spoon', 'table', 'light']  Task:Change TV channel  response:

{  I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV 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:['sheets', 'pot', 'microwave', 'walllamp', 'food_carrot', 'character', 'desk', 'keyboard', 'shower', 'washing_machine', 'window', 'mousepad', 'clothes_pants', 'towel', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'headset', 'chessboard', 'hair', 'napkin', 'table', 'soap', 'scrabble', 'dirt', 'coffee', 'creditcard']  Task:Wash clothes  response:  {       thoughts : walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'toaster', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'doorjamb', 'pencil', 'dresser', 'door', 'home_office', 'table', 'light']  Task:Change TV channel  response:

{  Change the channel on the TV 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:['dry_pasta', 'food_bread', 'microwave', 'freezer', 'ground_coffee', 'dough', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'faucet', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'cupboard', 'sink']  Task:Make coffee  response:  {       thoughts : I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['glue', 'filing_cabinet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'shoe-shine_kit', 'mousepad', 'pillow', 'wall', 'powersocket', 'cup', 'bed', 'wooden_spoon', 'coffee_pot', 'mouse', 'kitchen_counter', 'door', 'home_office', 'table']  Task:Write an email  response:

{  I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'filing_cabinet', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'ceiling', 'computer', 'shower', 'window', 'mousepad', 'couch', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'bench', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'razor', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'home_office', 'light', 'washing_machine']  Task:Wash clothes  response:  {       thoughts :  I walk to entrance hall   I walk to bedroom   I find basket of clothes   I lift basket of  clothes   I walk to kitchen   I find washing machine   I open washing machine    I put laundry in washing machine   I add laundry detergent     I close washing machine lid   I switch washing machine on ,       actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']  }     Scene_Objects:['sponge', 'pot', 'blender', 'food_ice_cream', 'microwave', 'chair', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'bedroom', 'computer', 'toaster', 'plate', 'shoe-shine_kit', 'oil', 'wall', 'newspaper', 'coffe_maker', 'tray', 'centerpiece', 'console', 'pencil', 'kitchen_counter', 'cupboard', 'spoon', 'dishwasher', 'laser_pointer', 'clothes_shirt']  Task:Wash dishes with dishwasher  response:

{  I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher. }