Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'mat', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'cutting_board', 'cup', 'novel', 'food_food', 'television', 'wine', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'board_game']  Task:Relax on sofa  response:  {       thoughts : lie in the sofa, relax,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']  }     Scene_Objects:['sponge', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'foundation', 'couch', 'microphone', 'wall', 'powersocket', 'oven', 'bed', 'television', 'wooden_spoon', 'doorjamb', 'lighter', 'dresser', 'door', 'table']  Task:Change TV channel  response:

{  I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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:['scissors', 'food_ice_cream', 'chair', 'bathroom', 'trashcan', 'food_carrot', 'shampoo', 'phone', 'floor', 'stamp', 'bookshelf', 'ceilinglamp', 'window', 'homework', 'couch', 'clothes_pants', 'pillow', 'nightstand', 'cup', 'bed', 'check', 'food_food', 'ice', 'headset', 'cupboard', 'door', 'home_office', 'light', 'dishwasher', 'clothes_shirt']  Task:Pick up phone  response:

{  walk to phone, grab phone, pick up phone, put to ear }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'blow_dryer', 'detergent', 'knife', 'orchid', 'bathroom_counter', 'shampoo', 'keyboard', 'bookshelf', 'mail', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'faucet', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'cup', 'light_bulb', 'food_food', 'television', 'food_onion', 'pencil', 'napkin', 'light']  Task:Drink  response:  {       thoughts : Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.,       actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'detergent', 'food_egg', 'cpuscreen', 'phone', 'folder', 'character', 'keyboard', 'envelope', 'piano_bench', 'ceilinglamp', 'plate', 'faucet', 'couch', 'coffe_maker', 'food_donut', 'tray', 'centerpiece', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'bathroom_cabinet', 'light']  Task:Pick up phone  response:

{  I walk to the home office, find where the phone is and lift the reciever. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'chair', 'walllamp', 'dough', 'orchid', 'cpuscreen', 'hanger', 'floor', 'keyboard', 'remote_control', 'food_cake', 'envelope', 'computer', 'button', 'food_bacon', 'ceilinglamp', 'stereo', 'homework', 'oven', 'tape', 'photoframe', 'coffee_table', 'keys', 'check', 'novel', 'light_bulb', 'wooden_spoon', 'curtain', 'cd', 'home_office']  Task:Change TV channel  response:  {       thoughts : walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the remote.,       actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['pot', 'filing_cabinet', 'food_bread', 'microwave', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'box', 'oven_mitts', 'food_onion', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'door', 'light', 'soap']  Task:Turn on light  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'food_salt', 'jelly', 'band-aids', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'broom', 'wall', 'powersocket', 'doorjamb', 'lighter', 'door', 'sink', 'light', 'table', 'laser_pointer', 'clothes_shirt', 'creditcard']  Task:Turn on light  response:  {       thoughts : I go into my room, find the light,  then turn on the lights.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[WALK] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'dustpan', 'pillow', 'broom', 'wall', 'powersocket', 'cup', 'video_game_controller', 'television', 'doorjamb', 'hairbrush', 'door', 'sink', 'bag', 'table']  Task:Watch TV  response:

{  Walk to living room.  Find remote control.  Find television.  Point remote at television.  Press \ on\  button.  Watch. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'food_pizza', 'filing_cabinet', 'toilet', 'walllamp', 'detergent', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'faucet', 'balanceball', 'picture', 'wall', 'oven', 'tape', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'towel_rack', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['tea', 'walllamp', 'drawing', 'orchid', 'food_egg', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'shower', 'couch', 'clothes_hat', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'television', 'food_onion', 'doorjamb', 'controller', 'door', 'table']  Task:Change TV channel  response:

{  Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'filing_cabinet', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'toaster', 'faucet', 'stereo', 'couch', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'bed', 'photoframe', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Washing Hands,       actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[TOUCH] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['pot', 'microwave', 'band-aids', 'walllamp', 'drawing', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'plate', 'oil', 'mousepad', 'wall', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'doorjamb', 'door', 'napkin', 'table', 'teeth']  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:['sponge', 'water_glass', 'pot', 'glue', 'walllamp', 'trashcan', 'knifeblock', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'mat', 'faucet', 'microphone', 'wall', 'cup', 'bed', 'food_food', 'check', 'water', 'food_donut', 'curtain', 'kitchen_counter', 'chessboard', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'bathroom_cabinet', 'dirt']  Task:Drink  response:  {       thoughts : I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['food_salt', 'microwave', 'cat', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'table_cloth', 'mat', 'plate', 'stereo', 'ceilinglamp', 'tvstand', 'electric_shaver', 'microphone', 'wall', 'powersocket', 'light_bulb', 'keys', 'doorjamb', 'pencil', 'laundry_detergent', 'door', 'clothes_scarf', 'sink', 'spoon', 'light']  Task:Turn on light  response:

{  I open the room door and press the light button on }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'drawing', 'orchid', 'knifeblock', 'bills', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'shower', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'home_office', 'table', 'light', 'bathroom_cabinet']  Task:Relax on sofa  response:  {       thoughts : Walk into the living room. Walk up to the sofa. Sit down on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'jelly', 'chair', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'bathroom_counter', 'keyboard', 'alcohol', 'clothes_jacket', 'stovefan', 'mat', 'toaster', 'stereo', 'picture', 'ceilinglamp', 'dining_room', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'check', 'video_game_controller', 'razor', 'food_food', 'curtain', 'shoes']  Task:Listen to music  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:['measuring_cup', 'microwave', 'cat', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'desk', 'mat', 'deck_of_cards', 'iron', 'stereo', 'balanceball', 'shower', 'faucet', 'mousepad', 'nightstand', 'oven', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'vase']  Task:Walk through  response:  {       thoughts : Walk through the hallway.,       actions : ['[WALK] <home_office>', '[WALK] <home_office>']  }     Scene_Objects:['scissors', 'chair', 'freezer', 'floor', 'phone', 'character', 'thread', 'ceilinglamp', 'stereo', 'shower', 'window', 'mousepad', 'pillow', 'broom', 'wall', 'cup', 'photoframe', 'clothes_gloves', 'food_food', 'coffe_maker', 'razor', 'lighter', 'doorjamb', 'shoes', 'hairbrush', 'napkin', 'bathroom_cabinet', 'table', 'laser_pointer', 'clothes_shirt']  Task:Listen to music  response:

{  Find the radio; switch on the radio and listen to music. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'food_bread', 'microwave', 'chair', 'band-aids', 'woman', 'needle', 'longboard', 'man', 'keyboard', 'envelope', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'nightstand', 'box', 'light_bulb', 'coffe_maker', 'curtain', 'towel_rack', 'shoes', 'dresser', 'hairbrush', 'door', 'vase', 'instrument_violin', 'creditcard']  Task:Greet guests  response:  {       thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']  }     Scene_Objects:['filing_cabinet', 'dog', 'walllamp', 'bathroom', 'drawing', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'ceilinglamp', 'tvstand', 'shower', 'window', 'foundation', 'couch', 'pillow', 'wall', 'razor', 'toothbrush_holder', 'tray', 'curtain', 'mouse', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:

{  allow sofa to support weight in order to decrease gravity induced entropy }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'blender', 'crayon', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'oven', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'curtain', 'hairbrush', 'food_steak', 'bag', 'table']  Task:Relax on sofa  response:  {       thoughts : walk to living room, find sofa, sit in sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['jelly', 'trashcan', 'cpuscreen', 'clothes_underwear', 'ceiling', 'folder', 'desk', 'computer', 'stovefan', 'shower', 'mousepad', 'candle', 'clothes_hat', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'video_game_controller', 'oven_mitts', 'curtain', 'pencil', 'kitchen_counter', 'dishrack', 'laundry_detergent', 'door', 'light', 'dishwasher', 'soap', 'tooth_paste', 'washing_machine']  Task:Wash clothes  response:

{  Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'mop', 'toilet', 'freezer', 'walllamp', 'bathroom', 'cat', 'food_butter', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'toy', 'tape', 'photoframe', 'television', 'food_rice', 'doorjamb', 'cards', 'door']  Task:Relax on sofa  response:  {       thoughts : walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'orchid', 'drawing', 'bedroom', 'tea_bag', 'bookshelf', 'envelope', 'alcohol', 'computer', 'ceilinglamp', 'mat', 'shower', 'deck_of_cards', 'food_noodles', 'microphone', 'bowl', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'dresser', 'napkin', 'table', 'clothes_shirt']  Task:Pet cat  response:

{  First I need to find the cat in the living room. Then I walk over to the cat and pet it gently. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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_ice_cream', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'toothbrush_holder', 'doorjamb', 'mouse', 'light', 'vase']  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:['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:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_pizza', 'filing_cabinet', 'nail_polish', 'toothbrush', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'food_food', 'toothbrush_holder', 'tray', 'dresser', 'cupboard', 'controller', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'light', 'tooth_paste']  Task:Wash teeth  response:  {       thoughts : 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.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>']  }     Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'toilet', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bills', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'plate', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'console', 'door', 'table']  Task:Watch TV  response:

{  go to living room, sit on couch, get remote, switch on tv, 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:['chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'food_steak', 'sink', 'bathroom_cabinet', 'table']  Task:Browse internet  response:  {       thoughts : I sit at my computer desk and open the browser.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['pot', 'microwave', 'freezer', 'bathroom', 'trashcan', 'dough', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'computer', 'toaster', 'ceilinglamp', 'mat', 'deck_of_cards', 'mousepad', 'clothes_socks', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'food_food', 'doorjamb', 'mouse', 'door', 'light']  Task:Put groceries in Fridge  response:

{  Open the fridge, and put groceries in the fridge. 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:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee']  Task:Bring dirty plate to sink  response:  {       thoughts : Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink.,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>']  }     Scene_Objects:['sheets', 'freezer', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'food_food', 'food_donut', 'tray', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'dresser', 'food_steak', 'door', 'bathroom_cabinet', 'light', 'clothes_skirt']  Task:Cook some food  response:

{  Go kitchen and make something for eat }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toilet', 'freezer', 'cat', 'orchid', 'drawing', 'hanger', 'ceiling', 'dvd_player', 'desk', 'mail', 'piano_bench', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'food_orange', 'pillow', 'bench', 'bed', 'check', 'doorjamb', 'cd', 'controller', 'laundry_detergent', 'sink', 'home_office', 'dishwasher']  Task:Pet cat  response:  {       thoughts : I go to the living room then go to the cat and touch it.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['measuring_cup', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'phone', 'character', 'stamp', 'tea_bag', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'brush', 'window', 'couch', 'food_orange', 'pillow', 'wall', 'bench', 'tray', 'curtain', 'after_shave', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'soap']  Task:Relax on sofa  response:

{  Sitting down and relaxing on the sofa }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'drawing', 'hanger', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'foundation', 'oil', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'novel', 'television', 'curtain', 'after_shave', 'door', 'napkin', 'home_office', 'table']  Task:Turn off TV  response:  {       thoughts : Walk over to tv and press power button,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>']  }     Scene_Objects:['spectacles', 'blender', 'food_salt', 'jelly', 'freezer', 'orchid', 'drawing', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'toaster', 'tvstand', 'shower', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'bed', 'food_food', 'tray', 'doorjamb', 'cards', 'controller', 'door', 'light', 'dishwasher']  Task:Turn on light  response:

{  I enter the bedroom and find the light. Then I turn it on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee']  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:['pot', 'tablelamp', 'freezer', 'bathroom', 'detergent', 'food_butter', 'drawing', 'hanger', 'phone', 'bedroom', 'desk', 'toaster', 'brush', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'dining_room', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'mouthwash', 'television', 'curtain', 'doorjamb', 'mouse', 'napkin', 'teeth']  Task:Listen to music  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'stereo', 'tvstand', 'towel', 'pillow', 'wall', 'pasta', 'powersocket', 'coffe_maker', 'oven_mitts', 'tray', 'curtain', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['filing_cabinet', 'food_ice_cream', 'bathroom', 'food_carrot', 'knifeblock', 'hanger', 'bookshelf', 'computer', 'button', 'stovefan', 'couch', 'candle', 'dining_room', 'wall', 'bench', 'basket_for_clothes', 'newspaper', 'light_bulb', 'check', 'coffe_maker', 'television', 'after_shave', 'curtain', 'comb', 'pajamas', 'hair', 'door', 'sink', 'dishwasher', 'colander']  Task:Pet cat  response:

{  Walk to living room. Find the cat. Walk over to the cat. Touch the cat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'beer', 'microwave', 'chair', 'freezer', 'ground_coffee', 'floor', 'ceiling', 'mail', 'food_bacon', 'toaster', 'deck_of_cards', 'faucet', 'window', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'light_bulb', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'after_shave', 'pencil', 'kitchen_counter', 'pajamas', 'sink', 'light']  Task:Make coffee  response:  {       thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <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:['filing_cabinet', 'chair', 'freezer', 'dog', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'envelope', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'pasta', 'nightstand', 'bench', 'photoframe', 'tray', 'mouse', 'door', 'table', 'soap']  Task:Work  response:

{  go to home office. turn the computer on. begin working }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'table', 'light']  Task:Watch TV  response:  {       thoughts : Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[WATCH] <television>']  }     Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'oven', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'curtain', 'hairbrush', 'food_steak', 'bag', 'table']  Task:Relax on sofa  response:

{  walk to living room, find sofa, sit in 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:['filing_cabinet', 'mop', 'chair', 'band-aids', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'laptop', 'toaster', 'foundation', 'pillow', 'wall', 'powersocket', 'bench', 'novel', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light', 'soap', 'instrument_violin']  Task:Turn off light  response:  {       thoughts : Grasp light switch, flip light switch.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['walllamp', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'food_noodles', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'pencil', 'hair', 'door', 'table', 'instrument_violin']  Task:Watch TV  response:

{  Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table']  Task:Give milk to cat  response:  {       thoughts : Grab milk and pour it into the plate so that the cat can drink,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[POINTAT] <cat>', '[PULL] <cat>', '[FIND] <milk>', '[GRAB] <milk>', '[FIND] <plate>', '[POUR] <milk> <plate>', '[TOUCH] <cat>', '[SCRUB] <cat>']  }     Scene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'cup', 'television', 'food_rice', 'curtain', 'doorjamb', 'diary', 'shoes', 'door', 'spoon', 'bathroom_cabinet', 'table']  Task:Watch TV  response:

{  I walk into the living room and sit on the sofa to 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:['dry_pasta', 'sponge', 'scissors', 'food_salt', 'trashcan', 'drawing', 'needle', 'hanger', 'longboard', 'floor', 'character', 'stamp', 'keyboard', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'window', 'couch', 'dining_room', 'wall', 'photoframe', 'television', 'curtain', 'rag', 'pencil', 'shoes', 'clothes_dress', 'conditioner', 'sink', 'table']  Task:Text friends while sitting on couch  response:  {       thoughts : Text while sitting,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[TOUCH] <phone>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'deck_of_cards', 'window', 'tvstand', 'mousepad', 'pillow', 'wall', 'pasta', 'light_bulb', 'check', 'mouthwash', 'wooden_spoon', 'mouse', 'door', 'table', 'coffee']  Task:Browse internet  response:

{  Turn on computer, pull up browser, 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:['sponge', 'toilet', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'clothes_gloves', 'novel', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light', 'dishwasher']  Task:Pet cat  response:  {       thoughts : walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['glue', 'pot', 'tablelamp', 'microwave', 'drawing', 'knife', 'knifeblock', 'hanger', 'bathroom_counter', 'phone', 'stovefan', 'laptop', 'faucet', 'foundation', 'couch', 'food_orange', 'pillow', 'bowl', 'bench', 'oven', 'basket_for_clothes', 'cup', 'novel', 'razor', 'centerpiece', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'soap']  Task:Turn on light  response:

{  Walk to the living room, walk to the lamp, switch on the lamp. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'shower', 'closetdrawer', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'sink', 'home_office', 'table', 'light', 'coffee']  Task:Walk through  response:  {       thoughts : Walk through the hallway.,       actions : ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']  }     Scene_Objects:['spectacles', 'sheets', 'sponge', 'chair', 'freezer', 'trashcan', 'ceiling', 'stamp', 'desk', 'keyboard', 'table_cloth', 'stovefan', 'ceilinglamp', 'shower', 'iron', 'electric_shaver', 'mousepad', 'clothes_socks', 'powersocket', 'oven', 'tray', 'kitchen_counter', 'dishrack', 'hair', 'cupboard', 'door', 'hairdryer', 'bathroom_cabinet', 'instrument_guitar', 'coffee']  Task:Listen to music  response:

{  walk to living room ,find radio ,switch on radio ,listen to music 4 }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'freezer', 'ground_coffee', 'dough', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'bedroom', 'tea_bag', 'toaster', 'faucet', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'coffe_maker', 'television', 'coffee_filter', 'water', 'mouse', 'kitchen_counter', 'sink', 'table']  Task:Make coffee  response:  {       thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['glue', 'food_bread', 'mop', 'freezer', 'trashcan', 'knifeblock', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'stovefan', 'mat', 'faucet', 'pillow', 'wall', 'powersocket', 'bed', 'food_food', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'chessboard', 'dresser', 'cupboard', 'hair', 'door', 'instrument_guitar', 'light', 'creditcard']  Task:Turn on light  response:

{  Walk into living room. Find wall. Find light button. Switch on light button. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light']  Task:Write an email  response:  {       thoughts : I need to write an e-mail to my boss about the meeting at work tomorrow.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TYPE] <keyboard>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['microwave', 'toilet', 'knifeblock', 'floor', 'ceiling', 'purse', 'computer', 'table_cloth', 'stovefan', 'mat', 'faucet', 'window', 'bowl', 'wall', 'powersocket', 'cutting_board', 'television', 'razor', 'tray', 'after_shave', 'doorjamb', 'shoes', 'comb', 'dresser', 'door', 'home_office', 'light', 'dishwasher', 'soap', 'coffee']  Task:Turn on light  response:

{  I walk in to the living room. I find the light switch. I turn on the lights. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_ice_cream', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'mail', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'after_shave', 'doorjamb', 'chessboard', 'door', 'food_steak', 'bathroom_cabinet', 'table', 'board_game']  Task:Watch TV  response:  {       thoughts : I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'powersocket', 'clothes_gloves', 'television', 'razor', 'curtain', 'doorjamb', 'console', 'mouse', 'door', 'bag', 'table', 'dishwasher']  Task:Change TV channel  response:

{  I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch 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:['microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'tea_bag', 'computer', 'food_bacon', 'tvstand', 'iron', 'window', 'electric_shaver', 'mousepad', 'dining_room', 'wall', 'nightstand', 'wall_clock', 'photoframe', 'towel_rack', 'mouse', 'table']  Task:Check email  response:  {       thoughts : Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond.,       actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'cpuscreen', 'hanger', 'floor', 'keyboard', 'purse', 'bookshelf', 'food_bacon', 'button', 'toaster', 'laptop', 'stereo', 'couch', 'wall', 'bench', 'basket_for_clothes', 'toothbrush_holder', 'curtain', 'rag', 'diary', 'cards', 'cupboard', 'controller', 'laundry_detergent', 'soap', 'tooth_paste', 'washing_machine', 'creditcard']  Task:Wash clothes  response:

{  I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'tvstand', 'shower', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'cup', 'bed', 'coffe_maker', 'food_food', 'doorjamb', 'towel_rack', 'pencil', 'headset', 'chessboard', 'dresser', 'hairbrush', 'door', 'clothes_scarf', 'light']  Task:Turn on light  response:  {       thoughts : I go into my room, find the light,  then turn on the lights.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[WALK] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee']  Task:Browse internet  response:

{  The task is browse and surf on the internet regarding a particular topic }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'toilet', 'detergent', 'cpuscreen', 'food_egg', 'bathroom_counter', 'floor', 'folder', 'desk', 'envelope', 'clothes_jacket', 'mat', 'plate', 'stereo', 'deck_of_cards', 'shower', 'couch', 'television', 'oven_mitts', 'curtain', 'shaving_cream', 'chessboard', 'cupboard', 'conditioner', 'light', 'table', 'soap', 'clothes_shirt']  Task:Dust  response:  {       thoughts : Get a broom or duster with long handle. Dust blades of ceiling fan.,       actions : ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>']  }     Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'stamp', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'mat', 'mousepad', 'clothes_pants', 'wall', 'cutting_board', 'food_cheese', 'keys', 'food_food', 'video_game_controller', 'toothbrush_holder', 'mouse', 'pencil', 'door', 'sink', 'table', 'light', 'dirt']  Task:Browse internet  response:

{  Go to home office, turn on the computer, open the internet and browse around 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:['sponge', 'pot', 'bathroom', 'knifeblock', 'bathroom_counter', 'shampoo', 'phone', 'mail', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'window', 'clothes_socks', 'couch', 'clothes_pants', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'mouse', 'shoes', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt']  Task:Get dressed  response:  {       thoughts : Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes.,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTON] <clothes_socks>', '[CLOSE] <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']  }     Scene_Objects:['glue', 'filing_cabinet', 'toilet', 'food_butter', 'orchid', 'bathroom_counter', 'bedroom', 'tea_bag', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'window', 'food_noodles', 'couch', 'clothes_hat', 'pillow', 'bench', 'powersocket', 'basket_for_clothes', 'television', 'oven_mitts', 'kitchen_counter', 'shoes', 'pajamas', 'door', 'light', 'soap', 'washing_machine']  Task:Wash clothes  response:

{  Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'filing_cabinet', 'food_ice_cream', 'beer', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'dvd_player', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'wall', 'wall_clock', 'cup', 'bed', 'food_food', 'coin', 'food_rice', 'water', 'pencil', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Drink  response:  {       thoughts : Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']  }     Scene_Objects:['spectacles', 'sponge', 'measuring_cup', 'walllamp', 'nail_polish', 'drawing', 'orchid', 'floor', 'ceiling', 'dvd_player', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'broom', 'wall', 'powersocket', 'oven', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'mouse', 'bag', 'table']  Task:Relax on sofa  response:

{  I sit on the sofa. I put my legs on the sofa and recline. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'blow_dryer', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'picture', 'iron', 'mousepad', 'bowl', 'wall', 'powersocket', 'bench', 'photoframe', 'toilet_paper', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'dishrack', 'sink', 'bathroom_cabinet', 'home_office', 'light']  Task:Get toilet paper  response:  {       thoughts : There are extra toilet papers in the bottom cabinet.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']  }     Scene_Objects:['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:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light']  Task:Turn on light  response:  {       thoughts : walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']  }     Scene_Objects:['freezer', 'bathroom', 'detergent', 'cat', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'form', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'coffee_filter', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'controller', 'door', 'light', 'coffee']  Task:Put groceries in Fridge  response:

{  I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light']  Task:Change TV channel  response:  {       thoughts : first i will go to living room and then take the remote and swtitch on television after that il change the channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'crayon', 'walllamp', 'drawing', 'knifeblock', 'orchid', 'floor', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'window', 'couch', 'food_orange', 'pillow', 'dining_room', 'wall', 'powersocket', 'bench', 'cutting_board', 'curtain', 'cards', 'dresser', 'bag', 'table', 'light', 'colander', 'clothes_shirt']  Task:Relax on sofa  response:

{  Walk to the living room, turn to the sofa. Sit on the sofa and relax. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'console', 'dresser', 'cupboard', 'home_office', 'table', 'clothes_skirt', 'vase']  Task:Watch TV  response:  {       thoughts : Watch the television,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'food_butter', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'mousepad', 'wall', 'powersocket', 'photoframe', 'newspaper', 'ice', 'curtain', 'mouse', 'headset', 'hairbrush', 'door', 'bathroom_cabinet', 'table', 'clothes_shirt']  Task:Write an email  response:

{  walk into office, sit in chair, turn on computer, write email }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'freezer', 'detergent', 'knifeblock', 'phone', 'bookshelf', 'computer', 'mop_bucket', 'brush', 'clothes_socks', 'mousepad', 'dining_room', 'nightstand', 'basket_for_clothes', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'sink', 'home_office', 'napkin', 'dishwasher', 'bathroom_cabinet', '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:['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:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table']  Task:Pick up phone  response:  {       thoughts : I walk to the home office. I find the telephone. I pick up the telephone handset.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'dog', 'bathroom', 'knifeblock', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'bedroom', 'clothes_jacket', 'mat', 'tvstand', 'pillow', 'towel', 'wall', 'cup', 'food_donut', 'curtain', 'after_shave', 'dishrack', 'cupboard', 'controller', 'door', 'dishwasher']  Task:Pick up phone  response:

{  Walk to living room. Go near telephone. take the receiver and then talk to other person on that side. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'faucet', 'plate', 'mousepad', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'tape', 'cup', 'doorjamb', 'sink', 'light', 'table']  Task:Pick up phone  response:  {       thoughts : walk over and pick up the phone,       actions : ['[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'bathroom', 'nail_polish', 'detergent', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'table_cloth', 'stereo', 'mousepad', 'broom', 'wall', 'nightstand', 'powersocket', 'oven', 'television', 'rag', 'mouse', 'headset', 'door', 'shoe_rack']  Task:Listen to music  response:

{  I walk to my bedroom.  I locate my stereo and turn it on.  I put on my headphones and sit to listen. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light']  Task:Watch TV  response:  {       thoughts : Walk into the living room. Sit on the couch. Turn on TV.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['microwave', 'toilet', 'band-aids', 'detergent', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'stovefan', 'mat', 'tvstand', 'faucet', 'brush', 'window', 'oil', 'couch', 'bowl', 'wall', 'powersocket', 'coffee_pot', 'pencil', 'food_steak', 'sink', 'bag', 'bathroom_cabinet', 'tooth_paste', 'teeth']  Task:Wash teeth  response:

{  I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'walllamp', 'detergent', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'phone', 'character', 'computer', 'piano_bench', 'shoe-shine_kit', 'faucet', 'food_noodles', 'mousepad', 'clothes_hat', 'towel', 'broom', 'cutting_board', 'shelf', 'keys', 'novel', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'sink', 'table', 'light', 'coffee']  Task:Change TV channel  response:  {       thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>']  }     Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'beer', 'bathroom', 'food_butter', 'food_carrot', 'milk', 'bathroom_counter', 'bedroom', 'thread', 'table_cloth', 'bookmark', 'ceilinglamp', 'shower', 'mousepad', 'nightstand', 'powersocket', 'box', 'photoframe', 'razor', 'wine', 'dresser', 'clothes_scarf', 'sink', 'home_office', 'light', 'colander', 'laser_pointer', 'dirt']  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:['food_pizza', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'ceiling', 'phone', 'thread', 'computer', 'stovefan', 'faucet', 'shower', 'food_jam', 'dining_room', 'wall', 'powersocket', 'tape', 'coffe_maker', 'food_food', 'mirror', 'doorjamb', 'mouse', 'paper_towel', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'dirt']  Task:Clean  mirror  response:  {       thoughts : Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[WIPE] <mirror>', '[FIND] <trashcan>', '[PUTBACK] <paper_towel> <trashcan>']  }     Scene_Objects:['fork', 'pot', 'measuring_cup', 'microwave', 'detergent', 'trashcan', 'orchid', 'bills', 'knife', 'bathroom_counter', 'floor', 'character', 'keyboard', 'mat', 'mousepad', 'nightstand', 'pasta', 'tape', 'novel', 'food_food', 'check', 'television', 'curtain', 'coffee_pot', 'laundry_detergent', 'clothes_scarf', 'bathroom_cabinet', 'colander', 'instrument_violin', 'washing_machine']  Task:Wash clothes  response:

{  Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'woman', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'stamp', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'box', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'cd', 'dresser', 'table']  Task:Watch movie  response:  {       thoughts : Sitting and watching  a movie with family,       actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TURNTO] <child>', '[LOOKAT] <child>', '[GREET] <child>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']  }     Scene_Objects:['food_pizza', 'blender', 'walllamp', 'cat', 'drawing', 'orchid', 'needle', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'ceilinglamp', 'laptop', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'oven', 'newspaper', 'check', 'tray', 'curtain', 'doorjamb', 'door', 'bathroom_cabinet', 'table', 'tooth_paste', 'coffee']  Task:Relax on sofa  response:

{  I'm tired and want to relax on the sofa }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'folder', 'bedroom', 'food_cake', 'computer', 'shower', 'iron', 'window', 'pillow', 'wall', 'nightstand', 'powersocket', 'tape', 'bed', 'television', 'wine', 'doorjamb', 'towel_rack', 'dresser', 'home_office', 'light', 'bathroom_cabinet', 'dishwasher']  Task:Pick up phone  response:  {       thoughts : I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear.,       actions : ['[WALK] <dining_room>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'blow_dryer', 'detergent', 'knife', 'orchid', 'bathroom_counter', 'shampoo', 'keyboard', 'bookshelf', 'mail', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'faucet', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'cup', 'light_bulb', 'food_food', 'television', 'food_onion', 'pencil', 'napkin', 'light']  Task:Drink  response:

{  Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light']  Task:Turn on light  response:  {       thoughts : I walk in to the living room. I find the light switch. I turn on the lights.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['filing_cabinet', 'juice', 'measuring_cup', 'microwave', 'walllamp', 'trashcan', 'floor', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'candle', 'pillow', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']  Task:Wash dishes with dishwasher  response:

{  Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in 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:['water_glass', 'food_bread', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'drawing', 'desk', 'keyboard', 'bookshelf', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'pillow', 'bowl', 'wall', 'box', 'coffe_maker', 'razor', 'television', 'curtain', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathroom_cabinet']  Task:Drink  response:  {       thoughts : Pour water into a glass and drink from the glass.,       actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['freezer', 'ground_coffee', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'stereo', 'mousepad', 'couch', 'clothes_pants', 'dining_room', 'wall', 'powersocket', 'box', 'bed', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'food_steak', 'napkin', 'light', 'board_game']  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:['fork', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'envelope', 'computer', 'button', 'food_bacon', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'television', 'doorjamb', 'dresser', 'dirt']  Task:Change TV channel  response:  {       thoughts : Pickup remote control for the living room TV and push the change channel button,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['pot', 'tablelamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'shampoo', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'clothes_socks', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'nightstand', 'basket_for_clothes', 'newspaper', 'clothes_gloves', 'tray', 'doorjamb', 'lighter', 'cards', 'clothes_dress', 'laundry_detergent', 'napkin', 'clothes_skirt', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the 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:['tea', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'alcohol', 'mat', 'faucet', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'bench', 'coffee_filter', 'ice', 'paper_towel', 'conditioner', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'hands_both', 'shoe_rack']  Task:Wash hands  response:  {       thoughts : I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'picture', 'window', 'mousepad', 'oil', 'clothes_hat', 'wall', 'keys', 'food_food', 'coin', 'food_onion', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'table']  Task:Write an email  response:

{  I walk into the home office and walk to the desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on my email program.  When the program is loaded I write an email. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'measuring_cup', 'dog', 'freezer', 'walllamp', 'orchid', 'bathroom_counter', 'keyboard', 'bookshelf', 'closetdrawer', 'pillow', 'dining_room', 'powersocket', 'oven', 'newspaper', 'clothes_gloves', 'bed', 'check', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'cd', 'cupboard', 'door', 'napkin', 'home_office', 'bathroom_cabinet', 'dishwasher', 'scrabble']  Task:Read book  response:  {       thoughts : Read a book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[PUTOBJBACK] <novel>']  }     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:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'mop', 'chair', 'bathroom', 'food_carrot', 'woman', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'keyboard', 'mat', 'faucet', 'window', 'foundation', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'towel_rack', 'cd', 'dresser', 'sink', 'clothes_scarf', 'light']  Task:Greet guests  response:  {       thoughts : Stand next to the door. When the door opens from the outside, greet the guests.,       actions : ['[RUN] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>']  }     Scene_Objects:['food_ice_cream', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'mail', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'after_shave', 'doorjamb', 'chessboard', 'door', 'food_steak', 'bathroom_cabinet', 'table', 'board_game']  Task:Watch TV  response:

{  I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'tea', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'keys', 'novel', 'coffe_maker', 'clothes_gloves', 'coffee_filter', 'water', 'ice', 'tray', 'food_onion', 'cupboard', 'door', 'light', 'dishwasher', 'soap']  Task:Make coffee  response:  {       thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['sponge', 'microwave', 'walllamp', 'bathroom', 'toothbrush', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'ceilinglamp', 'mat', 'deck_of_cards', 'stereo', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'light_bulb', 'food_donut', 'tray', 'curtain', 'shoes', 'dishrack', 'sink', 'spoon', 'table', 'dishwasher', 'coffee']  Task:Relax on sofa  response:

{  I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['water_glass', 'pot', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']  Task:Drink  response:

{  I need to go to Kitchen.  Get a cup.  Fill cup.  Drink }