Datasets:

Barrybw

/

ustc_test

like 0

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'blender', 'food_salt', 'toilet', 'chair', 'toothbrush', 'drawing', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'alcohol', 'clothes_jacket', 'ceilinglamp', 'foundation', 'pillow', 'bowl', 'dining_room', 'bed', 'curtain', 'lighter', 'doorjamb', 'towel_rack', 'console', 'chessboard', 'cd', 'clothes_scarf', 'instrument_guitar', 'light', 'teeth'] Task:Listen to music response: { "thoughts": I walk to the living room. I find a radio there and switch it on to listen to music., "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] }

Scene_Objects:['pot', 'tablelamp', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'ceilinglamp', 'plate', 'mat', 'couch', 'wall', 'oven', 'food_food', 'tray', 'food_onion', 'curtain', 'diary', 'kitchen_counter', 'dishrack', 'sauce_pan', 'cupboard', 'spoon', 'home_office'] Task:Cook some food response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'microwave', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'folder', 'desk', 'alcohol', 'stovefan', 'plate', 'mousepad', 'wall', 'oven', 'food_food', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'sink', 'clothes_scarf', 'light', 'clothes_shirt', 'teeth'] Task:Pick up phone response: { "thoughts": walk over and pick up the phone, "actions": ['[WALK] <phone>', '[GRAB] <phone>'] }

Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'trashcan', 'bills', 'knife', 'floor', 'desk', 'mail', 'button', 'toaster', 'plate', 'faucet', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'nightstand', 'oven', 'bed', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'tray', 'sink', 'table', 'dishwasher', 'shoe_rack'] Task:Wash dishes with dishwasher response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'freezer', 'walllamp', 'cat', 'ceilingfan', 'drawing', 'cpuscreen', 'clothes_underwear', 'longboard', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'ice', 'curtain', 'after_shave', 'door', 'table', 'dishwasher', 'vase'] Task:Watch TV response: { "thoughts": Sit on couch and watch the tv, "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['freezer', 'blow_dryer', 'ceilingfan', 'trashcan', 'toothbrush', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'coffe_maker', 'television', 'food_donut', 'curtain', 'coffee_pot', 'controller', 'sink', 'bathroom_cabinet', 'table', 'soap', 'teeth', 'shoe_rack'] Task:Watch TV response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'drawing', 'duster', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'mat', 'tvstand', 'picture', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'powersocket', 'photoframe', 'food_food', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'light', 'home_office', 'scrabble'] Task:Dust response: { "thoughts": Using the duster, lightly dust all hanging pictures on walls in living room. Dust all around surface of picture frame and front of pictures, moving duster back and forth, side to side, until all dust is gone., "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <duster>', '[GRAB] <duster>', '[WALK] <wall>', '[WALK] <picture>', '[WIPE] <picture>', '[WALK] <picture>', '[WIPE] <picture>', '[WALK] <picture>', '[WIPE] <picture>', '[WALK] <filing_cabinet>', '[PUTBACK] <duster> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] }

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:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer'] Task:Relax on sofa response: { "thoughts": walk to living room, walk to sofa, sit in sofa, "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] }

Scene_Objects:['juice', 'detergent', 'knifeblock', 'cpuscreen', 'longboard', 'folder', 'character', 'bookshelf', 'table_cloth', 'toaster', 'stereo', 'picture', 'food_orange', 'nightstand', 'wall_clock', 'tape', 'light_bulb', 'coffe_maker', 'ice', 'tray', 'curtain', 'doorjamb', 'cd', 'shoes', 'dresser', 'door', 'sink', 'light', 'dishwasher', 'teeth'] Task:Listen to music response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'mail', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'window', 'mousepad', 'wall', 'nightstand', 'photoframe', 'novel', 'doorjamb', 'mouse', 'light', 'dishwasher'] Task:Write an email response: { "thoughts": Switch on computer, Use keybord and mouse to open e-mail provider, type requested e-mail, click send, close e-mail provider, turn off computer, "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[FIND] <keyboard>', '[FIND] <mail>', '[OPEN] <mail>', '[TYPE] <keyboard>', '[FIND] <button>', '[PUSH] <button>', '[CLOSE] <mail>', '[SWITCHOFF] <computer>'] }

Scene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'needle', 'floor', 'mail', 'plate', 'faucet', 'window', 'pillow', 'nightstand', 'basket_for_clothes', 'cup', 'photoframe', 'bed', 'coffe_maker', 'coffee_filter', 'coin', 'water', 'after_shave', 'dresser', 'hairbrush', 'maindoor', 'table', 'shoe_rack'] Task:Drink response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'microwave', 'ground_coffee', 'knifeblock', 'wallshelf', 'ceiling', 'phone', 'character', 'desk', 'piano_bench', 'stovefan', 'toaster', 'couch', 'clothes_hat', 'pillow', 'bench', 'oven', 'tape', 'cutting_board', 'doorjamb', 'cards', 'mouse', 'dishrack', 'cupboard', 'hairdryer', 'sink', 'clothes_scarf', 'table', 'dishwasher'] Task:Pick up phone response: { "thoughts": i go find the phone. i pick up the phone, "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] }

Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'door', 'light'] Task:Browse internet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'detergent', 'cat', 'knife', 'food_egg', 'character', 'stamp', 'bedroom', 'desk', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'window', 'oil', 'mousepad', 'clothes_hat', 'towel', 'pillow', 'dining_room', 'powersocket', 'coin', 'console', 'towel_rack', 'dishrack', 'cupboard', 'maindoor', 'sink', 'bag'] Task:Keep cats out of room response: { "thoughts": Stand in the doorway and create a loud noise so the cats will stay out., "actions": ['[WALK] <bedroom>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>'] }

Scene_Objects:['tablelamp', 'toilet', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'ceilinglamp', 'balanceball', 'mousepad', 'dustpan', 'towel', 'food_kiwi', 'wall', 'nightstand', 'novel', 'doorjamb', 'mouse', 'home_office', 'light'] Task:Write an email response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt'] Task:Get dressed response: { "thoughts": Get some clothes together that make an appropriate outfit. Put them on, "actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>'] }

Scene_Objects:['spectacles', 'tea', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'keys', 'novel', 'coffe_maker', 'clothes_gloves', 'coffee_filter', 'water', 'ice', 'tray', 'food_onion', 'cupboard', 'door', 'light', 'dishwasher', 'soap'] Task:Make coffee response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'tablelamp', 'crayon', 'microwave', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bookshelf', 'computer', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'window', 'oil', 'couch', 'food_jam', 'food_orange', 'wall', 'bench', 'mouthwash', 'television', 'cupboard', 'table', 'clothes_skirt', 'light', 'tooth_paste'] Task:Relax on sofa response: { "thoughts": walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa, "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>'] }

Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'laptop', 'faucet', 'tvstand', 'window', 'couch', 'microphone', 'towel', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'food_food', 'television', 'tray', 'mouse', 'dresser', 'sink', 'clothes_scarf', 'home_office', 'table', 'clothes_skirt'] Task:Relax on sofa response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_salt', 'microwave', 'toilet', 'walllamp', 'drawing', 'needle', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'computer', 'bookmark', 'stovefan', 'plate', 'tvstand', 'dish_soap', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'oven', 'powersocket', 'curtain', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: { "thoughts": Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher., "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] }

Scene_Objects:['tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_cheese', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'bathroom_cabinet', 'light', 'home_office'] Task:Work response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'food_ice_cream', 'measuring_cup', 'knife', 'orchid', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'alcohol', 'computer', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'window', 'pillow', 'powersocket', 'cup', 'newspaper', 'check', 'ice', 'after_shave', 'lighter', 'diary', 'cd', 'cupboard', 'maindoor', 'colander', 'board_game'] Task:Listen to music response: { "thoughts": Find radio, turn it on, "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] }

Scene_Objects:['pot', 'scissors', 'freezer', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'piano_bench', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'pillow', 'wall', 'nightstand', 'bed', 'newspaper', 'food_onion', 'doorjamb', 'towel_rack', 'shoes', 'dresser', 'hair', 'hairdryer', 'maindoor', 'spoon', 'table'] Task:Put groceries in Fridge response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste'] Task:Cook some food response: { "thoughts": Go kitchen and make something for eat, "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>'] }

