Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'chair', 'detergent', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'shower', 'mousepad', 'dustpan', 'dining_room', 'wall', 'powersocket', 'oven', 'check', 'television', 'doorjamb', 'hairbrush', 'controller', 'sink', 'home_office', 'light']  Task:Turn on light  response:  {       thoughts : Walk to living room.  Find light switch.  Switch on light switch.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['sponge', 'filing_cabinet', 'cat', 'food_butter', 'hanger', 'floor', 'ceiling', 'food_cake', 'ceilinglamp', 'deck_of_cards', 'tvstand', 'homework', 'mousepad', 'closetdrawer', 'teeth', 'food_jam', 'nightstand', 'powersocket', 'bed', 'check', 'video_game_controller', 'mouthwash', 'towel_rack', 'mouse', 'console', 'cd', 'cupboard', 'instrument_guitar', 'coffee', 'shoe_rack']  Task:Clean  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'chair', 'band-aids', 'bathroom', 'trashcan', 'phone', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'picture', 'window', 'couch', 'bowl', 'broom', 'wall', 'oven', 'bench', 'cup', 'food_food', 'oven_mitts', 'colander', 'curtain', 'pencil', 'kitchen_counter', 'clothes_dress', 'sink', 'dishwasher', 'soap', 'instrument_violin']  Task:Pet cat  response:  {       thoughts : Find Cat in living room.  Walk to cat.  Pet cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'filing_cabinet', 'mop', 'measuring_cup', 'dog', 'walllamp', 'bathroom', 'food_butter', 'woman', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'man', 'table_cloth', 'electric_shaver', 'dining_room', 'child', 'mouthwash', 'razor', 'rag', 'doorjamb', 'lighter', 'towel_rack', 'mouse', 'shoes', 'hair', 'food_steak', 'soap']  Task:Greet guests  response:

{  Greet guests when they knock on the door and invite them to enter my home }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink']  Task:Work  response:  {       thoughts : working on computer,       actions : ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <button>', '[TURNTO] <button>', '[LOOKAT] <button>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <button>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['blender', 'chair', 'walllamp', 'detergent', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'napkin']  Task:Watch TV  response:

