Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['trashcan', 'dough', 'drawing', 'needle', 'longboard', 'floor', 'desk', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'shower', 'window', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'bed', 'television', 'coffee_filter', 'curtain', 'rag', 'doorjamb', 'cards', 'mouse', 'pencil', 'maindoor', 'sink', 'door']  Task:Turn on lights  response:  {       thoughts : Walk to your lamp, switch it on, and lay on your bed,       actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TURNTO] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <bed>', '[LIE] <bed>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mail', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Write an email  response:

{  go to the office and use the computer to write and email }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'thread', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'clothes_socks', 'wall', 'pasta', 'powersocket', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'television', 'rag', 'doorjamb', 'shoes', 'door', 'table', 'dishwasher']  Task:Watch TV  response:  {       thoughts : turn on the tv,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']  }     Scene_Objects:['tea', 'chair', 'ground_coffee', 'food_butter', 'floor', 'ceiling', 'computer', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'brush', 'stereo', 'mat', 'electric_shaver', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher']  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:['sponge', 'pot', 'crayon', 'tea', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'faucet', 'picture', 'wall', 'oven', 'food_food', 'check', 'television', 'ice', 'tray', 'rag', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'spoon']  Task:Clean  response:  {       thoughts : Take out a rag. Turn on faucet and get water on the rag. Clean counter off.,       actions : ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <rag> <sink>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[SQUEEZE] <rag>', '[WALK] <kitchen_counter>', '[WIPE] <kitchen_counter>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:

{  Type on a computer in the 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:['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', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'headset', 'dresser', 'bathroom_cabinet', 'soap']  Task:Change TV channel  response:

{  I find the remote then I push the button to switch it to the tv channel i want to watch }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'closetdrawer', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet']  Task:Watch TV  response:  {       thoughts : Sit on the couch and use the remote control to turn on the TV,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['food_salt', 'microwave', 'chair', 'freezer', 'toothbrush', 'drawing', 'wallshelf', 'floor', 'ceiling', 'food_bacon', 'toaster', 'mat', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'newspaper', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'conditioner', 'food_steak', 'sink', 'napkin', 'creditcard']  Task:Put groceries in Fridge  response:

{  In the kitchen where I left the bags of groceries, I grab cheese from the grocery bag, I walk over to the refrigerator, open it up, neatly put cheese in the fridge, Close the fridge }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['mop', 'bathroom', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'remote_control', 'computer', 'clothes_jacket', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'food_noodles', 'couch', 'clothes_pants', 'pillow', 'wall', 'oven', 'check', 'television', 'tray', 'curtain', 'sink', 'table', 'light', 'teeth']  Task:Watch TV  response:  {       thoughts : You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you watch television.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'walllamp', 'nail_polish', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'couch', 'microphone', 'pillow', 'wall', 'pasta', 'cup', 'photoframe', 'bed', 'novel', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'home_office']  Task:Read book  response:

{  Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'mat', 'deck_of_cards', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'bed', 'coffee_filter', 'wine', 'curtain', 'doorjamb', 'kitchen_counter', 'pajamas', 'door', 'food_steak', 'bag', 'light', 'electrical_outlet']  Task:Turn on light  response:  {       thoughts : I walk to the living room. I find the electric outlet. I switch on the light.,       actions : ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['water_glass', 'food_bread', 'toilet', 'blow_dryer', 'bathroom', 'knife', 'orchid', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'ceiling', 'phone', 'character', 'computer', 'stereo', 'homework', 'mousepad', 'pillow', 'food_kiwi', 'oven', 'cup', 'check', 'television', 'razor', 'water', 'curtain', 'rag', 'diary', 'mouse', 'bathroom_cabinet']  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:['pot', 'filing_cabinet', 'scissors', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'faucet', 'mousepad', 'food_orange', 'wall', 'powersocket', 'wooden_spoon', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'table']  Task:Computer work  response:  {       thoughts : Find the computer, Turn on the computer, find keyboard, find mouse, go online,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['tablelamp', 'toilet', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'tvstand', 'shower', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'cup', 'bed', 'coffe_maker', 'food_food', 'doorjamb', 'towel_rack', 'pencil', 'headset', 'chessboard', 'dresser', 'hairbrush', 'door', 'clothes_scarf', 'light']  Task:Turn on light  response:

{  I go into my room, find the light,  then turn on the lights. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'freezer', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bookshelf', 'ceilinglamp', 'tvstand', 'shower', 'mat', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'oven', 'coffe_maker', 'tray', 'curtain', 'coffee_pot', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'hairdryer']  Task:Answer door  response:  {       thoughts : Walk up to the door.  Open the door and greet whomever is out side,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']  }     Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'dog', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'food_jam', 'pillow', 'wall', 'nightstand', 'cutting_board', 'novel', 'television', 'toothbrush_holder', 'mouse', 'door', 'dirt']  Task:Read book  response:

{  I pick up a book. I sit in a chair. I open 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:['microwave', 'freezer', 'walllamp', 'blow_dryer', 'milk', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'food_cake', 'alcohol', 'stovefan', 'homework', 'closetdrawer', 'pillow', 'broom', 'wall', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'kitchen_counter', 'shoes', 'sink', 'light', 'table']  Task:Drink  response:  {       thoughts : Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']  }     Scene_Objects:['microwave', 'chair', 'walllamp', 'nail_polish', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'shaving_cream', 'dresser', 'sink', 'home_office', 'bathroom_cabinet', 'dishwasher']  Task:Watch TV  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : walk into room, grab phone,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['tablelamp', 'chair', 'bathroom', 'drawing', 'knife', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'shower', 'oil', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'pasta', 'bed', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'napkin', 'light', 'coffee']  Task:Turn on light  response:

{  I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'dry_pasta', 'ceilingfan', 'trashcan', 'drawing', 'longboard', 'floor', 'ceiling', 'bedroom', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'shower', 'deck_of_cards', 'couch', 'food_kiwi', 'wall', 'tape', 'basket_for_clothes', 'keys', 'coffe_maker', 'toilet_paper', 'television', 'curtain', 'cd', 'controller', 'table']  Task:Watch TV  response:  {       thoughts : Sit on the couch. Get comfortable. Switch on the television. Stare at the television.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'novel', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Browse internet  response:

{  I walk to the home office. I sit on the chair. I switch on the computer. I look at my monitor. I open the browsing application by click the application using mouse. I type the book that I need to searching for (using keyboard). I found the book that I need. I read the book. I switch on the printer. I print the information that I get. I read carefully the book information that I got. I switch off the printer. I switch of 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:['fork', 'toilet', 'toothbrush', 'drawing', 'floor', 'desk', 'tea_bag', 'toaster', 'mat', 'deck_of_cards', 'window', 'oil', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'bench', 'cutting_board', 'standingmirror', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'lighter', 'maindoor', 'napkin', 'instrument_guitar', 'table', 'bathroom_cabinet']  Task:Relax on sofa  response:  {       thoughts : Find the sofa and sit on it.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['tablelamp', 'chair', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'stovefan', 'mousepad', 'wall', 'nightstand', 'television', 'curtain', 'after_shave', 'mouse', 'kitchen_counter', 'clothes_dress', 'door', 'sink', 'home_office', 'soap']  Task:Read book  response:

{  find a book to read. sit down. 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:['filing_cabinet', 'food_bread', 'toilet', 'chair', 'cat', 'trashcan', 'ceilingfan', 'orchid', 'cpuscreen', 'longboard', 'desk', 'remote_control', 'button', 'food_bacon', 'foundation', 'couch', 'dining_room', 'oven', 'bench', 'basket_for_clothes', 'cup', 'bed', 'check', 'toothbrush_holder', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'controller', 'spoon', 'table']  Task:Change TV channel  response:  {       thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'freezer', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'food_jam', 'pillow', 'dining_room', 'wall', 'powersocket', 'photoframe', 'bed', 'ice', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'instrument_guitar', 'light', 'shoe_rack']  Task:Turn on light  response:

{  Walk to the Living Room. Switch on 1 light. Walk to dining room. Switch on 1 light. Walk to Entrance hall. Switch on 1 light. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'juice', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'envelope', 'computer', 'mop_bucket', 'laptop', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'doorjamb', 'mouse', 'controller', 'door']  Task:Surf internet  response:  {       thoughts : SIT ON COUCH OR CHAIR AND SURF SHOPPING AN SOCIAL MEDIA SITES,       actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['filing_cabinet', 'tea', 'toilet', 'jelly', 'band-aids', 'dog', 'walllamp', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'mop_bucket', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'pasta', 'powersocket', 'nightstand', 'razor', 'food_donut', 'tray', 'chessboard', 'controller', 'laundry_detergent', 'light']  Task:Go to toilet  response:

{  I walk into the bathroom. I walk over to the toilet. I sit on the toilet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'filing_cabinet', 'microwave', 'freezer', 'trashcan', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'shower', 'mousepad', 'dustpan', 'clothes_pants', 'dining_room', 'powersocket', 'bench', 'bed', 'toilet_paper', 'food_food', 'wine', 'mouse', 'pencil', 'kitchen_counter', 'cd', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Listen to music  response:  {       thoughts : walk to living room ,find radio ,switch on radio ,listen to music 4,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     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', 'check', 'television', 'doorjamb', 'mouse', 'address_book', 'dresser', 'door']  Task:Write an email  response:

{  Walk to Home office. Sit on the chair. Switch on the computer. Find address in addressbook. Type in the keyboard. Write mail. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'toy', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'dresser', 'dishwasher', 'shoe_rack']  Task:Watch movie  response:  {       thoughts : Sit down on couch in front of TV.  Use remote to turn on the TV,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'couch', 'wall', 'oven', 'cup', 'coffe_maker', 'food_food', 'mouthwash', 'drinking_glass', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'pajamas', 'sink', 'dishwasher']  Task:Drink  response:

{  First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I 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:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'envelope', 'mop_bucket', 'toaster', 'mat', 'faucet', 'dish_soap', 'couch', 'wall', 'cup', 'photoframe', 'toilet_paper', 'video_game_controller', 'wooden_spoon', 'tray', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light']  Task:Wash dishes  response:  {       thoughts : Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[PUTBACK] <sponge> <sink>', '[SWITCHON] <faucet>', '[RINSE] <cup>', '[GRAB] <cup>', '[FIND] <dishrack>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[GRAB] <sponge>', '[PUTOBJBACK] <sponge>']  }     Scene_Objects:['glue', 'filing_cabinet', 'mop', 'microwave', 'dog', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'form', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'centerpiece', 'sink', 'scrabble']  Task:Relax on sofa  response:

{  I walk into the living room. I bend down. I sit 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:['water_glass', 'tablelamp', 'crayon', 'freezer', 'knifeblock', 'bathroom_counter', 'shampoo', 'ceiling', 'thread', 'faucet', 'shower', 'mousepad', 'food_kiwi', 'nightstand', 'wall', 'bench', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'food_food', 'coffe_maker', 'toothbrush_holder', 'water', 'doorjamb', 'mouse', 'shoes', 'dresser', 'cupboard', 'table']  Task:Drink  response:  {       thoughts : Drinking a glass of water,       actions : ['[WALK] <dining_room>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'kitchen_cabinet', 'bathroom_counter', 'desk', 'bedroom', 'thread', 'faucet', 'shower', 'electric_shaver', 'microphone', 'towel', 'dining_room', 'wall', 'oven', 'cutting_board', 'photoframe', 'water', 'drinking_glass', 'curtain', 'food_onion', 'doorjamb', 'kettle', 'kitchen_counter', 'dresser', 'laundry_detergent', 'light', 'table', 'dirt']  Task:Drink  response:

{  You walk to the kitchen and open the kitchen cabinet and grab a drinking glass. You find the water and pour the water into the drinking glass. You drink the water from the glass. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'cat', 'ceilingfan', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'dvd_player', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'foundation', 'oil', 'couch', 'towel', 'wall', 'pasta', 'powersocket', 'television', 'curtain', 'doorjamb', 'shoes', 'pajamas', 'maindoor', 'table']  Task:Change TV channel  response:  {       thoughts : 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.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['filing_cabinet', 'crayon', 'tea', 'beer', 'toilet', 'chair', 'orchid', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'bookshelf', 'alcohol', 'stovefan', 'mat', 'shower', 'clothes_hat', 'pillow', 'wall', 'powersocket', 'bed', 'newspaper', 'novel', 'razor', 'television', 'doorjamb', 'mouse', 'dresser', 'hairdryer']  Task:Go to toilet  response:

{  I walk to bathroom, I open the door of the bathroom, and sit on the toilet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'oil', 'couch', 'wall', 'cup', 'food_food', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'console', 'hairbrush', 'cupboard', 'food_steak', 'maindoor', 'door', 'table']  Task:Watch TV  response:  {       thoughts : Watch favorite shows, netflix, hulu,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['walllamp', 'detergent', 'milk', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'stamp', 'food_cake', 'computer', 'piano_bench', 'mat', 'tvstand', 'faucet', 'shower', 'couch', 'clothes_hat', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'mouse', 'light']  Task:Relax on sofa  response:

{  I walk into the living room and I lie down 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:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer']  Task:Write an email  response:  {       thoughts : I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email,       actions : ['[WALK] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'tablelamp', 'microwave', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_bacon', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'television', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light']  Task:Cook some food  response:

{  go to the kitchen and cook some thing to eat }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'light', 'table']  Task:Watch TV  response:  {       thoughts : walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     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', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'door']  Task:Work  response:

{  Walk to home office. Sit in chair. Switch on computer. Look at computer. Type with 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:['dry_pasta', 'pot', 'food_pizza', 'filing_cabinet', 'tablelamp', 'beer', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'cat', 'cpuscreen', 'phone', 'character', 'food_cake', 'computer', 'piano_bench', 'brush', 'clothes_pants', 'dining_room', 'nightstand', 'cutting_board', 'toilet_paper', 'coffe_maker', 'check', 'curtain', 'kitchen_counter', 'table', 'scrabble', 'creditcard']  Task:Pet cat  response:  {       thoughts : Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.,       actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <bedroom>', '[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[FIND] <brush>', '[GRAB] <brush>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'food_donut', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Browse internet  response:

{  walk into Living room, look for computer, walk to computer, turn on computer, grab mouse, click mouse }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'dog', 'bathroom', 'food_carrot', 'bills', 'ceiling', 'phone', 'keyboard', 'stovefan', 'stereo', 'window', 'oven', 'bench', 'tape', 'bed', 'light_bulb', 'food_onion', 'coffee_pot', 'kettle', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'maindoor', 'instrument_guitar', 'table', 'bathroom_cabinet', 'dishwasher', 'coffee']  Task:Pet cat  response:  {       thoughts : I walk to my living room, find my cat, scrub it using my hand.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'ground_coffee', 'drawing', 'food_egg', 'cpuscreen', 'hanger', 'floor', 'bedroom', 'tea_bag', 'bookshelf', 'mat', 'tvstand', 'faucet', 'wall', 'nightstand', 'powersocket', 'bed', 'television', 'coffee_filter', 'oven_mitts', 'mouse', 'door', 'clothes_scarf', 'spoon', 'napkin', 'light', 'sink', 'bag']  Task:Go to sleep  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:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'picture', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'light']  Task:Watch TV  response:  {       thoughts : Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'bills', 'cpuscreen', 'orchid', 'hanger', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'newspaper', 'check', 'television', 'coin', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Work  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', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'television', 'doorjamb', 'dresser', 'cupboard', 'light', 'clothes_shirt']  Task:Change TV channel  response:  {       thoughts : Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[TOUCH] <button>']  }     Scene_Objects:['pot', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'mat', 'tvstand', 'faucet', 'stereo', 'picture', 'mousepad', 'couch', 'microphone', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'lighter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher']  Task:Relax on sofa  response:

{  go to living room and lie down on the sofa. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'freezer', 'ground_coffee', 'cat', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'mat', 'iron', 'couch', 'food_peanut_butter', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'clothes_gloves', 'food_food', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'hair', 'clothes_dress', 'light', 'table']  Task:Put groceries in Fridge  response:  {       thoughts : I put my groceries into the fridge.,       actions : ['[WALK] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['fork', 'microwave', 'toilet', 'cat', 'toothbrush', 'floor', 'ceiling', 'desk', 'tea_bag', 'toaster', 'mat', 'shower', 'couch', 'towel', 'box', 'cup', 'photoframe', 'food_food', 'water', 'towel_rack', 'console', 'mouse', 'vacuum_cleaner', 'hairdryer', 'bathroom_cabinet', 'dishwasher', 'soap', 'tooth_paste', 'dirt', 'teeth']  Task:Wash teeth  response:

{  Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'beer', 'crayon', 'freezer', 'walllamp', 'bathroom', 'detergent', 'wallshelf', 'floor', 'ceiling', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'photoframe', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Wipe down baseboards please  response:  {       thoughts : Use a rag to get all the dust off the baseboards please.,       actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['chair', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'closetdrawer', 'couch', 'pillow', 'wall', 'toy', 'photoframe', 'television', 'doorjamb', 'dresser', 'controller', 'food_steak', 'door']  Task:Watch TV  response:

{  Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'cup', 'television', 'doorjamb', 'mouse', 'shoes', 'door', 'sink', 'napkin', 'clothes_scarf', 'table', 'light', 'dishwasher', 'colander']  Task:Relax on sofa  response:  {       thoughts : walk to living room ,find sofa ,sit on sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sheets', 'ground_coffee', 'bathroom', 'shampoo', 'character', 'bedroom', 'bookshelf', 'keyboard', 'envelope', 'bookmark', 'shower', 'iron', 'foundation', 'mousepad', 'closetdrawer', 'couch', 'wall', 'oven', 'basket_for_clothes', 'cup', 'bed', 'food_food', 'curtain', 'towel_rack', 'cupboard', 'door', 'food_steak', 'bathroom_cabinet', 'dishwasher', 'dirt']  Task:Brush teeth  response:

{  go to the bathroom and brush your teeth }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'closetdrawer', 'wall', 'oven', 'cup', 'novel', 'water', 'drinking_glass', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'door']  Task:Drink  response:  {       thoughts : go to the kitchen,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'bathroom', 'food_carrot', 'knife', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'stamp', 'purse', 'computer', 'mat', 'shoe-shine_kit', 'shower', 'foundation', 'mousepad', 'closetdrawer', 'food_jam', 'powersocket', 'coffe_maker', 'television', 'tray', 'curtain', 'diary', 'cards', 'pencil', 'table']  Task:Listen to music  response:

{  I walk to the radio.  I switch on the radio and listen }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'filing_cabinet', 'tablelamp', 'bathroom', 'trashcan', 'food_butter', 'cpuscreen', 'desk', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'bench', 'oven', 'powersocket', 'toy', 'photoframe', 'coffe_maker', 'television', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'sink', 'home_office']  Task:Pick up toys  response:  {       thoughts : Grab toys off floor.  Put it in a container.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['dry_pasta', 'chair', 'walllamp', 'drawing', 'needle', 'wallshelf', 'bills', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'tooth_paste']  Task:Watch TV  response:

{  I enter the living room and sit on the couch. I grab the remote and turn on the TV. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'chair', 'ceilingfan', 'dough', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'folder', 'bedroom', 'character', 'ceilinglamp', 'mat', 'balanceball', 'mousepad', 'wall', 'nightstand', 'box', 'check', 'television', 'doorjamb', 'pencil', 'vacuum_cleaner', 'dresser', 'cupboard', 'conditioner', 'door', 'light', 'table']  Task:Turn on light  response:  {       thoughts : I walk into the kitchen, I find the light switch, and then i switch on the lights in the kitchen.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['food_ice_cream', 'microwave', 'toilet', 'freezer', 'blow_dryer', 'bathroom', 'cpuscreen', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'food_bacon', 'tvstand', 'clothes_socks', 'oil', 'towel', 'nightstand', 'oven', 'bed', 'check', 'coffee_filter', 'curtain', 'clothes_dress', 'door', 'sink', 'home_office', 'table', 'light', 'colander', 'laser_pointer']  Task:Drink  response:

{  Pour water into a glass and drink from the glass. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'window', 'homework', 'couch', 'dustpan', 'food_orange', 'dining_room', 'wall', 'nightstand', 'photoframe', 'clothes_gloves', 'coffe_maker', 'check', 'television', 'mouse', 'pencil', 'table', 'laser_pointer']  Task:Relax on sofa  response:  {       thoughts : Walk to the living room, turn to the sofa. Sit on the sofa and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']  }     Scene_Objects:['mop', 'freezer', 'bathroom', 'dough', 'drawing', 'clothes_underwear', 'shampoo', 'bedroom', 'bookshelf', 'stovefan', 'tvstand', 'shower', 'mousepad', 'couch', 'dining_room', 'wall', 'food_food', 'check', 'rag', 'mouse', 'kitchen_counter', 'chessboard', 'cd', 'shoes', 'door', 'napkin', 'home_office', 'dishwasher', 'board_game', 'coffee']  Task:Pick up phone  response:

{  i go find the phone. i pick up the phone }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'crayon', 'chair', 'walllamp', 'detergent', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'pillow', 'wall', 'powersocket', 'newspaper', 'television', 'tray', 'doorjamb', 'mouse', 'pencil', 'door', 'light', 'table']  Task:Write an email  response:  {       thoughts : I walk into my office and go to the computer desk. I sit at my desk and turn the computer on. Then I write an email.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['microwave', 'freezer', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'alcohol', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'television', 'coffe_maker', 'ice', 'kitchen_counter', 'cupboard', 'hair', 'table', 'scrabble']  Task:Put groceries in Fridge  response:

{  I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge. }


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

{  Go to the living room.  Find the telephone.  Lift up the receiver. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'walllamp', 'bathroom', 'orchid', 'bills', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'bowl', 'nightstand', 'wall', 'oven', 'bed', 'novel', 'food_food', 'television', 'oven_mitts', 'curtain', 'dresser', 'controller', 'table', 'dishwasher', 'soap']  Task:Watch TV  response:  {       thoughts : walk to living room ,find television , switch on remote control,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[SWITCHON] <remote_control>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'food_onion', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office']  Task:Browse internet  response:

{  turn on the computer 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:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'thread', 'toaster', 'dustpan', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'chessboard', 'cupboard', 'spoon', 'light', 'dishwasher']  Task:Make coffee  response:  {       thoughts : Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[FIND] <water>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Browse internet  response:

{  I go to the living room, where my computer is. I locate it, switch it on and type desired URL adress in the web browser. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_pizza', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'needle', 'floor', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'window', 'homework', 'oil', 'dustpan', 'bowl', 'wall', 'pasta', 'oven', 'toy', 'food_food', 'oven_mitts', 'tray', 'kitchen_counter', 'napkin', 'table', 'dishwasher', 'laser_pointer', 'teeth']  Task:Cook some food  response:  {       thoughts : I switch on the stove and cook my groceries there.,       actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[SWITCHON] <oven>', '[FIND] <bowl>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <oven>', '[FIND] <food_food>', '[SWITCHOFF] <oven>']  }     Scene_Objects:['tablelamp', 'mop', 'microwave', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Browse internet  response:

{  Walk to the Home Office.  Find the computer.  Turn 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', 'food_salt', 'crayon', 'freezer', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'shampoo', 'desk', 'mail', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mat', 'electric_shaver', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'basket_for_clothes', 'food_food', 'diary', 'towel_rack', 'dresser', 'clothes_dress']  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:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'needle', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:

{  Go to office, sit at desk, turn on computer, enter password, open application and begin 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:['filing_cabinet', 'toilet', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'stovefan', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'towel', 'wall', 'nightstand', 'curtain', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SQUEEZE] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'bills', 'cpuscreen', 'orchid', 'hanger', 'wallshelf', '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:Browse internet  response:

{  I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'controller', 'door', 'light', 'table']  Task:Work  response:  {       thoughts : Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'detergent', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'toaster', 'mat', 'faucet', 'iron', 'mousepad', 'wall', 'powersocket', 'cup', 'coffe_maker', 'water', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'clothes_scarf', 'colander']  Task:Drink  response:

{  I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'food_chicken', 'desk', 'stovefan', 'ceilinglamp', 'toaster', 'balanceball', 'shower', 'faucet', 'food_noodles', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'bed', 'food_food', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'dishwasher']  Task:Cook some food  response:  {       thoughts : I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>']  }     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', 'keys', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Write an email  response:

{  I need to send an email to my friend so I go into my office and sit down at the desk. I turn on the computer and type the email. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'food_pizza', 'jelly', 'freezer', 'bathroom', 'detergent', 'food_butter', 'food_carrot', 'cpuscreen', 'bedroom', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'mousepad', 'food_noodles', 'food_orange', 'nightstand', 'cup', 'check', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'napkin', 'spoon', 'table', 'home_office', 'soap']  Task:Open door  response:  {       thoughts : Open the door when leaving or coming in.,       actions : ['[WALK] <home_office>']  }     Scene_Objects:['food_salt', 'microwave', 'toilet', 'walllamp', 'cat', 'food_carrot', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'mop_bucket', 'stovefan', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'bed', 'novel', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'controller', 'door', 'food_steak', 'spoon', 'light']  Task:Turn on light  response:

{  I walk to wall. I put my hand on the switch. I push the button. I turn on the lights. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'window', 'couch', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'food_steak', 'door', 'sink', 'table']  Task:Make toast  response:  {       thoughts : Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <toaster>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'shoe-shine_kit', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light', 'laser_pointer']  Task:Browse internet  response:

{  i'm walkin to the home office, i'm walking to the desk, i'm sitting on the chair, i'm turning on the computer and i'm browsing 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', 'food_salt', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'razor', 'television', 'food_rice', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dirt']  Task:Work  response:  {       thoughts : I go to my office. I switch the computer on and sit on the office chair. I look at the computer screen to see what needs to be done. I use my mouse to navigate to the relevant directory, then release it. I type code with my keyboard. When I'm done, I look at the computer again to evaluate what I've done. Then I switch off the computer using the mouse and put back the mouse.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[SWITCHOFF] <computer>', '[PUTOBJBACK] <mouse>']  }     Scene_Objects:['scissors', 'tablelamp', 'beer', 'toilet', 'walllamp', 'orchid', 'bathroom_counter', 'dvd_player', 'stamp', 'envelope', 'clothes_jacket', 'toaster', 'ceilinglamp', 'faucet', 'food_noodles', 'pillow', 'bowl', 'nightstand', 'coffe_maker', 'check', 'ice', 'tray', 'after_shave', 'mouse', 'hairbrush', 'sink', 'napkin', 'light', 'clothes_shirt', 'creditcard']  Task:Receive credit card  response:

{  hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'fork', 'beer', 'walllamp', 'bathroom', 'orchid', 'kitchen_cabinet', 'floor', 'phone', 'toaster', 'mat', 'plate', 'tvstand', 'window', 'dish_soap', 'couch', 'bowl', 'wall', 'oven', 'bench', 'coffe_maker', 'tray', 'rag', 'console', 'kitchen_counter', 'dishrack', 'hair', 'maindoor', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet..,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>', '[GRAB] <plate>', '[WIPE] <plate>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[PUTOBJBACK] <dishrack>']  }     Scene_Objects:['sponge', 'toilet', 'chair', 'walllamp', 'bathroom', 'ground_coffee', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'foundation', 'mousepad', 'wall', 'cup', 'newspaper', 'bed', 'coffe_maker', 'doorjamb', 'dresser', 'conditioner', 'door', 'light', 'dishwasher', 'tooth_paste']  Task:Change TV channel  response:

{  take remote control, push \ change channel\  button }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'beer', 'tea', 'ground_coffee', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'plate', 'tvstand', 'closetdrawer', 'couch', 'food_jam', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'chessboard', 'door', 'light']  Task:Turn on light  response:  {       thoughts : walk into living room, walk to light, turn on light switch.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['pot', 'food_salt', 'microwave', 'drawing', 'orchid', 'wallshelf', 'floor', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'faucet', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'novel', 'coffe_maker', 'food_rice', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'orchid', 'hanger', 'ceiling', 'keyboard', 'piano_bench', 'tvstand', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'wall', 'powersocket', 'bench', 'cutting_board', 'toy', 'photoframe', 'bed', 'razor', 'wooden_spoon', 'after_shave', 'coffee_pot', 'dresser', 'clothes_dress', 'bathtub', 'bathroom_cabinet', 'light', 'clothes_shirt', 'washing_machine', 'shoe_rack']  Task:Wash clothes  response:  {       thoughts : walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off washing machine.,       actions : ['[WALK] <dining_room>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[TURNTO] <washing_machine>', '[LOOKAT] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>', '[SWITCHOFF] <washing_machine>']  }     Scene_Objects:['pot', 'jelly', 'freezer', 'food_carrot', 'drawing', 'floor', 'ceiling', 'desk', 'envelope', 'table_cloth', 'mat', 'faucet', 'mousepad', 'couch', 'pillow', 'towel', 'wall', 'cup', 'food_food', 'mouthwash', 'television', 'water', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'light', 'dishwasher', 'table']  Task:Drink  response:

{  Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'thread', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'toilet_paper', 'television', 'razor', 'coin', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table']  Task:Turn on computer  response:  {       thoughts : Push power button.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['tablelamp', 'microwave', 'dog', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'shower', 'couch', 'wall', 'powersocket', 'newspaper', 'keys', 'wooden_spoon', 'doorjamb', 'centerpiece', 'kitchen_counter', 'door', 'home_office', 'light', 'shoe_rack']  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:['filing_cabinet', 'tea', 'chair', 'knifeblock', 'knife', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'desk', 'bedroom', 'bookshelf', 'food_bacon', 'mat', 'shoe-shine_kit', 'food_jam', 'wall', 'powersocket', 'oven', 'photoframe', 'novel', 'mouthwash', 'coffee_filter', 'tray', 'curtain', 'vacuum_cleaner', 'dresser', 'bathtub', 'soap']  Task:Read to child  response:  {       thoughts : Read a book out loud to a child,       actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'laptop', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dishrack', 'door', 'light', 'shoe_rack']  Task:Browse internet  response:

{  Walk to home office, walk to desk, sit in chair, turn on laptop, grab mouse, open a web page to look at it, move mouse, keep looking at laptop screen. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', '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:  {       thoughts : Coming home turning on lights.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'faucet', 'mousepad', 'clothes_socks', 'dustpan', 'wall', 'coffe_maker', 'oven_mitts', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'sink', 'home_office', 'light', 'clothes_skirt', 'board_game', 'coffee']  Task:Pick up phone  response:

{  I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'mop', 'bathroom', 'dough', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'cleaning_solution', 'keyboard', 'mat', 'faucet', 'window', 'food_noodles', 'closetdrawer', 'couch', 'clothes_pants', 'nightstand', 'tape', 'food_food', 'check', 'food_rice', 'wooden_spoon', 'rag', 'mouse', 'controller', 'door', 'home_office']  Task:Clean mirror  response:  {       thoughts : Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.,       actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'blow_dryer', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'dishwasher']  Task:Write an email  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'shoes', 'door', 'table', 'light', 'creditcard']  Task:Watch  TV  response:  {       thoughts : Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['fork', 'pot', 'food_bread', 'dry_pasta', 'tablelamp', 'filing_cabinet', 'measuring_cup', 'microwave', 'toilet', 'chair', 'walllamp', 'floor', 'bookshelf', 'toaster', 'mat', 'faucet', 'shower', 'closetdrawer', 'bowl', 'dining_room', 'wall', 'newspaper', 'coffe_maker', 'oven_mitts', 'diary', 'kitchen_counter', 'cupboard', 'clothes_dress', 'sink', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  Walk to Kitchen. Take the dishes from the sink. Apply dish washer, scrub and then wash with water. }


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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'bookshelf', 'mat', 'shower', 'faucet', 'wall', 'powersocket', 'oven', 'light_bulb', 'novel', 'check', 'television', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'spoon', 'home_office', 'light', 'dishwasher']  Task:Turn on light  response:  {       thoughts : Switch on light in home office,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[WALK] <home_office>']  }     Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'button', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'novel', 'television', 'doorjamb', 'dresser']  Task:Change TV channel  response:

{  first i will go to living room and then take the remote and swtitch on television after that il change the channel }