Scene_Objects:['water_glass', 'microwave', 'needle', 'kitchen_cabinet', 'desk', 'alcohol', 'mat', 'ceilinglamp', 'balanceball', 'window', 'couch', 'clothes_pants', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'oven', 'toilet_paper', 'mouthwash', 'water', 'ice', 'tray', 'rag', 'doorjamb', 'towel_rack', 'coffee_pot', 'pencil', 'door', 'dishwasher', 'vase'] Task:Drink response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'walllamp', 'food_carrot', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'food_bacon', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'wall', 'powersocket', 'toy', 'photoframe', 'mouse', 'controller', 'door', 'table', 'light'] Task:Browse internet response: { "thoughts": turn on the computer and browse the internet, "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] }

Scene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'food_salt', 'jelly', 'band-aids', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'broom', 'wall', 'powersocket', 'doorjamb', 'lighter', 'door', 'sink', 'light', 'table', 'laser_pointer', 'clothes_shirt', 'creditcard'] Task:Turn on light response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'chair', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'window', 'mousepad', 'broom', 'wall', 'wall_clock', 'nightstand', 'novel', 'coin', 'lighter', 'centerpiece', 'mouse', 'dresser'] Task:Read book response: { "thoughts": find a book to read. sit down. read the book., "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] }

Scene_Objects:['water_glass', 'pot', 'food_salt', 'mop', 'freezer', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'purse', 'button', 'piano_bench', 'food_bacon', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'form', 'wall', 'bench', 'food_food', 'television', 'water', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'maindoor', 'table'] Task:Drink response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'chair', 'drawing', 'bills', 'knife', 'floor', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_jam', 'form', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'novel', 'food_food', 'check', 'television', 'oven_mitts', 'razor', 'tray', 'pencil', 'dresser', 'pajamas', 'table', 'soap'] Task:Read book response: { "thoughts": Sit and read, "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>'] }

Scene_Objects:['tablelamp', 'microwave', 'board_game', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'longboard', 'phone', 'ceiling', 'dvd_player', 'bedroom', 'tea_bag', 'stamp', 'keyboard', 'stovefan', 'plate', 'picture', 'form', 'pillow', 'oven', 'television', 'centerpiece', 'shoes', 'cd', 'bag', 'dishwasher', 'soap', 'tooth_paste', 'creditcard'] Task:Pet cat response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'pasta', 'powersocket', 'photoframe', 'television', 'food_donut', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'laundry_detergent', 'table'] Task:Watch TV response: { "thoughts": walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button, "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>'] }

Scene_Objects:['filing_cabinet', 'microwave', 'ceilingfan', 'drawing', 'knifeblock', 'knife', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'stereo', 'food_noodles', 'couch', 'dustpan', 'form', 'dining_room', 'wall', 'powersocket', 'oven', 'check', 'television', 'curtain', 'kitchen_counter', 'cd', 'table', 'vase'] Task:Watch TV response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'oven', 'check', 'television', 'oven_mitts', 'doorjamb', 'mouse', 'kitchen_counter', 'sink', 'napkin', 'table', 'shoe_rack'] Task:Browse internet response: { "thoughts": I will walk to the computer at the desk in my home office, sit in the chair, turn on the computer, open a web browser, type in the address, and view the computer., "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] }

Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'coffe_maker', 'doorjamb', 'coffee_pot', 'headset', 'door', 'hairdryer', 'light', 'tooth_paste'] Task:Turn on light response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'stovefan', 'wall_clock', 'powersocket', 'bed', 'food_food', 'television', 'wooden_spoon', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'hairdryer', 'home_office', 'light', 'clothes_skirt', 'bathtub', 'bathroom_cabinet'] Task:Read book response: { "thoughts": pick up your book and read it, "actions": ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>'] }

Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'mat', 'ceilinglamp', 'shower', 'plate', 'wall', 'nightstand', 'powersocket', 'food_cheese', 'bed', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'dresser', 'controller', 'clothes_scarf', 'home_office', 'bathroom_cabinet', 'board_game', 'scrabble', 'teeth'] Task:Take shower response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'door', 'light'] Task:Browse internet response: { "thoughts": I want to surf the internet and look around at funny pictures., "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] }

Scene_Objects:['pot', 'measuring_cup', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'character', 'toaster', 'mat', 'dish_soap', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'shaving_cream', 'cupboard', 'food_steak', 'dishwasher'] Task:Wash dishes with dishwasher response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'mop', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'chessboard', 'laundry_detergent', 'door', 'board_game'] Task:Go to toilet response: { "thoughts": walk to bathroom , run to toilet, "actions": ['[WALK] <bathroom>', '[RUN] <toilet>'] }

Scene_Objects:['chair', 'band-aids', 'trashcan', 'dough', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'mousepad', 'food_orange', 'wall', 'oven', 'keys', 'mouse', 'shoes', 'hair', 'dishwasher', 'vase', 'coffee'] Task:Read book response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'freezer', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'piano_bench', 'stovefan', 'mat', 'faucet', 'wall', 'wall_clock', 'oven', 'cutting_board', 'toilet_paper', 'video_game_controller', 'television', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'kitchen_counter', 'dresser', 'conditioner', 'sink', 'bathroom_cabinet', 'light', 'teeth'] Task:Wash teeth response: { "thoughts": Walk to bathroom. Find mouthwash or turn on water. Put mouthwash or water in mouth. Swish around for 30 seconds. Spit mouthwash out., "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[RINSE] <teeth>'] }

Scene_Objects:['glue', 'pot', 'scissors', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'button', 'toaster', 'plate', 'tvstand', 'dish_soap', 'oil', 'candle', 'wall', 'oven', 'tape', 'box', 'coffe_maker', 'food_food', 'check', 'tray', 'centerpiece', 'controller', 'light', 'dishwasher', 'soap'] Task:Wash dishes with dishwasher response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'orchid', 'drawing', 'bedroom', 'tea_bag', 'bookshelf', 'envelope', 'alcohol', 'computer', 'ceilinglamp', 'mat', 'shower', 'deck_of_cards', 'food_noodles', 'microphone', 'bowl', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'dresser', 'napkin', 'table', 'clothes_shirt'] Task:Pet cat response: { "thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently., "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['toilet', 'chair', 'freezer', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'desk', 'bedroom', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'stereo', 'wall', 'pasta', 'cup', 'tray', 'doorjamb', 'dresser', 'cupboard', 'hair', 'clothes_dress', 'door', 'clothes_scarf', 'maindoor', 'light', 'dishwasher'] Task:Turn on light response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'ceiling', 'phone', 'thread', 'computer', 'stovefan', 'faucet', 'shower', 'food_jam', 'dining_room', 'wall', 'powersocket', 'tape', 'coffe_maker', 'food_food', 'mirror', 'doorjamb', 'mouse', 'paper_towel', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'dirt'] Task:Clean mirror response: { "thoughts": Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks., "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[WIPE] <mirror>', '[FIND] <trashcan>', '[PUTBACK] <paper_towel> <trashcan>'] }

Scene_Objects:['pot', 'toilet', 'jelly', 'band-aids', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'shampoo', 'ceiling', 'desk', 'keyboard', 'purse', 'brush', 'toaster', 'shoe-shine_kit', 'plate', 'faucet', 'mousepad', 'towel', 'dining_room', 'wall', 'photoframe', 'newspaper', 'coffe_maker', 'toothbrush_holder', 'mouse', 'door', 'home_office'] Task:Go to toilet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'phone', 'tea_bag', 'computer', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'clothes_hat', 'wall', 'oven', 'bench', 'television', 'curtain', 'vacuum_cleaner', 'dresser', 'maindoor', 'spoon', 'home_office', 'table'] Task:Watch TV response: { "thoughts": walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television, "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['pot', 'tablelamp', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'mousepad', 'dustpan', 'wall', 'nightstand', 'photoframe', 'wine', 'doorjamb', 'mouse', 'dresser', 'light', 'colander'] Task:Browse internet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'computer', 'mat', 'shoe-shine_kit', 'oil', 'pillow', 'wall', 'pasta', 'powersocket', 'cup', 'food_food', 'video_game_controller', 'toothbrush_holder', 'television', 'doorjamb', 'kettle', 'door', 'light', 'clothes_skirt', 'coffee'] Task:Turn on light response: { "thoughts": switching on light in an area, "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] }