{  Find the remote, turn on the TV, 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:['microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'character', 'toaster', 'plate', 'tvstand', 'foundation', 'dish_soap', 'tooth_paste', 'wall', 'cup', 'coffe_maker', 'food_food', 'food_onion', 'centerpiece', 'cards', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'door', 'sink', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'creditcard']  Task:Wash dishes with dishwasher  response:  {       thoughts : Wash a plate using the dishwasher in the kitchen.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['sponge', 'fork', 'pot', 'chair', 'detergent', 'floor', 'ceiling', 'dvd_player', 'toaster', 'mat', 'faucet', 'dish_soap', 'food_peanut_butter', 'form', 'bowl', 'dining_room', 'wall', 'nightstand', 'cup', 'bed', 'coffe_maker', 'mouthwash', 'check', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'controller', 'sink', 'clothes_shirt']  Task:Wash dishes  response:

{  Fill sink with warm, sudsy water. Place dirty dishes in soapy water. With a washcloth or sponge scrub dishes clean. Rinse under clean warm water. Place in dish rack to dry. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['beer', 'walllamp', 'ceilingfan', 'orchid', 'hanger', 'longboard', 'floor', 'ceiling', 'character', 'bedroom', 'folder', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'candle', 'wall', 'oven', 'bench', 'box', 'cup', 'clothes_gloves', 'coffe_maker', 'tray', 'console', 'maindoor', 'door', 'napkin', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.,       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] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'juice', 'measuring_cup', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'television', 'doorjamb', 'shaving_cream', 'mouse', 'home_office']  Task:Arrange furniture  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:['dog', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'food_egg', 'hanger', 'floor', 'phone', 'stovefan', 'mat', 'plate', 'stereo', 'dish_soap', 'food_noodles', 'closetdrawer', 'mousepad', 'dustpan', 'cup', 'food_food', 'coffe_maker', 'check', 'oven_mitts', 'water', 'food_rice', 'curtain', 'mouse', 'hairbrush', 'sink', 'home_office']  Task:Wash dishes by hand  response:  {       thoughts : walk to kitchen, fins soap, arrange dishes, wash dishes,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[FIND] <dish_soap>', '[FIND] <water>', '[GRAB] <plate>', '[GRAB] <dish_soap>', '[WASH] <plate>', '[RINSE] <plate>', '[DROP] <plate>']  }     Scene_Objects:['glue', 'sheets', 'filing_cabinet', 'food_bread', 'food_salt', 'microwave', 'chair', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'cup', 'check', 'mouthwash', 'food_donut', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'table', 'teeth']  Task:Play games  response:

{  I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'chair', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'thread', 'ceilinglamp', 'laptop', 'faucet', 'mousepad', 'couch', 'candle', 'food_jam', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'tray', 'after_shave', 'food_onion', 'shoes', 'cupboard']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room. I sit in the sofa and I relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'desk', 'brush', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'coffee_filter', 'food_rice', 'doorjamb', 'towel_rack', 'dresser', 'clothes_dress', 'door', 'light', 'table']  Task:Change clothes  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'mouse', 'door', 'creditcard']  Task:Play on laptop  response:  {       thoughts : Sit down on the couch. Place laptop on lap. Open laptop. Turn on laptop. Choose selected program. Play selected program. Close game. Close laptop.,       actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>', '[PUTOBJBACK] <laptop>']  }     Scene_Objects:['dry_pasta', 'pot', 'tablelamp', 'juice', 'microwave', 'freezer', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'powersocket', 'food_vegetable', 'food_food', 'television', 'ice', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light']  Task:Cook some food  response:

{  I prepare meals and cook them on the stove. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'button', 'toaster', 'window', 'mousepad', 'clothes_pants', 'wall', 'basket_for_clothes', 'coffe_maker', 'check', 'television', 'toothbrush_holder', 'ice', 'diary', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'pajamas', 'napkin', 'coffee_cup', 'dishwasher', 'soap', 'coffee']  Task:Make coffee  response:  {       thoughts : Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[OPEN] <coffe_maker>', '[POUR] <coffee> <coffe_maker>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>']  }     Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'tray', 'food_onion', 'doorjamb', 'shoes', 'dresser', 'sink', 'table', 'tooth_paste']  Task:Change TV channel  response:

{  I go to the living room, I settle on the sofa, I turn on the television, change the channel }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'bookshelf', 'brush', 'mat', 'stereo', 'picture', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'shelf', 'cup', 'television', 'wine', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'home_office', 'table']  Task:Listen to music  response:  {       thoughts : Walk to living room. Walk to radio. Switch on the radio. Walk to sofa and sit on it.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Work  response:

{  Using desktop computer in home office }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'walllamp', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'purse', 'stovefan', 'ceilinglamp', 'stereo', 'faucet', 'window', 'balanceball', 'electric_shaver', 'couch', 'wall', 'bench', 'food_food', 'television', 'curtain', 'diary', 'mouse', 'dresser', 'hair', 'bathroom_cabinet', 'table', 'home_office', 'vase', 'teeth', 'shoe_rack']  Task:Relax on sofa  response:  {       thoughts : Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'box', 'cup', 'photoframe', 'television', 'food_rice', 'doorjamb', 'towel_rack', 'kitchen_counter', 'door', 'home_office', 'soap']  Task:Relax on sofa  response:

{  I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_pizza', 'tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'cup', 'coffe_maker', 'doorjamb', 'mouse', 'chessboard', 'controller', 'bathroom_cabinet', 'light']  Task:Write an email  response:  {       thoughts : enter office, find computer, turn it on,,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['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:

{  walk into living room, look at the sofa which one is available, sit on the sofa, now take 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:['glue', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'laptop', 'balanceball', 'mousepad', 'pillow', 'wall', 'cup', 'bed', 'television', 'razor', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'light', 'vase']  Task:Turn on light  response:  {       thoughts : push any ligth button to turn it on, for example in the living room,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'mousepad', 'couch', 'form', 'wall', 'oven', 'powersocket', 'tape', 'cup', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'vacuum_cleaner', 'shoes', 'door', 'light']  Task:Pick up phone  response:

{  I go to my home office. I walk towards my desk. I see the phone. I pick it 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:['fork', 'tablelamp', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'envelope', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'check', 'video_game_controller', 'television', 'kitchen_counter', 'hairdryer', 'light', 'table']  Task:Relax on sofa  response:  {       thoughts : Walk to the living room. Walk to the sofa and sit on the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'food_bread', 'tablelamp', 'microwave', 'freezer', 'food_butter', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'stovefan', 'mat', 'tvstand', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'food_cheese', 'photoframe', 'food_food', 'television', 'wine', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'dishwasher']  Task:Cook some food  response:

{  I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'sheets', 'chair', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'stereo', 'window', 'clothes_hat', 'wall', 'nightstand', 'bench', 'box', 'food_cheese', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'hair', 'door', 'light']  Task:Turn on light  response:  {       thoughts : Walk to living room.  Find light switch.  Switch on light switch.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['sheets', 'walllamp', 'drawing', 'needle', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'deck_of_cards', 'stovefan', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'television', 'tray', 'doorjamb', 'pencil', 'conditioner', 'door', 'table', 'dishwasher']  Task:Relax on sofa  response:

{  Walk to living room. Find couch. Sit on couch }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'dvd_player', 'desk', 'bedroom', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'tray', 'curtain', 'controller', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'light']  Task:Listen to music  response:  {       thoughts : walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music,       actions : ['[WALK] <home_office>', '[WALK] <dvd_player>', '[FIND] <dvd_player>', '[TURNTO] <dvd_player>', '[LOOKAT] <dvd_player>', '[SWITCHON] <dvd_player>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'soap']  Task:Work  response:

{  Sit in front of the computer, switch on the computer and start typing (Work) }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'pot', 'ceilingfan', 'toothbrush', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'piano_bench', 'toaster', 'faucet', 'window', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'photoframe', 'toothbrush_holder', 'shoes', 'dresser', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'tooth_paste', 'laser_pointer']  Task:Brush teeth  response:  {       thoughts : go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>']  }     Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'food_butter', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'photoframe', 'bed', 'coffe_maker', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'napkin', 'dirt']  Task:Relax on sofa  response:

{  move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'mop', 'cd_player', 'chair', 'knifeblock', 'music_stand', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'envelope', 'food_bacon', 'mop_bucket', 'stovefan', 'ceilinglamp', 'shower', 'nightstand', 'bed', 'photoframe', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'bathroom_cabinet', 'light']  Task:Listen to music  response:  {       thoughts : Walk to the living and turn to the music stand. Switch on the CD player to listen to music.,       actions : ['[WALK] <home_office>', '[WALK] <music_stand>', '[FIND] <music_stand>', '[TURNTO] <music_stand>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']  }     Scene_Objects:['microwave', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'toaster', 'food_noodles', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'cup', 'bed', 'photoframe', 'coffe_maker', 'toilet_paper', 'television', 'coffee_filter', 'ice', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'sink', 'clothes_scarf', 'dishwasher', 'soap', 'dirt', 'coffee']  Task:Make coffee  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'juice', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'coffee_table', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']  Task:Watch TV  response:  {       thoughts : Sit down, turn on the TV with the remote control that is on the coffee table.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <coffee_table>', '[TURNTO] <coffee_table>', '[LOOKAT] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['chair', 'jelly', 'walllamp', 'drawing', 'knife', 'wallshelf', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'sink']  Task:Watch TV  response:

{  Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on 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:['food_bread', 'toilet', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'ceiling', 'cleaning_solution', 'mop_bucket', 'table_cloth', 'faucet', 'shower', 'iron', 'clothes_socks', 'pillow', 'wall', 'food_food', 'mirror', 'wine', 'doorjamb', 'coffee_pot', 'paper_towel', 'cupboard', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'scrabble']  Task:Clean mirror  response:  {       thoughts : First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'comb', 'dresser', 'door', 'light']  Task:Work  response:

{  Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'spectacles', 'glue', 'jelly', 'freezer', 'detergent', 'food_carrot', 'orchid', 'clothes_underwear', 'hanger', 'floor', 'bedroom', 'thread', 'bookmark', 'mat', 'stereo', 'shower', 'mousepad', 'oil', 'nightstand', 'light_bulb', 'coffe_maker', 'television', 'tray', 'pencil', 'shoes', 'bathroom_cabinet', 'dishwasher', 'colander', 'dirt']  Task:Pick up phone  response:  {       thoughts : Go to the living room.  Find the telephone.  Lift up the receiver.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'piano_bench', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'stereo', 'deck_of_cards', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'mouse', 'door', 'table', 'laser_pointer']  Task:Work  response:

{  Go to the office and sit on the chair, then work on the computer }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'microwave', 'ground_coffee', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'toaster', 'plate', 'faucet', 'foundation', 'mousepad', 'food_jam', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'food_food', 'coffe_maker', 'rag', 'shaving_cream', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Take a dish and put it in the dishwasher to be washed,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'oven_mitts', 'tray', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Watch TV  response:

{  Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'band-aids', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'bathroom_counter', 'phone', 'bookshelf', 'computer', 'stovefan', 'mat', 'plate', 'ceilinglamp', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'oven', 'cutting_board', 'curtain', 'mouse', 'table', 'dishwasher', 'light']  Task:Set up table  response:  {       thoughts : Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table.,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <table>', '[PUTBACK] <plate> <table>']  }     Scene_Objects:['juice', 'walllamp', 'nail_polish', 'detergent', 'dough', 'drawing', 'food_egg', 'tea_bag', 'bookshelf', 'remote_control', 'alcohol', 'button', 'mop_bucket', 'table_cloth', 'stovefan', 'tvstand', 'shoe-shine_kit', 'shower', 'stereo', 'deck_of_cards', 'mousepad', 'powersocket', 'check', 'rag', 'towel_rack', 'pencil', 'conditioner', 'door', 'bathroom_cabinet', 'soap']  Task:Change TV channel  response:

{  Take the Tv Remote Control  in the Living Room table And Press the Channel Change Button to change the channel }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'filing_cabinet', 'walllamp', 'drawing', 'floor', 'desk', 'tea_bag', 'computer', 'clothes_jacket', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'towel', 'tape', 'basket_for_clothes', 'bed', 'curtain', 'shaving_cream', 'towel_rack', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'hair', 'laundry_detergent', 'bathroom_cabinet', 'light', 'board_game', 'dirt']  Task:Open front door  response:  {       thoughts : Walk over to the front door, turn the knob, and open the door.,       actions : ['[WALK] <home_office>']  }     Scene_Objects:['scissors', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'food_noodles', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'headset', 'dresser', 'food_steak', 'sink']  Task:Change TV channel  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'juice', 'chair', 'blow_dryer', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'toaster', 'laptop', 'deck_of_cards', 'faucet', 'food_noodles', 'closetdrawer', 'food_orange', 'wall', 'nightstand', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'food_food', 'curtain', 'towel_rack', 'console', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'spoon', 'dishwasher']  Task:Make coffee  response:  {       thoughts : Making coffee,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['glue', 'food_pizza', 'toilet', 'chair', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'food_bacon', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'shower', 'mousepad', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'console', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'pajamas', 'sink', 'napkin', 'hands_both']  Task:Wash hands  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'scissors', 'freezer', 'ceilingfan', 'knifeblock', 'knife', 'hanger', 'phone', 'desk', 'clothes_jacket', 'toaster', 'ceilinglamp', 'electric_shaver', 'window', 'mousepad', 'couch', 'candle', 'cutting_board', 'food_cheese', 'food_rice', 'food_onion', 'pencil', 'cd', 'comb', 'door', 'maindoor', 'napkin', 'soap']  Task:Pet cat  response:  {       thoughts : You walk to the living room and find the cat. You look at the cat and touch it to pet it.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'bathroom', 'cat', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'bedroom', 'food_bacon', 'piano_bench', 'bookmark', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'stereo', 'mat', 'couch', 'nightstand', 'wall', 'photoframe', 'coffee_filter', 'towel_rack', 'dishrack', 'controller', 'table', 'clothes_skirt', 'soap']  Task:Pick up phone  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'scissors', 'microwave', 'bathroom', 'drawing', 'knifeblock', 'floor', 'bedroom', 'desk', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'closetdrawer', 'wall', 'powersocket', 'newspaper', 'photoframe', 'bed', 'check', 'food_rice', 'ice', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'board_game']  Task:Wash dishes by hand  response:  {       thoughts : go into the kitchen, walk to the sink. Turn on the water and rinse of a plate and clean them off fully with a sponge.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[RINSE] <plate>', '[FIND] <sponge>', '[GRAB] <sponge>', '[WASH] <plate>']  }     Scene_Objects:['pot', 'food_ice_cream', 'food_salt', 'measuring_cup', 'mop', 'chair', 'walllamp', 'cat', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'clothes_pants', 'oven', 'check', 'toilet_paper', 'oven_mitts', 'food_donut', 'after_shave', 'lighter', 'cards', 'headset', 'instrument_violin', 'instrument_guitar', 'light', 'board_game', 'teeth']  Task:Pet cat  response:

{  I go to the living room then go to the cat and touch it. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'food_butter', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'shower', 'picture', 'mousepad', 'pillow', 'wall', 'oven', 'powersocket', 'bed', 'photoframe', 'food_donut', 'tray', 'mouse', 'pencil', 'bag', 'soap']  Task:Read book  response:  {       thoughts : go to living room,find the text book on the self ,sat on the chair ,open and read the book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['pot', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'shower', 'clothes_socks', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'food_food', 'television', 'tray', 'wooden_spoon', 'food_onion', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'hairdryer', 'door', 'dishwasher', 'clothes_skirt']  Task:Put groceries in Fridge  response:

{  Open the fridge, put the groceries in the fridge and close it. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'light_bulb', 'check', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'clothes_dress', 'door', 'table', 'clothes_shirt']  Task:Pick up phone  response:  {       thoughts : Walk to living room. Go near telephone. take the receiver and then talk to other person on that side.,       actions : ['[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['scissors', 'chair', 'freezer', 'band-aids', 'walllamp', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'keyboard', 'toaster', 'ceilinglamp', 'plate', 'stereo', 'mat', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'check', 'food_food', 'food_rice', 'ice', 'food_onion', 'console', 'kitchen_counter', 'table']  Task:Set up table  response:

{  Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'beer', 'toilet', 'dough', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'window', 'oil', 'couch', 'bowl', 'wall', 'oven', 'toy', 'cup', 'bed', 'food_food', 'television', 'wooden_spoon', 'towel_rack', 'comb', 'cupboard', 'table', 'dishwasher']  Task:Relax on sofa  response:  {       thoughts : Walk to living room. Find couch. Sit on couch,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sponge', 'band-aids', 'detergent', 'food_carrot', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'button', 'piano_bench', 'toaster', 'plate', 'faucet', 'drying_rack', 'shower', 'dish_soap', 'closetdrawer', 'clothes_pants', 'wall', 'oven', 'food_cheese', 'newspaper', 'food_food', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'shoe_rack']  Task:Wash dishes by hand  response:

{  I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'scissors', 'juice', 'food_salt', 'microwave', 'chair', 'food_butter', 'toothbrush', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'button', 'brush', 'ceilinglamp', 'plate', 'wall', 'tape', 'food_food', 'check', 'food_donut', 'wooden_spoon', 'rag', 'door', 'clothes_scarf', 'napkin', 'table', 'light', 'dishwasher']  Task:Eat  response:  {       thoughts : Serve food on dinning table in appropriate utensils, sit on the chair, eat,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <plate>', '[PUTBACK] <food_food> <plate>', '[GRAB] <food_food>', '[PUTOBJBACK] <food_food>', '[FIND] <fork>', '[GRAB] <fork>', '[EAT] <plate>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Browse internet  response:

{  Sit down at desk in home office, turn on computer, open browser on computer, browse 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:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'television', 'curtain', 'doorjamb', 'cd', 'pajamas', 'door', 'table', 'light', 'dishwasher']  Task:Watch TV  response:  {       thoughts : Sitting on the couch watching my favorite television show.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'beer', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'keyboard', 'toaster', 'mat', 'tvstand', 'couch', 'food_orange', 'pillow', 'wall', 'basket_for_clothes', 'food_cheese', 'food_food', 'television', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dirt']  Task:Put groceries in Fridge  response:

{  I leave the bags with groceries near the fridge, open the door and put the groceries in the shelves. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'dustpan', 'wall', 'bed', 'coffe_maker', 'lighter', 'coffee_pot', 'mouse', 'hair', 'door', 'napkin', 'home_office', 'table']  Task:Browse internet  response:  {       thoughts : Go find a computer, turn it on, click google, and browse the internet.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['water_glass', 'scissors', 'blender', 'chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'character', 'desk', 'computer', 'food_bacon', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'cup', 'photoframe', 'newspaper', 'television', 'ice', 'doorjamb', 'diary', 'console', 'towel_rack']  Task:Relax on sofa  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['fork', 'tablelamp', 'toilet', 'chair', 'band-aids', 'orchid', 'drawing', 'kitchen_cabinet', 'floor', 'table_cloth', 'ceilinglamp', 'plate', 'mat', 'tvstand', 'electric_shaver', 'candle', 'microphone', 'wall', 'cup', 'photoframe', 'food_food', 'food_rice', 'tray', 'food_onion', 'kitchen_counter', 'chessboard', 'cupboard', 'home_office', 'table', 'laser_pointer']  Task:Set up table  response:

{  Walk into kitchen. Grab plates and forks. Walk into dining room. Put plates and forks on table. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'filing_cabinet', 'food_salt', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'toy', 'tape', 'light_bulb', 'check', 'food_food', 'television', 'curtain', 'doorjamb', 'mouse', 'pencil', 'dresser', 'conditioner', 'spoon', 'light', 'table', 'colander']  Task:Re arrange office  response:  {       thoughts : Walk in.Turn on light.Move furniture. Change the room,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[PUSH] <desk>', '[WALK] <chair>', '[PUSH] <chair>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>']  }     Scene_Objects:['water_glass', 'pot', 'freezer', 'milk', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'alcohol', 'computer', 'toaster', 'shoe-shine_kit', 'faucet', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'check', 'toilet_paper', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'clothes_dress', 'food_steak', 'sink', 'bathroom_cabinet']  Task:Drink  response:

{  I walk into the kitchen. I reach into the cabinet and pick up a water glass. Turn on the faucet and place the glass under the water stream. Bring the glass of water to lips and drink. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'couch', 'wall', 'nightstand', 'oven', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'food_onion', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'electrical_outlet']  Task:Toast bread  response:  {       thoughts : Place two slices of bread in the toaster. Select medium toast on toaster.  Push down button to begin toasting.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[WALK] <electrical_outlet>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <electrical_outlet>', '[TURNTO] <toaster>', '[LOOKAT] <toaster>', '[SWITCHON] <toaster>']  }     Scene_Objects:['sheets', 'microwave', 'chair', 'walllamp', 'bathroom', 'detergent', 'bathroom_counter', 'button', 'toaster', 'brush', 'stereo', 'shower', 'faucet', 'food_orange', 'pillow', 'oven', 'photoframe', 'check', 'television', 'tray', 'kettle', 'mouse', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'dishwasher', 'clothes_skirt', 'soap']  Task:Listen to music  response:

{  Walk into living room, look for radio, grab on 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:['fork', 'blender', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'keyboard', 'mat', 'laptop', 'tvstand', 'picture', 'window', 'clothes_socks', 'couch', 'pillow', 'food_kiwi', 'wall', 'wall_clock', 'cutting_board', 'bed', 'television', 'toothbrush_holder', 'curtain', 'food_onion', 'doorjamb', 'door', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk into the living room. I cross the room to the couch. I sit down and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'wooden_spoon', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Browse internet  response:

{  I go to my home office. I sit on the chair right in front of my computer. I turn on the computer. Use the mouse to open the web browser. Use the keyboard to type the URL that I want to visit. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'food_butter', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'photoframe', 'bed', 'coffe_maker', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'napkin', 'dirt']  Task:Relax on sofa  response:  {       thoughts : move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'mat', 'deck_of_cards', 'clothes_socks', 'closetdrawer', 'couch', 'mousepad', 'wall', 'nightstand', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'door', 'light']  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:['walllamp', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'microphone', 'pillow', 'wall', 'wall_clock', 'photoframe', 'television', 'toothbrush_holder', 'food_donut', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'sink', 'clothes_scarf', 'napkin', 'table']  Task:Straighten pictures on wall  response:  {       thoughts : Move the pictures/paintings until they are straight.,       actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PUSH] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PUSH] <drawing>']  }     Scene_Objects:['spectacles', 'filing_cabinet', 'juice', 'toilet', 'chair', 'nail_polish', 'needle', 'clothes_underwear', 'phone', 'keyboard', 'bookmark', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'foundation', 'clothes_hat', 'pillow', 'oven', 'powersocket', 'tape', 'bed', 'coffe_maker', 'television', 'curtain', 'towel_rack', 'mouse', 'cupboard', 'bathroom_cabinet', 'table']  Task:Listen to music  response:

{  Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'food_carrot', 'drawing', 'hanger', 'phone', 'ceiling', 'desk', 'computer', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'towel', 'cup', 'food_cheese', 'keys', 'tray', 'after_shave', 'towel_rack', 'mouse', 'cupboard', 'sink', 'coffee']  Task:Pet cat  response:  {       thoughts : I walk into the living room and I pet the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['food_pizza', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'clothes_dress', 'door', 'conditioner', 'sink', 'light']  Task:Pet cat  response:

{  My cat looks like it wants attention, so I will go pet it on the couch. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'glue', 'pot', 'toilet', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'kettle', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'controller', 'light']  Task:Relax on sofa  response:  {       thoughts : I get home from work and walk into the living room. I see the couch and go to sit on it.,       actions : ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['sheets', 'microwave', 'chair', 'bathroom', 'orchid', 'food_egg', 'cpuscreen', 'floor', 'phone', 'bedroom', 'desk', 'stovefan', 'toaster', 'ceilinglamp', 'shower', 'mat', 'food_peanut_butter', 'wall', 'pasta', 'powersocket', 'oven', 'cup', 'bed', 'after_shave', 'food_onion', 'chessboard', 'dresser', 'cupboard', 'clothes_scarf', 'home_office']  Task:Pet cat  response:

{  I walk to my living room, find my cat, scrub it using my hand. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']  Task:Take shower  response:  {       thoughts : go to a bathroom, open the shower, let water wash your body,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']  }     Scene_Objects:['fork', 'pot', 'microwave', 'bathroom', 'knife', 'floor', 'ceiling', 'bedroom', 'toaster', 'plate', 'shower', 'dish_soap', 'closetdrawer', 'dustpan', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'check', 'drinking_glass', 'curtain', 'centerpiece', 'shaving_cream', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'dirt', 'shoe_rack']  Task:Wash dishes with dishwasher  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'bathroom', 'trashcan', 'orchid', 'drawing', 'wallshelf', 'floor', 'character', 'bedroom', 'tea_bag', 'keyboard', 'toaster', 'mat', 'stovefan', 'tvstand', 'couch', 'dining_room', 'wall', 'nightstand', 'child', 'bed', 'photoframe', 'novel', 'food_onion', 'after_shave', 'cupboard', 'bathtub', 'napkin', 'bathroom_cabinet', 'board_game']  Task:Story reading time  response:  {       thoughts : Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures,       actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Work  response:

{  I go to my home office. I find the computer along with mechanical keyboard on the desk. I sit on chair. I switch on the computer. I type on keyboard and work on the computer. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'window', 'clothes_hat', 'dining_room', 'wall', 'bench', 'powersocket', 'photoframe', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'table', 'light', 'tooth_paste']  Task:Pick up phone  response:  {       thoughts : Pick up phone,       actions : ['[WALK] <table>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'microwave', 'band-aids', 'detergent', 'cat', 'drawing', 'orchid', 'ceiling', 'bedroom', 'keyboard', 'thread', 'clothes_jacket', 'toaster', 'iron', 'shower', 'mousepad', 'food_orange', 'broom', 'oven', 'coffee_filter', 'curtain', 'doorjamb', 'centerpiece', 'towel_rack', 'shoes', 'controller', 'door', 'bathroom_cabinet', 'teeth']  Task:Pet cat  response:

{  Find the cat; pet the cat by touching it }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'food_ice_cream', 'walllamp', 'nail_polish', 'cat', 'orchid', 'drawing', 'floor', 'ceiling', 'purse', 'alcohol', 'mail', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'towel', 'wall', 'oven', 'cup', 'food_cheese', 'television', 'curtain', 'doorjamb', 'door', 'table', 'clothes_shirt']  Task:Straighten paintings on wall  response:  {       thoughts : Go up to the painting and tilt it which ever way it is uneven until it looks straight.,       actions : ['[WALK] <home_office>', '[WALK] <wall>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']  }     Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'dough', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'wall', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'cupboard', 'table']  Task:Read book  response:

{  Walk to the couch in the living room, sit on ti and read the book }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathtub', 'light', 'table', 'instrument_violin']  Task:Straighten pictures on wall  response:  {       thoughts : Move the pictures/paintings until they are straight.,       actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PUSH] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PUSH] <drawing>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'floor', 'shampoo', 'mop_bucket', 'toaster', 'mat', 'plate', 'shower', 'dish_soap', 'closetdrawer', 'dining_room', 'wall', 'photoframe', 'coffe_maker', 'colander', 'pencil', 'kitchen_counter', 'cupboard', 'clothes_dress', 'food_steak', 'home_office', 'dishwasher', 'soap', 'tooth_paste']  Task:Wash dishes with dishwasher  response:

{  Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the soap into the dishwasher.  Close the dishwasher.  Turn on the dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'beer', 'measuring_cup', 'toilet', 'drawing', 'knife', 'hanger', 'floor', 'desk', 'tea_bag', 'keyboard', 'piano_bench', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'foundation', 'clothes_pants', 'towel', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'bag', 'table', 'vase', 'soap']  Task:Wash hands  response:  {       thoughts : BEFORE EATING,       actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <towel>', '[WIPE] <towel>']  }     Scene_Objects:['microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'computer', 'mail', 'table_cloth', 'mat', 'tvstand', 'plate', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'sink']  Task:Relax on sofa  response:

{  I walk to the living room. I sit in the sofa and I 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:['microwave', 'board_game', 'chair', 'ground_coffee', 'detergent', 'knifeblock', 'floor', 'ceiling', 'alcohol', 'toaster', 'faucet', 'picture', 'closetdrawer', 'couch', 'dining_room', 'broom', 'wall', 'coffe_maker', 'check', 'water', 'drinking_glass', 'after_shave', 'rag', 'kitchen_counter', 'shoes', 'cupboard', 'hair', 'sink', 'table', 'tooth_paste']  Task:Drink  response:  {       thoughts : Walk to kitchen. Walk to faucet. Switch on faucet. Pour water into drinking glass. Switch off faucet. Drink water.,       actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <sink>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <drinking_glass>']  }     Scene_Objects:['tablelamp', 'food_salt', 'chair', 'walllamp', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'oil', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'check', 'television', 'doorjamb', 'dresser', 'door']  Task:Change TV channel  response:

{  Walk to living room. Walk to and sit at the sofa. Grab remote control and switch on TV. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'tea', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mousepad', 'food_noodles', 'couch', 'closetdrawer', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'razor', 'television', 'shaving_cream', 'kitchen_counter', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth']  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:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Browse internet  response:

{  I walk into my home office and walk up to my desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on the google icon. I enter Disney Cruise Line into the search bar and browse the internet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'ceilinglamp', 'mat', 'balanceball', 'electric_shaver', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'nightstand', 'photoframe', 'food_food', 'doorjamb', 'mouse', 'door', 'light']  Task:Browse internet  response:  {       thoughts : turn on the computer and browse the internet,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['food_pizza', 'filing_cabinet', 'chair', 'band-aids', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'doorjamb', 'shoes', 'dresser', 'soap']  Task:Change TV channel  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'glue', 'food_ice_cream', 'food_salt', 'tea', 'drawing', 'knife', 'cpuscreen', 'phone', 'desk', 'computer', 'button', 'plate', 'iron', 'dish_soap', 'mousepad', 'nightstand', 'powersocket', 'curtain', 'kitchen_counter', 'dishrack', 'dresser', 'spoon', 'napkin', 'table', 'dishwasher', 'home_office', 'vase', 'bathroom_cabinet', 'coffee']  Task:Wash dishes with dishwasher  response:  {       thoughts : put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <dishrack>', '[PUTBACK] <fork> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishrack>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['dry_pasta', 'food_salt', 'toilet', 'walllamp', 'bathroom', 'food_carrot', 'dough', 'milk', 'phone', 'ceiling', 'bedroom', 'desk', 'keyboard', 'table_cloth', 'picture', 'oil', 'candle', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'oven', 'coffe_maker', 'coin', 'towel_rack', 'pencil', 'dresser', 'clothes_dress', 'clothes_scarf', 'instrument_guitar']  Task:Pick up phone  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Watch youtube  response:  {       thoughts : Go to youtube.Com watch videos,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:

{  I need to complete work on my computer, so I will be pulling out my chair, turning on my computer and begin my task. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'pot', 'walllamp', 'detergent', 'milk', 'hanger', 'phone', 'toaster', 'tvstand', 'balanceball', 'electric_shaver', 'food_noodles', 'garbage_can', 'mousepad', 'clothes_hat', 'pillow', 'broom', 'food_kiwi', 'bench', 'food_vegetable', 'food_cheese', 'food_food', 'ice', 'wine', 'rag', 'shaving_cream', 'dresser', 'cupboard', 'napkin', 'pantry']  Task:Organize pantry  response:  {       thoughts : Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.,       actions : ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>']  }     Scene_Objects:['tablelamp', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'stamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'dining_room', 'wall', 'toy', 'bed', 'food_food', 'toilet_paper', 'mouthwash', 'doorjamb', 'pencil', 'kitchen_counter', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'home_office', 'bathroom_cabinet', 'dishwasher', 'washing_machine']  Task:Wash clothes  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'mat', 'deck_of_cards', 'shower', 'tvstand', 'food_jam', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_cheese', 'photoframe', 'novel', 'food_food', 'toilet_paper', 'coffe_maker', 'food_donut', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'light', 'tooth_paste', 'coffee']  Task:Put groceries in Fridge  response:  {       thoughts : in my home i walk to the kitchen with some groceries and locate the fridge,then open the fridge put the groceries into the fridge and closed.,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['sponge', 'pot', 'tablelamp', 'food_salt', 'measuring_cup', 'walllamp', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'stamp', 'keyboard', 'food_noodles', 'closetdrawer', 'mousepad', 'clothes_pants', 'pasta', 'powersocket', 'food_food', 'video_game_controller', 'check', 'water', 'chessboard', 'dresser', 'cupboard', 'clothes_scarf', 'home_office', 'bathroom_cabinet', 'soap', 'scrabble']  Task:Wash hands  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'detergent', 'cat', 'drawing', 'floor', 'stamp', 'computer', 'ceilinglamp', 'mat', 'balanceball', 'picture', 'window', 'foundation', 'faucet', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'mouthwash', 'television', 'ice', 'centerpiece', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'table', 'dishwasher']  Task:Pet cat  response:  {       thoughts : I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']  }     Scene_Objects:['water_glass', 'food_salt', 'chair', 'freezer', 'drawing', 'wallshelf', 'hanger', 'phone', 'folder', 'bedroom', 'desk', 'keyboard', 'purse', 'couch', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'wall', 'water', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'conditioner', 'sink', 'napkin', 'home_office', 'table', 'tooth_paste']  Task:Drink  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : I need to go to Kitchen.  Get a cup.  Fill cup.  Drink,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'purse', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'food_noodles', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'table']  Task:Write an email  response:

{  FIRST YOU NEED TO SWITVH ON YOU COMPUTER AND CHECK THE INTERNET CONNECTION.FOR SENDING EMAIL EMAIL ID FOR REQUIRED FOR BOTH SEND AND RECEIVE .SO CLEALY MENTION THE ID ON THE TO PLACE THEN ONLY IT WILL GO CORRECTLY }