Scene_Objects:['tablelamp', 'bathroom', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'purse', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'couch', 'dining_room', 'wall', 'bench', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'wooden_spoon', 'curtain', 'pencil', 'shoes', 'table', 'light', 'vase'] Task:Change TV channel response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'plate', 'faucet', 'shower', 'couch', 'pillow', 'dining_room', 'wall', 'pasta', 'newspaper', 'novel', 'check', 'toilet_paper', 'food_food', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'controller', 'door', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: { "thoughts": I walk into the living room. I cross the room to the couch. I sit down and relax., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] }

Scene_Objects:['pot', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'food_bacon', 'table_cloth', 'stovefan', 'faucet', 'dining_room', 'wall', 'oven', 'photoframe', 'novel', 'coffe_maker', 'drinking_glass', 'wine', 'shaving_cream', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'dishwasher', 'scrabble'] Task:Drink response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'balanceball', 'mat', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'light', 'dishwasher'] Task:Work response: { "thoughts": Go to office, sit at desk, turn on computer, enter password, open application and begin work, "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] }

Scene_Objects:['spectacles', 'food_bread', 'filing_cabinet', 'tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'mousepad', 'food_noodles', 'pillow', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'doorjamb', 'towel_rack', 'mouse', 'light'] Task:Work response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'microwave', 'trashcan', 'drawing', 'floor', 'dvd_player', 'desk', 'envelope', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'check', 'television', 'coin', 'colander', 'after_shave', 'cd', 'cupboard', 'table', 'vase', 'soap'] Task:Relax on sofa response: { "thoughts": Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax, "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] }

Scene_Objects:['filing_cabinet', 'juice', 'cat', 'food_butter', 'orchid', 'hanger', 'floor', 'shampoo', 'phone', 'mat', 'shower', 'electric_shaver', 'dustpan', 'microphone', 'towel', 'pillow', 'dining_room', 'wall', 'bench', 'tape', 'food_cheese', 'check', 'wine', 'curtain', 'vacuum_cleaner', 'dresser', 'sink', 'napkin', 'bathroom_cabinet', 'vase'] Task:Read book response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'window', 'food_noodles', 'couch', 'microphone', 'pillow', 'wall', 'newspaper', 'novel', 'coffe_maker', 'television', 'coin', 'toothbrush_holder', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'bathroom_cabinet', 'table', 'vase', 'laser_pointer', 'creditcard'] Task:Read book response: { "thoughts": Sit on couch. Grab book. Open book. Read book., "actions": ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] }

Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'food_bacon', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'clothes_pants', 'wall', 'toy', 'food_food', 'television', 'oven_mitts', 'curtain', 'diary', 'headset', 'home_office', 'table'] Task:Change TV channel response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'pot', 'filing_cabinet', 'microwave', 'chair', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'face', 'toaster', 'stovefan', 'faucet', 'oil', 'towel', 'wall', 'facial_cleanser', 'check', 'coffe_maker', 'tray', 'rag', 'mouse', 'kitchen_counter', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap'] Task:Wash face response: { "thoughts": Turn the faucet on. Wet the face. Take facial cleanser out of packaging. Lather on face. Rinse face with water. Turn off the faucet. Dry face with towel., "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <face>', '[WASH] <face>', '[FIND] <rag>', '[GRAB] <rag>', '[RINSE] <rag>', '[FIND] <facial_cleanser>', '[GRAB] <facial_cleanser>', '[POUR] <facial_cleanser> <rag>', '[PUTOBJBACK] <facial_cleanser>', '[SCRUB] <face>', '[RINSE] <rag>', '[PUTOBJBACK] <rag>', '[RINSE] <face>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>'] }

Scene_Objects:['chair', 'freezer', 'detergent', 'food_butter', 'trashcan', 'hanger', 'floor', 'phone', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'laptop', 'plate', 'window', 'wall', 'nightstand', 'bed', 'check', 'curtain', 'doorjamb', 'dresser', 'cupboard', 'controller', 'door', 'light', 'dishwasher', 'laser_pointer', 'shoe_rack'] Task:Pick up phone response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'toilet', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'clothes_gloves', 'novel', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light', 'dishwasher'] Task:Pet cat response: { "thoughts": walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly, "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['food_bread', 'scissors', 'mop', 'chair', 'ceilingfan', 'milk', 'toothbrush', 'knifeblock', 'phone', 'bookshelf', 'stovefan', 'toaster', 'tvstand', 'shower', 'couch', 'food_peanut_butter', 'dustpan', 'oven', 'photoframe', 'clothes_gloves', 'bed', 'video_game_controller', 'tray', 'towel_rack', 'clothes_scarf', 'table', 'light', 'soap', 'tooth_paste', 'scrabble'] Task:Wash teeth response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'food_egg', 'bathroom_counter', 'shampoo', 'phone', 'mat', 'ceilinglamp', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'microphone', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'check', 'food_food', 'after_shave', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'laser_pointer'] Task:Turn on light response: { "thoughts": I go home and it's dark so I can not see anything, "actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] }

Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'button', 'ceilinglamp', 'faucet', 'oil', 'teeth', 'clothes_hat', 'towel', 'wall', 'photoframe', 'bed', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'coffee', 'hairbrush', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'hands_both'] Task:Wash hands response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'blender', 'chair', 'freezer', 'walllamp', 'nail_polish', 'detergent', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'desk', 'computer', 'mat', 'ceilinglamp', 'plate', 'faucet', 'mousepad', 'candle', 'microphone', 'bowl', 'wall', 'nightstand', 'bench', 'bed', 'keys', 'food_food', 'table'] Task:Eat response: { "thoughts": I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food, "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <food_food> <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <plate>', '[EAT] <plate>'] }

Scene_Objects:['blender', 'dog', 'band-aids', 'drawing', 'bathroom_counter', 'floor', 'longboard', 'bedroom', 'food_cake', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'window', 'couch', 'dustpan', 'clothes_pants', 'bowl', 'wall', 'television', 'oven_mitts', 'after_shave', 'doorjamb', 'towel_rack', 'cards', 'shoes', 'home_office', 'table'] Task:Relax on sofa response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light'] Task:Research response: { "thoughts": I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc., "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>'] }

Scene_Objects:['tablelamp', 'chair', 'freezer', 'nail_polish', 'trashcan', 'bills', 'drawing', 'hanger', 'bathroom_counter', 'character', 'bedroom', 'keyboard', 'computer', 'stereo', 'shower', 'form', 'dining_room', 'powersocket', 'oven', 'bench', 'cup', 'coffe_maker', 'mouthwash', 'television', 'coin', 'wooden_spoon', 'tray', 'doorjamb', 'mouse', 'bathroom_cabinet'] Task:Listen to music response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'shower', 'homework', 'wall', 'powersocket', 'box', 'bed', 'coffe_maker', 'television', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'cupboard', 'home_office', 'light', 'dishwasher'] Task:Turn on light response: { "thoughts": Walk into living room. Find wall. Find light button. Switch on light button., "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] }

Scene_Objects:['pot', 'food_bread', 'food_ice_cream', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'longboard', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'oil', 'couch', 'wall', 'bench', 'mouthwash', 'television', 'curtain', 'shaving_cream', 'mouse', 'headset', 'bathroom_cabinet', 'table', 'light'] Task:Watch TV response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'juice', 'microwave', 'freezer', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'ceilinglamp', 'plate', 'window', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'powersocket', 'novel', 'food_food', 'mouthwash', 'television', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'comb', 'door', 'laser_pointer'] Task:Put groceries in Fridge response: { "thoughts": Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge,, "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] }

Scene_Objects:['food_pizza', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'purse', 'computer', 'mail', 'toaster', 'tvstand', 'mousepad', 'wall', 'check', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'cards', 'dresser', 'cupboard', 'door', 'napkin', 'light', 'scrabble'] Task:Pick up phone response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'ground_coffee', 'wallshelf', 'hanger', 'floor', 'stamp', 'desk', 'bookshelf', 'tea_bag', 'envelope', 'computer', 'mop_bucket', 'mat', 'shower', 'foundation', 'form', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'novel', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'door', 'light'] 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', 'food_bread', 'freezer', 'food_butter', 'toothbrush', 'knifeblock', 'food_egg', 'cpuscreen', 'longboard', 'bathroom_counter', 'phone', 'ceiling', 'tea_bag', 'plate', 'shower', 'deck_of_cards', 'window', 'electric_shaver', 'dish_soap', 'broom', 'bench', 'powersocket', 'tape', 'mouthwash', 'centerpiece', 'shaving_cream', 'mouse', 'bathroom_cabinet', 'dishwasher', 'coffee'] Task:Wash dishes by hand response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'blender', 'beer', 'microwave', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'food_orange', 'wall', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'sink'] Task:Wash dirty dishes response: { "thoughts": Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack., "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>'] }

Scene_Objects:['tea', 'freezer', 'walllamp', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'desk', 'table_cloth', 'ceilinglamp', 'plate', 'mousepad', 'couch', 'candle', 'tape', 'light_bulb', 'novel', 'coin', 'water', 'drinking_glass', 'wine', 'tray', 'coffee_pot', 'mouse', 'cd', 'conditioner', 'maindoor', 'napkin', 'home_office'] Task:Drink response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dog', 'freezer', 'dough', 'knifeblock', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'toaster', 'tvstand', 'faucet', 'couch', 'pasta', 'powersocket', 'oven', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'dresser', 'door', 'sink', 'home_office', 'light', 'bathroom_cabinet'] Task:Greet guests response: { "thoughts": Say hi, "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>'] }

Scene_Objects:['sheets', 'scissors', 'mop', 'toilet', 'blow_dryer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'toaster', 'tvstand', 'shower', 'mousepad', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'food_onion', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'bathroom_cabinet'] Task:Go to toilet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt'] Task:Switch on lamp response: { "thoughts": Press the button so the light comes on., "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] }

Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'mail', 'ceilinglamp', 'mat', 'iron', 'balanceball', 'faucet', 'food_orange', 'pillow', 'wall', 'pasta', 'box', 'cup', 'newspaper', 'food_food', 'check', 'toilet_paper', 'chessboard', 'maindoor', 'napkin', 'creditcard'] Task:Put groceries in Fridge response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'envelope', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'stereo', 'mousepad', 'towel', 'wall', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'tray', 'curtain', 'doorjamb', 'dresser', 'controller', 'door', 'food_steak', 'light', 'tooth_paste'] Task:Take shower response: { "thoughts": walk to bathroom , find shower , take a shower, "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>'] }

Scene_Objects:['filing_cabinet', 'food_salt', 'chair', 'blow_dryer', 'bathroom', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'shampoo', 'bookshelf', 'purse', 'keyboard', 'ceilinglamp', 'deck_of_cards', 'shower', 'window', 'couch', 'wall', 'powersocket', 'tape', 'photoframe', 'television', 'food_rice', 'after_shave', 'controller', 'conditioner', 'door', 'table', 'scrabble'] Task:Relax on sofa response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack'] Task:Read book response: { "thoughts": Obtain a book from the book shelf. Sit in the easy chair. Read the book. Mark the stopping point with a bookmark. Put the book back on the book shelf., "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>'] }

Scene_Objects:['sheets', 'filing_cabinet', 'beer', 'jelly', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'clothes_jacket', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'food_noodles', 'couch', 'wall', 'oven', 'basket_for_clothes', 'cup', 'television', 'curtain', 'conditioner', 'maindoor', 'table', 'vase'] Task:Watch TV response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'measuring_cup', 'toilet', 'chair', 'drawing', 'food_egg', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'button', 'shoe-shine_kit', 'shower', 'window', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'standingmirror', 'novel', 'coin', 'doorjamb', 'door', 'light', 'table', 'creditcard'] Task:Read response: { "thoughts": We pick out a book from the bookshelf and read it., "actions": ['[WALK] <novel>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>'] }

Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'food_salt', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'wall', 'nightstand', 'oven', 'toy', 'box', 'photoframe', 'keys', 'toothbrush_holder', 'tray', 'kitchen_counter', 'hair', 'door', 'sink', 'dishwasher'] Task:Cook some food response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['band-aids', 'trashcan', 'wallshelf', 'clothes_underwear', 'desk', 'keyboard', 'mail', 'computer', 'tvstand', 'shower', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'basket_for_clothes', 'keys', 'coffe_maker', 'television', 'food_donut', 'tray', 'rag', 'headset', 'clothes_scarf', 'bathtub', 'sink', 'light', 'dishwasher', 'soap', 'washing_machine'] Task:Wash clothes response: { "thoughts": Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine, "actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] }

Scene_Objects:['tablelamp', 'microwave', 'freezer', 'bathroom', 'cpuscreen', 'desk', 'tea_bag', 'alcohol', 'tvstand', 'oven', 'tape', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'toilet_paper', 'television', 'coffee_filter', 'wooden_spoon', 'mouse', 'cd', 'controller', 'maindoor', 'sink', 'home_office', 'light', 'dishwasher', 'soap', 'dirt', 'shoe_rack'] Task:Listen to music response:

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

Scene_Objects:['tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'couch', 'wall', 'nightstand', 'toy', 'photoframe', 'curtain', 'rag', 'doorjamb', 'mouse', 'dresser', 'door', 'light'] Task:Browse internet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'detergent', 'food_carrot', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'balanceball', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'tray', 'doorjamb', 'cards', 'mouse', 'shaving_cream', 'shoes', 'dresser', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'vase'] Task:Turn on light response: { "thoughts": switching on light in an area, "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] }

Scene_Objects:['glue', 'scissors', 'tablelamp', 'freezer', 'trashcan', 'drawing', 'floor', 'shampoo', 'folder', 'bookshelf', 'purse', 'computer', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'photoframe', 'television', 'curtain', 'food_onion', 'shaving_cream', 'mouse', 'pencil', 'hair', 'maindoor', 'clothes_scarf', 'home_office', 'colander'] Task:Go to sleep response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'envelope', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'television', 'curtain', 'hair', 'bathroom_cabinet', 'table'] Task:Pet cat response: { "thoughts": I would walk into the living room. Then sit on the couch and pet the cat., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['pot', 'toilet', 'jelly', 'ceilingfan', 'drawing', 'hanger', 'floor', 'stamp', 'desk', 'ceilinglamp', 'balanceball', 'faucet', 'window', 'couch', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'bed', 'photoframe', 'television', 'oven_mitts', 'food_rice', 'doorjamb', 'cards', 'shaving_cream', 'sink', 'table', 'light', 'shoe_rack'] Task:Relax on sofa response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'bedroom', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'stereo', 'closetdrawer', 'couch', 'broom', 'wall', 'wall_clock', 'photoframe', 'bed', 'television', 'mouse', 'kitchen_counter', 'comb', 'dresser', 'sink', 'spoon', 'clothes_skirt'] Task:Go to toilet response: { "thoughts": I walk into the bath room and go to the toilet, "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[SIT] <toilet>'] }

Scene_Objects:['pot', 'chair', 'ground_coffee', 'food_butter', 'toothbrush', 'knifeblock', 'drawing', 'phone', 'keyboard', 'bookshelf', 'table_cloth', 'mat', 'plate', 'electric_shaver', 'window', 'pillow', 'nightstand', 'oven', 'newspaper', 'clothes_gloves', 'photoframe', 'toilet_paper', 'water', 'centerpiece', 'towel_rack', 'kettle', 'pencil', 'clothes_scarf', 'tooth_paste', 'teeth'] Task:Wash teeth response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'blender', 'beer', 'microwave', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'food_orange', 'wall', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'sink'] Task:Wash dirty dishes response: { "thoughts": Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack., "actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>'] }

Scene_Objects:['food_bread', 'tablelamp', 'walllamp', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'mat', 'faucet', 'couch', 'pillow', 'wall', 'pasta', 'wall_clock', 'cup', 'photoframe', 'bed', 'television', 'water', 'wine', 'curtain', 'paper_towel', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response:

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

Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'dog', 'walllamp', 'ceilingfan', 'knifeblock', 'needle', 'bathroom_counter', 'floor', 'computer', 'shoe-shine_kit', 'dustpan', 'box', 'cup', 'bed', 'keys', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'shoes', 'comb', 'sink', 'bathroom_cabinet', 'board_game'] Task:Brush teeth response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'faucet', 'couch', 'dustpan', 'pillow', 'towel', 'wall', 'nightstand', 'oven', 'box', 'bed', 'keys', 'check', 'toilet_paper', 'television', 'kitchen_counter', 'dresser', 'instrument_guitar', 'soap', 'tooth_paste'] Task:Relax on sofa response: { "thoughts": Go to living room. Find sofa. Sit on sofa., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] }

Scene_Objects:['food_pizza', 'tablelamp', 'jelly', 'ceilingfan', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'computer', 'clothes_jacket', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'ceilinglamp', 'balanceball', 'stereo', 'brush', 'food_jam', 'clothes_hat', 'nightstand', 'pasta', 'powersocket', 'bench', 'bed', 'oven_mitts', 'tray', 'towel_rack', 'home_office'] Task:Listen to music response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'envelope', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table'] Task:Watch TV response: { "thoughts": Enter the living room, find TV remote, grab TV remote, switch on TV, find sofa, sit down on the sofa, watch TV, "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['sponge', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'food_cake', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'wall_clock', 'light_bulb', 'television', 'curtain', 'hair', 'food_steak', 'sink', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Watch TV response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light'] Task:Work response: { "thoughts": I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer., "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[SWITCHOFF] <computer>'] }

Scene_Objects:['freezer', 'trashcan', 'food_carrot', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'alcohol', 'button', 'ceilinglamp', 'plate', 'clothes_socks', 'couch', 'food_orange', 'wall', 'bench', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffee_filter', 'drinking_glass', 'water', 'towel_rack', 'dishrack', 'cupboard', 'clothes_dress', 'light', 'colander'] Task:Drink response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'food_bread', 'microwave', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'bedroom', 'tea_bag', 'tvstand', 'window', 'form', 'pillow', 'broom', 'bench', 'basket_for_clothes', 'newspaper', 'bed', 'check', 'coffe_maker', 'tray', 'door', 'home_office', 'light', 'bathroom_cabinet', 'tooth_paste', 'coffee'] Task:Get dressed response: { "thoughts": I get dressed in my bedroom in the mornings., "actions": ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>'] }

Scene_Objects:['pot', 'food_bread', 'microwave', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'faucet', 'towel', 'wall', 'bench', 'photoframe', 'light_bulb', 'lighter', 'pencil', 'chessboard', 'dresser', 'hair', 'cupboard', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'hands_both', 'shoe_rack'] Task:Wash hands response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['jelly', 'trashcan', 'cpuscreen', 'clothes_underwear', 'ceiling', 'folder', 'desk', 'computer', 'stovefan', 'shower', 'mousepad', 'candle', 'clothes_hat', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'video_game_controller', 'oven_mitts', 'curtain', 'pencil', 'kitchen_counter', 'dishrack', 'laundry_detergent', 'door', 'light', 'dishwasher', 'soap', 'tooth_paste', 'washing_machine'] Task:Wash clothes response: { "thoughts": Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on., "actions": ['[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] }

Scene_Objects:['filing_cabinet', 'chair', 'bathroom', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'purse', 'computer', 'shower', 'window', 'electric_shaver', 'mousepad', 'oil', 'couch', 'form', 'wall', 'food_food', 'television', 'rag', 'lighter', 'mouse', 'controller', 'sink'] Task:Pick up phone response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'drawing', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'bowl', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'food_food', 'coffe_maker', 'wooden_spoon', 'doorjamb', 'pencil', 'comb', 'door', 'light', 'soap', 'scrabble', 'creditcard'] Task:Put groceries in Fridge response: { "thoughts": 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, "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] }

Scene_Objects:['water_glass', 'chair', 'cat', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'ceilinglamp', 'shower', 'foundation', 'couch', 'food_orange', 'powersocket', 'bench', 'clothes_gloves', 'toilet_paper', 'razor', 'food_donut', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'pajamas', 'laundry_detergent', 'clothes_scarf', 'home_office', 'laser_pointer', 'creditcard'] Task:Drink response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'mousepad', 'dustpan', 'wall', 'nightstand', 'photoframe', 'wine', 'doorjamb', 'mouse', 'dresser', 'light', 'colander'] Task:Browse internet response: { "thoughts": Go find a computer, turn it on, click google, and browse the internet., "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] }

Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'detergent', 'trashcan', 'dough', 'clothes_underwear', 'folder', 'stamp', 'bookshelf', 'clothes_jacket', 'table_cloth', 'mousepad', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'nightstand', 'bench', 'oven', 'cutting_board', 'bed', 'food_food', 'check', 'doorjamb', 'console', 'cupboard', 'home_office', 'table'] Task:Pick up phone response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'trashcan', 'orchid', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'faucet', 'couch', 'clothes_pants', 'form', 'wall', 'cutting_board', 'photoframe', 'check', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response: { "thoughts": Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes, "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTBACK] <clothes_jacket> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] }

Scene_Objects:['fork', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'milk', 'floor', 'ceiling', 'shampoo', 'purse', 'ceilinglamp', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'tape', 'novel', 'food_food', 'food_donut', 'wooden_spoon', 'mouse', 'kitchen_counter', 'door', 'home_office', 'bathroom_cabinet', 'vase', 'soap', 'instrument_violin', 'creditcard'] Task:Put groceries in Fridge response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'food_pizza', 'pot', 'microwave', 'bathroom', 'bills', 'knifeblock', 'cpuscreen', 'drawing', 'longboard', 'floor', 'phone', 'folder', 'bedroom', 'keyboard', 'mail', 'food_bacon', 'piano_bench', 'button', 'table_cloth', 'shower', 'couch', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'water', 'tray', 'pencil', 'door'] 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:['filing_cabinet', 'food_ice_cream', 'crayon', 'bathroom', 'drawing', 'floor', 'phone', 'character', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'shower', 'window', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'check', 'food_food', 'television', 'dresser', 'sink', 'table', 'dishwasher', 'clothes_skirt', 'tooth_paste', 'dirt'] Task:Change TV channel response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'needle', 'kitchen_cabinet', 'desk', 'alcohol', 'mat', 'ceilinglamp', 'balanceball', 'window', 'couch', 'clothes_pants', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'oven', 'toilet_paper', 'mouthwash', 'water', 'ice', 'tray', 'rag', 'doorjamb', 'towel_rack', 'coffee_pot', 'pencil', 'door', 'dishwasher', 'vase'] Task:Drink response: { "thoughts": Get a glass of water to drink, "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>'] }

Scene_Objects:['tablelamp', 'scissors', 'chair', 'freezer', 'dog', 'trashcan', 'ceilingfan', 'drawing', 'bills', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'television', 'doorjamb', 'cards', 'mouse', 'light', 'table'] Task:Browse internet response:

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

Scene_Objects:['tablelamp', 'food_ice_cream', 'measuring_cup', 'freezer', 'ceilingfan', 'cpuscreen', 'longboard', 'ceiling', 'character', 'bedroom', 'toaster', 'stereo', 'balanceball', 'oil', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'nightstand', 'photoframe', 'coffe_maker', 'rag', 'doorjamb', 'towel_rack', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'laser_pointer', 'dirt'] Task:Pick up phone response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'chair', 'walllamp', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'knife', 'bathroom_counter', 'desk', 'keyboard', 'bookshelf', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'mousepad', 'pillow', 'dining_room', 'oven', 'photoframe', 'food_food', 'kitchen_counter', 'dresser', 'sink', 'home_office'] Task:Turn off light response: { "thoughts": Walk to the lamp. Find the switch. Click the switch off., "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[SWITCHOFF] <floor_lamp>'] }

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:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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_salt', 'jelly', 'walllamp', 'detergent', 'knife', 'drawing', 'hanger', 'floor', 'dvd_player', 'character', 'desk', 'bedroom', 'plate', 'dish_soap', 'oil', 'wall', 'powersocket', 'bed', 'light_bulb', 'coffe_maker', 'toilet_paper', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher'] Task:Wash dishes with dishwasher response: { "thoughts": Put dishes in the dishwasher and start the dishwasher., "actions": ['[RUN] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[WALK] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] }

Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'needle', 'cpuscreen', 'floor', 'character', 'keyboard', 'table_cloth', 'plate', 'faucet', 'window', 'oil', 'mousepad', 'pillow', 'wall', 'oven', 'food_cheese', 'bed', 'tray', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'light'] Task:Wash dishes by hand response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'ceilingfan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'food_cake', 'thread', 'faucet', 'towel', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'water', 'rag', 'lighter', 'cards', 'console', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'table', 'soap', 'laser_pointer', 'hands_both'] Task:Wash hands response: { "thoughts": Go into the bathroom and go over to the sink. Grab soap and turn on the water. Wet your hands and rub them together so that the soap lathers. Rub the soap all over your hands thoroughly. Rinse off the soap with water and turn off the sink. Dry your hands with a towel., "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] }

Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'ceilinglamp', 'mat', 'balanceball', 'electric_shaver', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'nightstand', 'photoframe', 'food_food', 'doorjamb', 'mouse', 'door', 'light'] Task:Browse internet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'water_glass', 'pot', 'glue', 'walllamp', 'trashcan', 'knifeblock', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'mat', 'faucet', 'microphone', 'wall', 'cup', 'bed', 'food_food', 'check', 'water', 'food_donut', 'curtain', 'kitchen_counter', 'chessboard', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'bathroom_cabinet', 'dirt'] Task:Drink response: { "thoughts": I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water., "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] }

Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'toilet', 'chair', 'detergent', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'novel', 'food_onion', 'doorjamb', 'mouse', 'napkin', 'light', 'clothes_skirt'] Task:Browse internet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'knife', 'wallshelf', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'box', 'photoframe', 'television', 'coffee_filter', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dresser'] Task:Change TV channel response: { "thoughts": Walk to livingroom, grab remote and change the channel on television., "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>'] }

Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'toothbrush_holder', 'doorjamb', 'mouse', 'light', 'vase'] Task:Browse internet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'microwave', 'toothbrush', 'drawing', 'orchid', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'pillow', 'wall', 'pasta', 'oven', 'coffe_maker', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'sauce_pan', 'cupboard'] Task:Cook some food response: { "thoughts": Cook some pasta on the stove, "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pasta>', '[GRAB] <pasta>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <sauce_pan>', '[POUR] <water> <sauce_pan>', '[FIND] <oven>', '[SWITCHON] <oven>', '[PUTBACK] <pasta> <sauce_pan>', '[FIND] <sauce_pan>', '[GRAB] <sauce_pan>', '[PUTBACK] <sauce_pan> <oven>'] }

Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'balanceball', 'mat', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'light', 'dishwasher'] Task:Work response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'crayon', 'toilet', 'chair', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'computer', 'tvstand', 'faucet', 'stereo', 'food_orange', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'home_office'] Task:Get dressed response: { "thoughts": I get dressed in my bedroom in the mornings., "actions": ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>'] }

Scene_Objects:['sponge', 'sheets', 'filing_cabinet', 'food_bread', 'toilet', 'ground_coffee', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'plate', 'iron', 'mousepad', 'wall', 'oven', 'photoframe', 'light_bulb', 'coffe_maker', 'centerpiece', 'mouse', 'dresser', 'maindoor'] Task:Go to toilet response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['pot', 'freezer', 'ceilingfan', 'dough', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'mop_bucket', 'ceilinglamp', 'microphone', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'curtain', 'shaving_cream', 'controller', 'door', 'maindoor', 'dirt'] Task:Put groceries in Fridge response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'sheets', 'filing_cabinet', 'food_salt', 'toilet', 'band-aids', 'walllamp', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'phone', 'computer', 'mop_bucket', 'stovefan', 'tvstand', 'deck_of_cards', 'closetdrawer', 'newspaper', 'coffe_maker', 'doorjamb', 'dresser', 'cupboard', 'door', 'food_steak', 'bag', 'sink', 'table', 'dishwasher', 'bathroom_cabinet'] Task:Put umbrella away response: { "thoughts": Place the umbrella in the umbrella bucket point first., "actions": ['[WALK] <home_office>', '[WALK] <mop_bucket>'] }

Scene_Objects:['filing_cabinet', 'juice', 'freezer', 'blow_dryer', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'bookmark', 'ceilinglamp', 'mat', 'window', 'couch', 'microphone', 'clothes_hat', 'pillow', 'wall', 'bench', 'cup', 'keys', 'television', 'towel_rack', 'cd', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'vase'] Task:Relax on sofa response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'faucet', 'plate', 'mousepad', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'tape', 'cup', 'doorjamb', 'sink', 'light', 'table'] Task:Pick up phone response: { "thoughts": walk over and pick up the phone, "actions": ['[WALK] <phone>', '[GRAB] <phone>'] }

Scene_Objects:['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:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'filing_cabinet', 'sheets', 'detergent', 'milk', 'hanger', 'phone', 'desk', 'clothes_jacket', 'plate', 'dish_soap', 'mousepad', 'couch', 'candle', 'pillow', 'bowl', 'basket_for_clothes', 'standingmirror', 'keys', 'food_food', 'check', 'razor', 'coffee_filter', 'mouse', 'kitchen_counter', 'controller', 'door', 'bathtub', 'dishwasher'] Task:Wash dishes with dishwasher response: { "thoughts": Put dishes in the dishwasher and start the dishwasher., "actions": ['[RUN] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[WALK] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] }

Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'button', 'mat', 'balanceball', 'window', 'candle', 'wall', 'powersocket', 'photoframe', 'novel', 'coffee_filter', 'ice', 'doorjamb', 'kettle', 'console', 'door', 'bathroom_cabinet', 'light', 'home_office', 'table', 'soap'] Task:Turn on light response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'laundry_detergent', 'door', 'table', 'light', 'soap'] Task:Watch TV response: { "thoughts": turn tv on, watch TV, "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['food_bread', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'tea_bag', 'envelope', 'clothes_jacket', 'toaster', 'balanceball', 'faucet', 'iron', 'bed', 'coffe_maker', 'wooden_spoon', 'cards', 'headset', 'dresser', 'napkin', 'spoon', 'vase', 'instrument_violin', 'laser_pointer', 'creditcard'] Task:Receive credit card response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'beer', 'detergent', 'food_butter', 'orchid', 'hanger', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'closetdrawer', 'broom', 'wall', 'nightstand', 'toy', 'newspaper', 'toilet_paper', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'shoes', 'chessboard', 'dresser', 'door', 'dishwasher', 'instrument_violin', 'laser_pointer'] Task:Put away shoes response: { "thoughts": Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door., "actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>'] }

Scene_Objects:['tea', 'jelly', 'dog', 'walllamp', 'bathroom_counter', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'window', 'oil', 'microphone', 'clothes_hat', 'nightstand', 'photoframe', 'bed', 'check', 'coffe_maker', 'toothbrush_holder', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'laundry_detergent', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap'] Task:Change TV channel response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['crayon', 'needle', 'clothes_underwear', 'phone', 'desk', 'stamp', 'clothes_jacket', 'stovefan', 'mat', 'tvstand', 'window', 'towel', 'pillow', 'cutting_board', 'basket_for_clothes', 'cup', 'bed', 'photoframe', 'newspaper', 'food_food', 'mouthwash', 'television', 'wine', 'kettle', 'dresser', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'washing_machine'] Task:Wash clothes response: { "thoughts": Walk to the kitchen and find the basket of clothes. Put the soap and clothes into the washing machine. Turn on the washing machine., "actions": ['[WALK] <dining_room>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <washing_machine>', '[TURNTO] <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[OPEN] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTBACK] <clothes_jacket> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] }

Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'food_ice_cream', 'freezer', 'walllamp', 'knife', 'bathroom_counter', 'floor', 'stamp', 'tea_bag', 'keyboard', 'food_cake', 'bookmark', 'toaster', 'plate', 'stereo', 'dish_soap', 'food_noodles', 'wall', 'oven', 'bench', 'coffe_maker', 'food_food', 'tray', 'food_onion', 'dishrack', 'conditioner', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'freezer', 'cat', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'oil', 'couch', 'clothes_hat', 'wall', 'basket_for_clothes', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'towel_rack', 'comb', 'dresser', 'maindoor', 'soap'] 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:['filing_cabinet', 'toilet', 'ceilingfan', 'food_egg', 'hanger', 'ceiling', 'dvd_player', 'character', 'thread', 'clothes_jacket', 'toaster', 'deck_of_cards', 'foundation', 'mousepad', 'oil', 'pillow', 'oven', 'toy', 'food_food', 'check', 'lighter', 'centerpiece', 'dishrack', 'coffee', 'hair', 'laundry_detergent', 'maindoor', 'sink', 'door', 'teeth'] Task:Turn on light response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'walllamp', 'knife', 'desk', 'bookshelf', 'button', 'clothes_jacket', 'stovefan', 'deck_of_cards', 'mousepad', 'closetdrawer', 'oil', 'towel', 'pillow', 'broom', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'television', 'wine', 'curtain', 'after_shave', 'cards', 'home_office', 'light', 'clothes_skirt', 'soap', 'washing_machine'] Task:Wash clothes response: { "thoughts": walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on, "actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] }

Scene_Objects:['sheets', 'microwave', 'chair', 'freezer', 'food_butter', 'drawing', 'food_egg', 'floor', 'ceiling', 'character', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'couch', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'novel', 'ice', 'curtain', 'doorjamb', 'kettle', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'light'] Task:Drink response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'alcohol', 'mat', 'electric_shaver', 'oil', 'wall', 'powersocket', 'box', 'food_cheese', 'photoframe', 'bed', 'food_food', 'coffe_maker', 'doorjamb', 'lighter', 'dishrack', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'coffee'] Task:Turn on light response: { "thoughts": push any ligth button to turn it on, for example in the living room, "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] }

Scene_Objects:['glue', 'pot', 'chair', 'band-aids', 'detergent', 'drawing', 'needle', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'novel', 'after_shave', 'doorjamb', 'centerpiece', 'headset', 'dresser', 'cupboard', 'door', 'light', 'scrabble'] Task:Turn on light response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'toilet', 'walllamp', 'food_carrot', 'knife', 'wallshelf', 'thread', 'envelope', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'couch', 'pillow', 'broom', 'wall', 'bench', 'powersocket', 'tape', 'shelf', 'basket_for_clothes', 'photoframe', 'bed', 'oven_mitts', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'shoes', 'table', 'shoe_rack'] Task:Listen to music response: { "thoughts": I walk to the living room. I find a radio there and switch it on to listen to music., "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] }

Scene_Objects:['scissors', 'microwave', 'toilet', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'food_egg', 'cpuscreen', 'clothes_underwear', 'tea_bag', 'keyboard', 'faucet', 'clothes_socks', 'food_noodles', 'dining_room', 'bench', 'cup', 'bed', 'check', 'toilet_paper', 'television', 'after_shave', 'console', 'comb', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'board_game', 'teeth'] Task:Pet cat response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Work response: { "thoughts": Go to the computer, sit in the chair, pull up computer screen get the mouse and keyboard load work software, "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PULL] <mouse>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <mouse>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] }

Scene_Objects:['pot', 'food_bread', 'ceilingfan', 'drawing', 'knife', 'longboard', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'foundation', 'clothes_socks', 'couch', 'dining_room', 'broom', 'wall', 'cup', 'coffee_table', 'television', 'toothbrush_holder', 'curtain', 'lighter', 'mouse', 'maindoor', 'table'] Task:Watch TV response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'dining_room', 'wall', 'tape', 'photoframe', 'television', 'tray', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'instrument_guitar', 'table', 'bathroom_cabinet'] Task:Watch TV response: { "thoughts": Walk to living room. Find remote control. Find television. Point remote at television. Press "on" button. Watch., "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['crayon', 'chair', 'ground_coffee', 'trashcan', 'dough', 'toothbrush', 'knifeblock', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'mop_bucket', 'toaster', 'stovefan', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'oven', 'bed', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'board_game', 'coffee'] Task:Pick up phone response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'bathroom', 'detergent', 'cpuscreen', 'ceiling', 'computer', 'toaster', 'brush', 'laptop', 'faucet', 'mousepad', 'clothes_pants', 'dirt', 'powersocket', 'oven', 'cup', 'bed', 'food_food', 'television', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'chessboard', 'laundry_detergent', 'sink', 'dishwasher', 'washing_machine'] Task:Wash clothes response: { "thoughts": Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine., "actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[PLUGIN] <washing_machine>'] }

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:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mail', 'table_cloth', 'shower', 'foundation', 'dustpan', 'microphone', 'wall', 'powersocket', 'food_food', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'clothes_skirt', 'scrabble', 'creditcard'] Task:Turn off light response: { "thoughts": Hit the switch., "actions": ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>'] }

Scene_Objects:['glue', 'pot', 'blow_dryer', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'stovefan', 'ceilinglamp', 'balanceball', 'stereo', 'window', 'shower', 'clothes_socks', 'couch', 'candle', 'broom', 'wall', 'wall_clock', 'bed', 'television', 'curtain', 'pencil', 'kitchen_counter', 'dresser', 'napkin', 'spoon', 'table', 'dirt', 'creditcard'] Task:Relax on sofa response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'scissors', 'food_ice_cream', 'chair', 'orchid', 'drawing', 'bills', 'knifeblock', 'floor', 'character', 'alcohol', 'mat', 'window', 'couch', 'microphone', 'pillow', 'dining_room', 'wall', 'pasta', 'clothes_gloves', 'check', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'table', 'dishwasher', 'colander', 'coffee'] Task:Set up table response: { "thoughts": walk to entrance hall. find a table. pull table. walk to living rook. push table., "actions": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[PULL] <table>', '[WALK] <home_office>', '[WALK] <table>', '[PUSH] <table>'] }

Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'mail', 'alcohol', 'toaster', 'ceilinglamp', 'balanceball', 'mousepad', 'food_orange', 'wall', 'nightstand', 'mouthwash', 'doorjamb', 'mouse', 'hairbrush', 'light'] Task:Write an email response:

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

Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'novel', 'check', 'television', 'curtain', 'conditioner', 'hairdryer', 'clothes_dress', 'table'] Task:Watch TV response:

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

Scene_Objects:['dog', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'faucet', 'clothes_socks', 'microphone', 'wall', 'bench', 'powersocket', 'photoframe', 'food_rice', 'food_onion', 'towel_rack', 'cd', 'hairbrush', 'controller', 'maindoor', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', 'vase', 'soap', 'instrument_violin', 'laser_pointer', 'hands_both'] Task:Wash hands response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'filing_cabinet', 'crayon', 'walllamp', 'bathroom', 'toothbrush', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'faucet', 'electric_shaver', 'dish_soap', 'broom', 'wall', 'oven', 'bench', 'photoframe', 'light_bulb', 'novel', 'coffe_maker', 'television', 'tray', 'towel_rack', 'kettle', 'dishrack', 'table', 'dishwasher', 'tooth_paste'] Task:Wash dishes with dishwasher response: { "thoughts": Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes, "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] }

Scene_Objects:['filing_cabinet', 'scissors', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'food_jam', 'wall', 'novel', 'television', 'curtain', 'doorjamb', 'comb', 'clothes_dress', 'sink', 'home_office', 'table'] Task:Change TV channel response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'microphone', 'form', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'television', 'curtain', 'vacuum_cleaner', 'dishrack', 'dresser', 'hairbrush', 'door', 'table', 'soap'] Task:Watch TV response: { "thoughts": I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote., "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] }

Scene_Objects:['sheets', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'mousepad', 'microphone', 'dining_room', 'nightstand', 'basket_for_clothes', 'bed', 'newspaper', 'coffe_maker', 'check', 'tray', 'curtain', 'doorjamb', 'mouse', 'headset', 'laundry_detergent', 'maindoor', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'folder', 'desk', 'bookshelf', 'keyboard', 'thread', 'computer', 'mail', 'bookmark', 'mousepad', 'wall', 'nightstand', 'photoframe', 'novel', 'toilet_paper', 'tray', 'towel_rack', 'mouse', 'door', 'light'] Task:Read book response: { "thoughts": Walk to the living room. Find a desk and grab a book. Walk to the chair, sit in the chair and read a book., "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] }

Scene_Objects:['filing_cabinet', 'food_ice_cream', 'food_carrot', 'longboard', 'ceiling', 'stamp', 'food_cake', 'stovefan', 'mat', 'oil', 'food_peanut_butter', 'dining_room', 'broom', 'pasta', 'basket_for_clothes', 'bed', 'coffe_maker', 'television', 'razor', 'tray', 'after_shave', 'mouse', 'laundry_detergent', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'dishwasher', 'laser_pointer', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['jelly', 'freezer', 'dog', 'chair', 'nail_polish', 'bathroom', 'orchid', 'bills', 'food_egg', 'hanger', 'character', 'bedroom', 'thread', 'toaster', 'faucet', 'mousepad', 'oil', 'nightstand', 'cup', 'photoframe', 'standingmirror', 'bed', 'video_game_controller', 'wine', 'doorjamb', 'maindoor', 'bathtub', 'vase', 'clothes_shirt', 'coffee'] Task:Read book response: { "thoughts": pick up the book open the book and read, "actions": ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>'] }

Scene_Objects:['food_bread', 'filing_cabinet', 'mop', 'toilet', 'dog', 'freezer', 'longboard', 'floor', 'ceiling', 'purse', 'ceilinglamp', 'balanceball', 'faucet', 'foundation', 'food_jam', 'wall', 'oven', 'cup', 'bed', 'novel', 'food_food', 'coffe_maker', 'coffee_filter', 'curtain', 'console', 'pencil', 'maindoor', 'table', 'light', 'dirt'] Task:Put groceries in Fridge response:

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

Scene_Objects:['freezer', 'detergent', 'dough', 'drawing', 'bills', 'clothes_underwear', 'floor', 'bedroom', 'keyboard', 'piano_bench', 'ceilinglamp', 'balanceball', 'picture', 'window', 'foundation', 'electric_shaver', 'couch', 'dustpan', 'food_kiwi', 'wall', 'keys', 'check', 'television', 'tray', 'rag', 'shoes', 'door', 'table', 'vase', 'coffee'] Task:Relax on sofa response:

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

Scene_Objects:['juice', 'bills', 'hanger', 'shampoo', 'phone', 'dvd_player', 'character', 'alcohol', 'mat', 'stereo', 'clothes_socks', 'mousepad', 'wall', 'pasta', 'powersocket', 'tape', 'bed', 'novel', 'food_food', 'tray', 'coffee_pot', 'pencil', 'dishrack', 'cupboard', 'clothes_scarf', 'bathroom_cabinet', 'light', 'home_office', 'vase', 'scrabble'] Task:Pick up phone response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'measuring_cup', 'toilet', 'chair', 'band-aids', 'freezer', 'walllamp', 'food_carrot', 'toothbrush', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'button', 'mat', 'tvstand', 'faucet', 'mousepad', 'food_kiwi', 'wall', 'light_bulb', 'coffe_maker', 'toothbrush_holder', 'rag', 'pencil', 'sink', 'bathroom_cabinet', 'soap', 'tooth_paste', 'teeth'] Task:Brush teeth response: { "thoughts": getting ready for bed, "actions": ['[WALK] <bathroom_counter>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <toothbrush> <bathroom_counter>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[GRAB] <toothbrush>', '[SCRUB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <toothbrush_holder>', '[PUTBACK] <toothbrush> <toothbrush_holder>'] }

Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'detergent', 'orchid', 'bathroom_counter', 'character', 'keyboard', 'remote_control', 'bookshelf', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'dustpan', 'nightstand', 'bench', 'tape', 'cup', 'bed', 'coffee_table', 'wooden_spoon', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'hair'] Task:Change TV channel response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'picture', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'light'] Task:Watch TV response: { "thoughts": Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program., "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>'] }

Scene_Objects:['pot', 'chair', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'computer', 'table_cloth', 'toaster', 'plate', 'faucet', 'dish_soap', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'food_food', 'television', 'wine', 'tray', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'dishwasher', 'vase'] Task:Wash dishes with dishwasher response:

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

Scene_Objects:['sheets', 'tablelamp', 'measuring_cup', 'dog', 'nail_polish', 'detergent', 'toothbrush', 'drawing', 'hanger', 'desk', 'computer', 'toaster', 'tvstand', 'iron', 'picture', 'window', 'shower', 'food_kiwi', 'bench', 'cup', 'food_cheese', 'photoframe', 'check', 'coffe_maker', 'television', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap'] Task:Read book response:

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

Scene_Objects:['food_ice_cream', 'beer', 'toilet', 'band-aids', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'desk', 'mail', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'stereo', 'iron', 'shower', 'pillow', 'nightstand', 'toy', 'bed', 'food_food', 'oven_mitts', 'coffee_filter', 'after_shave', 'curtain', 'lighter', 'cupboard', 'maindoor'] Task:Pet cat response:

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

Scene_Objects:['sheets', 'pot', 'tablelamp', 'freezer', 'walllamp', 'trashcan', 'food_butter', 'toothbrush', 'orchid', 'longboard', 'phone', 'keyboard', 'shower', 'stereo', 'oil', 'mousepad', 'clothes_pants', 'pillow', 'dining_room', 'nightstand', 'photoframe', 'newspaper', 'food_onion', 'mouse', 'shoes', 'cd', 'cupboard', 'controller', 'dishwasher', 'dirt'] Task:Turn on light response:

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

Scene_Objects:['tablelamp', 'microwave', 'bathroom', 'detergent', 'cat', 'drawing', 'floor', 'folder', 'keyboard', 'food_cake', 'table_cloth', 'ceilinglamp', 'deck_of_cards', 'window', 'couch', 'wall', 'wall_clock', 'powersocket', 'newspaper', 'television', 'pencil', 'maindoor', 'clothes_scarf', 'sink', 'home_office', 'table', 'tooth_paste', 'laser_pointer', 'teeth', 'creditcard'] Task:Pet cat response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'cloth_napkin', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'pencil', 'headset', 'dresser', 'door', 'sink'] Task:Clean response: { "thoughts": Use a cloth to wipe away any marks on the computer screen., "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <cloth_napkin>', '[GRAB] <cloth_napkin>', '[WIPE] <computer>'] }

Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'envelope', 'computer', 'mail', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'check', 'food_food', 'television', 'tray', 'doorjamb', 'mouse', 'chessboard', 'light'] Task:Browse internet response: