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:['chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'tape', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'sink', 'home_office', 'table', 'light'] Task:Work response: { "thoughts": Walk to home office. Sit on chair. Switch on computer. type in keyboard., "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] }

Scene_Objects:['pot', 'toilet', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'drawing', 'floor', 'ceiling', 'food_cake', 'stovefan', 'toaster', 'plate', 'mat', 'shower', 'food_kiwi', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'tray', 'food_onion', 'doorjamb', 'kitchen_counter', 'sauce_pan', 'cupboard', 'door', 'food_steak', 'spoon', 'light', '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:['filing_cabinet', 'toilet', 'walllamp', 'ground_coffee', 'trashcan', 'desk', 'bedroom', 'purse', 'mop_bucket', 'shower', 'picture', 'homework', 'mousepad', 'form', 'wall', 'oven', 'bed', 'keys', 'video_game_controller', 'wine', 'food_onion', 'after_shave', 'console', 'mouse', 'cd', 'comb', 'dresser', 'door', 'clothes_skirt', 'dirt'] Task:Pet cat response: { "thoughts": Find the cat; pet the cat by touching it, "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'floor', 'character', 'bookshelf', 'computer', 'toaster', 'mat', 'plate', 'window', 'food_noodles', 'food_orange', 'wall', 'oven', 'photoframe', 'keys', 'bed', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'clothes_dress', 'napkin', 'home_office', '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:['toilet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'iron', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'mouse', 'cupboard', 'door', 'clothes_scarf', 'bathroom_cabinet', 'table', 'instrument_guitar'] Task:Work response: { "thoughts": For doing homework walk to home office. Walk to computer. Switch on Computer. Sit in a chair and do homework in computer., "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>'] }

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:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'ceiling', 'bedroom', 'bookshelf', 'food_bacon', 'table_cloth', 'toaster', 'laptop', 'ceilinglamp', 'floor_lamp', 'mousepad', 'couch', 'clothes_pants', 'towel', 'dining_room', 'basket_for_clothes', 'check', 'pencil', 'chessboard', 'food_steak', 'napkin', 'spoon', 'table'] 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:['sponge', 'food_pizza', 'filing_cabinet', 'toilet', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'folder', 'keyboard', 'faucet', 'iron', 'mousepad', 'pillow', 'dining_room', 'tape', 'cutting_board', 'cup', 'food_food', 'video_game_controller', 'food_rice', 'food_donut', 'rag', 'kettle', 'mouse', 'kitchen_counter', 'controller', 'food_steak', 'sink', 'dishwasher'] 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:['filing_cabinet', 'food_salt', 'jelly', 'walllamp', 'trashcan', 'hanger', 'longboard', 'floor', 'desk', 'mail', 'toaster', 'plate', 'shower', 'balanceball', 'couch', 'wall', 'oven', 'box', 'cup', 'bed', 'coffe_maker', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'vase', 'laser_pointer'] Task:Wash dishes with dishwasher response: { "thoughts": Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on., "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] }

Scene_Objects:['food_salt', 'crayon', 'microwave', 'food_carrot', 'orchid', 'knifeblock', 'bills', 'floor', 'bedroom', 'stamp', 'envelope', 'clothes_jacket', 'bookmark', 'toaster', 'faucet', 'towel', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'video_game_controller', 'tray', 'lighter', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'soap', 'scrabble', '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:['pot', 'beer', 'microwave', 'jelly', 'freezer', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'purse', 'computer', 'iron', 'window', 'mousepad', 'oil', 'wall', 'powersocket', 'bed', 'keys', 'mouthwash', 'wine', 'doorjamb', 'mouse', 'cupboard', 'door', 'sink', 'light'] Task:Turn on light response: { "thoughts": walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light., "actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>'] }

Scene_Objects:['water_glass', 'filing_cabinet', 'food_bread', 'toilet', 'freezer', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'shampoo', 'bedroom', 'ceilinglamp', 'closetdrawer', 'form', 'towel', 'broom', 'nightstand', 'wall', 'keys', 'novel', 'coffe_maker', 'coin', 'water', 'curtain', 'headset', 'dishrack', 'hair', 'controller', 'sink', '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:['pot', 'food_salt', 'microwave', 'toilet', 'chair', 'blow_dryer', 'hanger', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'mail', 'shoe-shine_kit', 'mousepad', 'food_noodles', 'cutting_board', 'cup', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'comb', 'pajamas', 'clothes_dress', 'door', 'home_office', 'light', 'table'] Task:Pet cat response: { "thoughts": Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail, "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] }

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:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'laptop', 'shoe-shine_kit', 'balanceball', 'picture', 'ceilinglamp', 'mousepad', 'wall', 'nightstand', 'newspaper', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light'] Task:Work response: { "thoughts": I need to finish some work on my computer in my home office to meet a deadline for tomorrow., "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>', '[TYPE] <keyboard>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[LOOKAT] <computer>'] }

Scene_Objects:['sheets', 'water_glass', 'food_pizza', 'juice', 'toilet', 'chair', 'ground_coffee', 'nail_polish', 'food_butter', 'wallshelf', 'cpuscreen', 'kitchen_cabinet', 'character', 'purse', 'piano_bench', 'couch', 'novel', 'coffe_maker', 'razor', 'water', 'tray', 'after_shave', 'chessboard', 'laundry_detergent', 'food_steak', 'door', 'napkin', 'light', 'table', '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:['tablelamp', 'food_salt', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'mousepad', 'couch', 'food_kiwi', 'wall', 'bench', 'cup', 'check', 'television', 'curtain', 'napkin', 'table', 'soap', 'instrument_violin'] Task:Watch TV response: { "thoughts": I walk into the living room. I sit on the couch. I pick up the remote control. I push the power button. I push the guide button and look for my favorite show "The Middle." I click that channel and enjoy my show., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['filing_cabinet', 'detergent', 'floor', 'ceiling', 'character', 'bookshelf', 'toaster', 'mat', 'deck_of_cards', 'food_noodles', 'closetdrawer', 'mousepad', 'form', 'towel', 'wall', 'pasta', 'powersocket', 'light_bulb', 'novel', 'video_game_controller', 'television', 'tray', 'doorjamb', 'centerpiece', 'controller', 'door', 'instrument_guitar', 'light', 'dishwasher', 'bathroom_cabinet'] 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:['freezer', 'cat', 'drawing', 'knife', 'knifeblock', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'faucet', 'iron', 'window', 'mousepad', 'couch', 'form', 'dining_room', 'wall', 'oven', 'box', 'newspaper', 'bed', 'novel', 'toilet_paper', 'television', 'tray', 'sink', 'table'] Task:Pet cat response: { "thoughts": I walk to the living room. I locate the cat. I walk to the couch and sit down beside the cat. I pet the cat., "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <cat>'] }

Scene_Objects:['pot', 'water_glass', 'toilet', 'jelly', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'shower', 'food_kiwi', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'water', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'spoon', 'light', 'dishwasher'] 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', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'bowl', 'wall', 'powersocket', 'cup', 'novel', 'coffe_maker', 'food_donut', 'doorjamb', 'mouse', 'dresser', '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:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'bookshelf', 'computer', 'tvstand', 'shower', 'homework', 'clothes_pants', 'bowl', 'nightstand', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'toilet_paper', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet'] 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:['walllamp', 'cat', 'trashcan', 'drawing', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'mail', 'toaster', 'mat', 'tvstand', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'powersocket', 'television', 'food_donut', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'dirt'] Task:Pet cat response: { "thoughts": My cat looks like it wants attention, so I will go pet it on the couch., "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>'] }

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:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'blow_dryer', 'nail_polish', 'ground_coffee', 'milk', 'knife', 'wallshelf', 'hanger', 'character', 'desk', 'keyboard', 'stovefan', 'mat', 'plate', 'food_jam', 'nightstand', 'wall', 'toy', 'bed', 'coffe_maker', 'wine', 'rag', 'centerpiece', 'pencil', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Read book response: { "thoughts": Pick up the book, open to current page, read the words., "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] }

Scene_Objects:['pot', 'tablelamp', 'jelly', 'bathroom', 'detergent', 'dough', 'orchid', 'floor', 'bedroom', 'mat', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'tray', 'kitchen_counter', 'headset', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', '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:['food_salt', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'phone', 'character', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'wall_clock', 'bed', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'hairdryer', 'sink', 'home_office', 'table'] Task:Relax on sofa response: { "thoughts": Walk into the living room. Walk up to the sofa. Sit down on the sofa., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] }

Scene_Objects:['sheets', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'floor', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'cup', 'check', 'television', 'curtain', 'mouse', 'chessboard', 'shoes', 'comb', 'cupboard', 'hairdryer', 'door', 'home_office'] 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:['toilet', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'oil', 'couch', 'wall', 'cup', 'food_food', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'console', 'hairbrush', 'cupboard', 'food_steak', 'maindoor', 'door', 'table'] Task:Watch TV response: { "thoughts": Watch favorite shows, netflix, hulu, "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'walllamp', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'bookshelf', 'food_cake', 'plate', 'iron', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'cup', 'newspaper', 'novel', 'coffe_maker', 'food_food', 'check', 'coin', 'oven_mitts', 'food_rice', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', '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:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game'] Task:Brush teeth response: { "thoughts": EARLY MORNING AND BEFORE GOING TO BED, "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>'] }

Scene_Objects:['sheets', 'glue', 'sponge', 'microwave', 'toilet', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'bedroom', 'purse', 'mat', 'ceilinglamp', 'shower', 'picture', 'wall', 'powersocket', 'oven', 'toilet_paper', 'food_donut', 'tray', 'curtain', 'doorjamb', 'cupboard', 'door', 'hairdryer', 'spoon', 'light', 'dirt'] 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:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'ceilinglamp', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'novel', 'check', 'tray', 'doorjamb', 'towel_rack', 'console', 'pencil', 'light'] Task:Read book response: { "thoughts": Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook., "actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] }

Scene_Objects:['fork', 'pot', 'tea', 'microwave', 'walllamp', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'toaster', 'faucet', 'stereo', 'bowl', 'food_kiwi', 'wall', 'oven', 'bed', 'coffe_maker', 'food_food', 'drinking_glass', 'food_donut', 'tray', 'after_shave', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_skirt'] 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', 'blender', 'crayon', 'microwave', 'nail_polish', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'dining_room', 'wall', 'nightstand', 'oven', 'novel', 'television', 'curtain', 'dresser', 'pajamas', 'table', 'instrument_violin'] Task:Turn off TV response: { "thoughts": Walk over to tv and press power button, "actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>'] }

Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'ice', 'rag', 'doorjamb', 'mouse', 'controller', 'door', 'light', 'table', 'scrabble', 'dirt'] 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:['microwave', 'toilet', 'dog', 'toothbrush', 'bills', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'purse', 'faucet', 'balanceball', 'food_noodles', 'wall', 'bench', 'cup', 'photoframe', 'mouthwash', 'console', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { "thoughts": go to bathroom. walk to sink,turn on faucet, put hands in water. rub hands together. grab soap. rub soap in hands. put soap down. put hands under water. rubs hands together. turn off faucet, "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] }

Scene_Objects:['spectacles', 'crayon', 'microwave', 'toilet', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'shampoo', 'computer', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'light', 'instrument_violin'] 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:['tablelamp', 'chair', 'dog', 'trashcan', 'drawing', 'cpuscreen', 'character', 'keyboard', 'bookshelf', 'toaster', 'mat', 'tvstand', 'faucet', 'window', 'mousepad', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'wooden_spoon', 'kettle', 'shaving_cream', 'towel_rack', 'cupboard', 'conditioner', 'bathtub', 'dirt'] Task:Lock door response: { "thoughts": Turn the lock., "actions": ['[WALK] <bedroom>'] }

Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'orchid', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'picture', 'foundation', 'dish_soap', 'clothes_socks', 'pillow', 'powersocket', 'cutting_board', 'basket_for_clothes', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'sink', 'spoon', 'home_office'] 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:['sheets', 'filing_cabinet', 'tablelamp', 'bathroom', 'knifeblock', 'wallshelf', 'bathroom_counter', 'character', 'bedroom', 'tea_bag', 'keyboard', 'food_cake', 'toaster', 'ceilinglamp', 'shower', 'faucet', 'couch', 'food_jam', 'clothes_pants', 'bowl', 'dining_room', 'nightstand', 'oven', 'ice', 'lighter', 'mouse', 'conditioner', 'door', 'bathroom_cabinet', 'light'] Task:Pick up phone response: { "thoughts": Walk to the living room, Find Phone stand. Find Phone. Pickup the receiver to attend the call., "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] }

Scene_Objects:['tablelamp', 'measuring_cup', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'remote_control', 'bookshelf', 'computer', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'broom', 'nightstand', 'wall', 'television', 'curtain', 'doorjamb', 'pencil', 'dresser', 'pajamas', 'laundry_detergent', 'clothes_dress', 'bag', '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:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'table', 'light'] Task:Watch TV response: { "thoughts": I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch, "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUTOBJBACK] <remote_control>', '[WATCH] <television>'] }

Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'food_salt', 'chair', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'bathroom_counter', 'desk', 'bookshelf', 'thread', 'stovefan', 'laptop', 'faucet', 'window', 'clothes_socks', 'closetdrawer', 'powersocket', 'food_cheese', 'water', 'drinking_glass', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dishrack', 'sink', 'table', '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:['food_bread', 'food_pizza', 'tablelamp', 'microwave', 'floor', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'laptop', 'window', 'homework', 'oil', 'closetdrawer', 'couch', 'nightstand', 'wall', 'cup', 'bed', 'food_food', 'mouthwash', 'toothbrush_holder', 'oven_mitts', 'razor', 'food_donut', 'check', 'clothes_scarf', 'bathroom_cabinet'] Task:Go to sleep response: { "thoughts": Walk to bedroom. Walk to bed, lie in bed., "actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[LIE] <bed>'] }

Scene_Objects:['tea', 'toilet', 'chair', 'freezer', 'ground_coffee', 'drawing', 'floor', 'phone', 'alcohol', 'mail', 'piano_bench', 'mat', 'shower', 'stereo', 'homework', 'food_peanut_butter', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'bowl', 'powersocket', 'curtain', 'doorjamb', 'cd', 'laundry_detergent', 'door', 'sink', 'light', 'soap'] 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:['sheets', 'walllamp', 'drawing', 'orchid', 'bills', 'floor', 'desk', 'mat', 'tvstand', 'stereo', 'clothes_socks', 'closetdrawer', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'clothes_gloves', 'standingmirror', 'mouthwash', 'television', 'razor', 'towel_rack', 'kitchen_counter', 'clothes_dress', 'sink', 'soap', 'washing_machine'] Task:Wash clothes response: { "thoughts": put clothes and soap in the washing machine, turn it on, "actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[FIND] <soap>', '[GRAB] <soap>', '[OPEN] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] }

Scene_Objects:['dry_pasta', 'tablelamp', 'mop', 'chair', 'walllamp', 'food_butter', 'food_egg', 'cpuscreen', 'floor', 'ceiling', 'stamp', 'mail', 'stovefan', 'ceilinglamp', 'stereo', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'television', 'curtain', 'after_shave', 'mouse', 'hair', 'food_steak', 'sink', 'light', '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:['sheets', 'tablelamp', 'food_salt', 'toilet', 'bathroom_counter', 'floor', 'phone', 'desk', 'stovefan', 'toaster', 'plate', 'tvstand', 'picture', 'mat', 'mousepad', 'dining_room', 'food_kiwi', 'basket_for_clothes', 'cup', 'photoframe', 'bed', 'novel', 'keys', 'coin', 'food_rice', 'tray', 'pencil', 'kitchen_counter', 'door', 'table'] Task:Pet cat response: { "thoughts": I walk to the living room. I find the cat. I pet the cat., "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['tablelamp', 'scissors', 'microwave', 'walllamp', 'bathroom', 'orchid', 'drawing', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'toaster', 'tvstand', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'bed', 'keys', 'food_food', 'television', 'tray', 'curtain', 'kettle', 'dresser', '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:['pot', 'tablelamp', 'crayon', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'mail', 'food_bacon', 'clothes_jacket', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'food_jam', 'nightstand', 'powersocket', 'novel', 'food_food', 'centerpiece', 'diary', 'console', 'cupboard', 'bathroom_cabinet', 'table', 'light'] Task:Pick up phone response: { "thoughts": Pick up the ringing phone, "actions": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[POINTAT] <table>', '[FIND] <phone>', '[GRAB] <phone>', '[PUTOBJBACK] <phone>'] }

Scene_Objects:['chair', 'walllamp', 'nail_polish', 'orchid', 'bills', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'door', 'home_office', '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:['juice', 'bathroom', 'detergent', 'nail_polish', 'trashcan', 'food_butter', 'orchid', 'hanger', 'longboard', 'floor', 'bathroom_counter', 'remote_control', 'envelope', 'computer', 'window', 'electric_shaver', 'wall', 'cutting_board', 'bed', 'television', 'tray', 'curtain', 'after_shave', 'lighter', 'mouse', 'cupboard', 'clothes_dress', 'light', 'clothes_skirt', 'board_game'] Task:Watch TV response: { "thoughts": Watching tv with a remote is always fun; lay back, relax and enjoy;, "actions": ['[WALK] <bedroom>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <bed>', '[LIE] <bed>'] }

Scene_Objects:['pot', 'tea', 'microwave', 'band-aids', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'shampoo', 'stovefan', 'toaster', 'faucet', 'dining_room', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'coffe_maker', 'check', 'oven_mitts', 'water', 'tray', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher'] 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:['dry_pasta', 'tablelamp', 'crayon', 'band-aids', 'nail_polish', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'ceilinglamp', 'shoe-shine_kit', 'window', 'couch', 'food_kiwi', 'wall', 'bed', 'keys', 'check', 'television', 'oven_mitts', 'curtain', 'conditioner', 'maindoor', 'instrument_guitar', 'table', 'bathroom_cabinet'] Task:Pet cat response: { "thoughts": The cat is laying on the couch in the living room. I want to pet it, so I am going to walk to the living room, sit on the couch, and pet the cat., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['sheets', 'filing_cabinet', 'knifeblock', 'drawing', 'food_egg', 'desk', 'keyboard', 'food_cake', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'brush', 'window', 'foundation', 'deck_of_cards', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'light_bulb', 'clothes_gloves', 'check', 'mouthwash', 'curtain', 'dresser', 'clothes_dress', 'sink', 'creditcard'] 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:['toilet', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light'] Task:Go to toilet response: { "thoughts": walk to bathroom , run to toilet, "actions": ['[WALK] <bathroom>', '[RUN] <toilet>'] }

Scene_Objects:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', '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:['fork', 'tea', 'jelly', 'dog', 'chair', 'ground_coffee', 'bathroom', 'phone', 'bedroom', 'stovefan', 'mat', 'plate', 'faucet', 'shoe-shine_kit', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'newspaper', 'food_food', 'coffe_maker', 'tray', 'curtain', 'food_steak', 'door', 'bag', 'instrument_guitar', 'light', 'dishwasher'] Task:Set up table response: { "thoughts": Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room, "actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>'] }

Scene_Objects:['pot', 'chair', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', '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', 'filing_cabinet', 'beer', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'food_cake', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: { "thoughts": Walk to living room. Sit on sofa. Lie down on sofa., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>'] }

Scene_Objects:['sheets', 'bathroom', 'food_carrot', 'wallshelf', 'ceiling', 'dvd_player', 'character', 'bedroom', 'desk', 'keyboard', 'thread', 'stovefan', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'cup', 'bed', 'food_food', 'razor', 'toothbrush_holder', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'napkin', 'table', 'clothes_skirt'] 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:['sheets', 'filing_cabinet', 'juice', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'shower', 'faucet', 'window', 'mousepad', 'food_orange', 'wall', 'television', 'curtain', 'after_shave', 'mouse', 'dresser', 'door', 'napkin', 'table'] Task:Clean screen response: { "thoughts": Use a soft rag to wipe the screen until there are no marks on it., "actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>'] }

Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'wooden_spoon', 'curtain', 'diary', 'dresser', 'cupboard', 'clothes_dress', '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:['food_bread', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'wallshelf', 'floor', 'shampoo', 'character', 'computer', 'bookmark', 'toaster', 'plate', 'faucet', 'shoe-shine_kit', 'dish_soap', 'wall', 'toy', 'light_bulb', 'coffe_maker', 'rag', 'kitchen_counter', 'hairbrush', 'cupboard', 'dresser', 'controller', 'sink', 'home_office', 'table', 'dishwasher'] Task:Wash dishes by hand response: { "thoughts": Make some dish water, grab a dish rag, put dishes in dish water and wash., "actions": ['[RUN] <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[PUTBACK] <dish_soap> <plate>', '[RINSE] <dish_soap>', '[FIND] <plate>', '[WASH] <plate>'] }

Scene_Objects:['pot', 'microwave', 'walllamp', 'knifeblock', 'orchid', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'food_bacon', 'stovefan', 'toaster', 'plate', 'faucet', 'window', 'homework', 'closetdrawer', 'wall', 'oven', 'ice', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'sink', 'bathroom_cabinet', '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:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table'] 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:['pot', 'chair', 'walllamp', 'orchid', 'bills', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'comb', 'door', 'home_office', '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:['tablelamp', 'walllamp', 'detergent', 'orchid', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'tvstand', 'faucet', 'plate', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'bed', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'table'] Task:Watch TV response: { "thoughts": turn on the tv, "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>'] }

Scene_Objects:['sheets', 'juice', 'tea', 'toilet', 'freezer', 'walllamp', 'dough', 'drawing', 'food_egg', 'floor', 'dvd_player', 'character', 'alcohol', 'stovefan', 'mat', 'shower', 'closetdrawer', 'clothes_hat', 'food_jam', 'wall', 'powersocket', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'laundry_detergent', 'door', 'light', 'dishwasher', 'table'] 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', 'chair', 'ceilingfan', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'food_noodles', 'couch', 'wall', 'nightstand', 'food_food', 'television', 'curtain', 'cupboard', 'table', 'light', 'vase', 'dishwasher', 'dirt'] Task:Watch TV response: { "thoughts": Sit on the couch or the chair or the floor and watch cable, movies, or netflix., "actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['glue', 'pot', 'filing_cabinet', 'food_bread', 'toilet', 'jelly', 'freezer', 'food_butter', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'brush', 'mat', 'shower', 'mousepad', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'ice', 'doorjamb', 'hair', 'door', 'napkin', 'light', '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:['food_pizza', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'clothes_dress', 'door', 'conditioner', 'sink', 'light'] Task:Pet cat response: { "thoughts": My cat looks like it wants attention, so I will go pet it on the couch., "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['pot', 'food_bread', 'microwave', 'detergent', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'wall', 'cup', 'check', 'mouthwash', 'water', 'wine', 'after_shave', 'curtain', 'food_onion', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet'] 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:['food_bread', 'scissors', 'chair', 'bathroom', 'detergent', 'cat', 'ceilingfan', 'dough', 'knifeblock', 'hanger', 'floor', 'ceiling', 'character', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'microphone', 'wall', 'oven', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'dishwasher'] Task:Pet cat response: { "thoughts": Find a cat in the kitchen and touch it, "actions": ['[WALK] <dining_room>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['spectacles', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'desk', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'iron', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'television', 'doorjamb', 'mouse', 'door', 'home_office', 'light', 'table'] 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:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'tea_bag', 'computer', 'mat', 'tvstand', 'mousepad', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'oven', 'toy', 'cup', 'photoframe', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'dresser', 'laundry_detergent', 'sink', 'tooth_paste'] Task:Relax on sofa response: { "thoughts": Walk to the living room, find the sofa and sit in the sofa and find pillow. lie down in sofa., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <pillow>', '[LIE] <couch>'] }

Scene_Objects:['filing_cabinet', 'detergent', 'bills', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'mat', 'laptop', 'shower', 'faucet', 'ceilinglamp', 'mousepad', 'microphone', 'form', 'pillow', 'broom', 'wall', 'newspaper', 'after_shave', 'doorjamb', 'cd', 'comb', 'controller', 'door', 'bathroom_cabinet', 'light', 'table', '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:['beer', 'walllamp', 'ceilingfan', 'orchid', 'hanger', 'longboard', 'floor', 'ceiling', 'character', 'bedroom', 'folder', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'candle', 'wall', 'oven', 'bench', 'box', 'cup', 'clothes_gloves', 'coffe_maker', 'tray', 'console', 'maindoor', 'door', 'napkin', 'dishwasher'] Task:Wash dishes with dishwasher response: { "thoughts": I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on., "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] }

Scene_Objects:['scissors', 'dog', 'walllamp', 'clothes_underwear', 'bathroom_counter', 'phone', 'character', 'desk', 'tea_bag', 'envelope', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'food_kiwi', 'nightstand', 'cutting_board', 'photoframe', 'coffe_maker', 'television', 'tray', 'rag', 'doorjamb', 'diary', 'cupboard', 'hairdryer', 'home_office', 'light', 'table', '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:['fork', 'sheets', 'microwave', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'shower', 'oil', 'pillow', 'wall', 'novel', 'food_food', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'home_office', 'light'] Task:Put away groceries response: { "thoughts": Place groceries in refrigerator from shopping at the grocery store., "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] }

Scene_Objects:['filing_cabinet', 'tablelamp', 'crayon', 'microwave', 'freezer', 'detergent', 'drawing', 'knife', 'cpuscreen', 'purse', 'stovefan', 'brush', 'mat', 'faucet', 'food_noodles', 'couch', 'dustpan', 'nightstand', 'wall', 'powersocket', 'newspaper', 'novel', 'ice', 'kitchen_counter', 'hairbrush', 'cupboard', 'sink', 'table', 'clothes_skirt', 'board_game'] 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', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste'] Task:Hang up car keys response: { "thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall., "actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>'] }

Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'scissors', 'bathroom', 'drawing', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'laptop', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'lighter', 'mouse', 'comb', 'door', 'sink', 'light', 'dishwasher', '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:['water_glass', 'food_bread', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'phone', 'folder', 'bedroom', 'desk', 'keyboard', 'toaster', 'bench', 'tray', 'doorjamb', 'diary', 'console', 'mouse', 'towel_rack', 'cd', 'dresser', 'cupboard', 'controller', 'conditioner', 'table', 'vase'] Task:Drink response: { "thoughts": walk to kitchen, walk to table, grab water glass and drink water, "actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[PUTBACK] <water_glass> <table>'] }

Scene_Objects:['beer', 'microwave', 'dog', 'chair', 'cat', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'phone', 'character', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'oven', 'food_cheese', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'console', 'controller', 'clothes_scarf', 'light', 'colander', 'board_game', '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:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'walllamp', 'bathroom', 'knifeblock', 'food_egg', 'food_bacon', 'brush', 'mat', 'deck_of_cards', 'balanceball', 'tvstand', 'ceilinglamp', 'picture', 'couch', 'wall', 'tape', 'cup', 'toilet_paper', 'food_food', 'video_game_controller', 'water', 'cupboard', 'bathroom_cabinet', 'table', 'vase'] Task:Drink response: { "thoughts": I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass., "actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>'] }

Scene_Objects:['dry_pasta', 'spectacles', 'sheets', 'tablelamp', 'microwave', 'chair', 'jelly', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'picture', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'wall_clock', 'photoframe', 'food_food', 'coffe_maker', 'television', 'centerpiece', 'coffee_pot', 'pencil', 'shoes', 'bathroom_cabinet'] 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:['sheets', 'pot', 'food_pizza', 'dry_pasta', 'walllamp', 'trashcan', 'food_carrot', 'dough', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'wall', 'wall_clock', 'oven', 'food_cheese', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher'] Task:Keep an eye on stove as something is cooking response: { "thoughts": Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done, "actions": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <pot>', '[TURNTO] <pot>', '[LOOKAT] <pot>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[SWITCHOFF] <oven>'] }

Scene_Objects:['pot', 'food_salt', 'toilet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'bowl', 'wall', 'television', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'light', 'table', 'board_game'] 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:['fork', 'tablelamp', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'brush', 'mousepad', 'wall', 'nightstand', 'bed', 'photoframe', 'check', 'food_food', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'door', 'table', 'light', 'shoe_rack'] Task:Listen to music response: { "thoughts": I'll walk to my bedroom, where I have my computer. I'll walk to my computer and sit down in front of it. I'll put on my headphones and unlock my computer. I'll then navigate to music stored locally or streamed through the web., "actions": ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] }

Scene_Objects:['pot', 'microwave', 'freezer', 'detergent', 'orchid', 'knifeblock', 'knife', 'hanger', 'floor', 'character', 'bedroom', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'electric_shaver', 'couch', 'bowl', 'wall', 'box', 'food_cheese', 'coffe_maker', 'food_food', 'razor', 'shaving_cream', 'kitchen_counter', 'cupboard', 'sink', 'table', '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:['filing_cabinet', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table'] Task:Watch TV response: { "thoughts": Watching TV, "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['measuring_cup', 'detergent', 'orchid', 'clothes_underwear', 'floor', 'character', 'button', 'stovefan', 'ceilinglamp', 'toaster', 'homework', 'mousepad', 'couch', 'dustpan', 'microphone', 'form', 'towel', 'powersocket', 'basket_for_clothes', 'bed', 'light_bulb', 'oven_mitts', 'tray', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'colander', '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:['food_salt', 'beer', 'microwave', 'chair', 'drawing', 'hanger', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'bookmark', 'laptop', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'photoframe', 'newspaper', 'razor', 'tray', 'kitchen_counter', 'vacuum_cleaner', 'clothes_dress', 'door', 'bathroom_cabinet', 'tooth_paste'] Task:Write an email response: { "thoughts": I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email., "actions": ['[WALK] <bathroom>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] }

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

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'ground_coffee', 'bathroom', 'shampoo', 'character', 'bedroom', 'bookshelf', 'keyboard', 'envelope', 'bookmark', 'shower', 'iron', 'foundation', 'mousepad', 'closetdrawer', 'couch', 'wall', 'oven', 'basket_for_clothes', 'cup', 'bed', 'food_food', 'curtain', 'towel_rack', 'cupboard', 'door', 'food_steak', 'bathroom_cabinet', 'dishwasher', 'dirt'] Task:Brush teeth response: { "thoughts": go to the bathroom and brush your teeth, "actions": ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>'] }

Scene_Objects:['food_bread', 'tablelamp', 'chair', 'walllamp', 'floor', 'ceiling', 'bookshelf', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'check', 'television', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'shoes', 'dresser', 'pajamas', 'napkin', 'home_office', 'bathroom_cabinet', 'board_game'] 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', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'mouse', 'door', 'creditcard'] Task:Play on laptop response: { "thoughts": Sit down on the couch. Place laptop on lap. Open laptop. Turn on laptop. Choose selected program. Play selected program. Close game. Close laptop., "actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>', '[PUTOBJBACK] <laptop>'] }

Scene_Objects:['glue', 'sponge', 'pot', 'filing_cabinet', 'dog', 'knife', 'wallshelf', 'hanger', 'ceiling', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'shower', 'closetdrawer', 'pillow', 'box', 'novel', 'food_onion', 'shaving_cream', 'pencil', 'chessboard', 'comb', 'dresser', 'clothes_scarf', 'dishwasher', 'board_game'] 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:['chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'mousepad', 'couch', 'broom', 'wall', 'bed', 'check', 'toilet_paper', 'television', 'ice', 'kettle', 'mouse', 'door', 'sink', 'home_office', 'table'] Task:Browse internet response: { "thoughts": I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser., "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] }

Scene_Objects:['pot', 'toilet', 'walllamp', 'nail_polish', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'remote_control', 'button', 'bookmark', 'toaster', 'mat', 'faucet', 'food_jam', 'nightstand', 'tape', 'coffee_table', 'novel', 'check', 'mouse', 'pencil', 'chessboard', 'dresser', 'door', 'food_steak', 'laser_pointer'] 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:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'wall', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'mouse', 'cupboard', 'door', 'bathroom_cabinet', 'table'] Task:Browse internet response: { "thoughts": Turn on computer, pull up browser, browse the internet, "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] }

Scene_Objects:['sheets', 'microwave', 'detergent', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'mail', 'toaster', 'stovefan', 'faucet', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'coin', 'drinking_glass', 'water', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'sink', 'dishwasher', 'coffee'] 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', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher'] Task:Make coffee response: { "thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., "actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] }

Scene_Objects:['sponge', 'scissors', 'microwave', 'bathroom', 'drawing', 'knifeblock', 'floor', 'bedroom', 'desk', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'closetdrawer', 'wall', 'powersocket', 'newspaper', 'photoframe', 'bed', 'check', 'food_rice', 'ice', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'board_game'] Task:Wash dishes by hand response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'desk', 'bookshelf', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'shower', 'electric_shaver', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'bed', 'television', 'oven_mitts', 'curtain', 'cupboard', 'bathtub', 'home_office', 'table', 'bathroom_cabinet', 'light'] Task:Read magazine response: { "thoughts": Please sit on the couch and read a magazine, "actions": ['[WALK] <home_office>', '[WALK] <newspaper>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <newspaper>', '[LOOKAT] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>'] }

Scene_Objects:['fork', 'pot', 'blender', 'crayon', 'microwave', 'cat', 'drawing', 'orchid', 'needle', 'phone', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'food_jam', 'dining_room', 'powersocket', 'bed', 'photoframe', 'coffe_maker', 'television', 'diary', 'shoes', 'comb', 'controller', 'food_steak', 'instrument_violin', 'sink', 'dishwasher', 'board_game'] 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:['spectacles', 'food_salt', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'nightstand', 'powersocket', 'toy', 'bed', 'coffe_maker', 'television', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'hair', 'light', 'table'] 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:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink', 'light', 'table', 'creditcard'] 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', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'deck_of_cards', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'box', 'cup', 'toilet_paper', 'rag', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'bathtub', 'table', 'home_office'] Task:Drink response: { "thoughts": I walk the kitchen and walk up to the kitchen cabinet. I open the cabinet and take out a cup. I walk to sink and I turn the faucet on using the cold water handle. I put my cup under the running water until it is full. I turn off the cold water handle and bring the cup to my mouth and take a drink., "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[WALK] <sink>', '[FIND] <faucet>', '[PUSH] <faucet>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>'] }

Scene_Objects:['pot', 'tablelamp', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'stovefan', 'mat', 'toaster', 'shower', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'food_food', 'food_donut', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', '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:['glue', 'food_bread', 'chair', 'freezer', 'band-aids', 'walllamp', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'button', 'clothes_jacket', 'toaster', 'ceilinglamp', 'microphone', 'wall', 'oven', 'powersocket', 'bed', 'food_food', 'coffe_maker', 'oven_mitts', 'ice', 'tray', 'curtain', 'pencil', 'clothes_dress', 'dishwasher'] Task:Make toast response: { "thoughts": Place slices of bread in a toaster ,wait for the bread to pop up .Set aside., "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <toaster>'] }

Scene_Objects:['glue', 'juice', 'toilet', 'freezer', 'knifeblock', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mat', 'shower', 'dining_room', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'newspaper', 'food_food', 'curtain', 'doorjamb', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'instrument_guitar'] 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', '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: { "thoughts": walk to home office ,find computer ,switch on computer and work, "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] }

Scene_Objects:['sheets', 'pot', 'mop', 'toilet', 'chair', 'freezer', 'cpuscreen', 'food_egg', 'floor', 'table_cloth', 'toaster', 'mat', 'plate', 'ceilinglamp', 'dish_soap', 'couch', 'food_peanut_butter', 'dustpan', 'bowl', 'wall', 'photoframe', 'coffe_maker', 'food_food', 'television', 'tray', 'kitchen_counter', 'cupboard', 'light', 'dishwasher', 'table'] 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', 'scissors', 'tablelamp', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'tvstand', 'mousepad', 'form', 'pillow', 'wall', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'door', 'light'] Task:Pick up phone response: { "thoughts": Enter office. Go to desk. Pick up phone., "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <phone>', '[GRAB] <phone>'] }

Scene_Objects:['food_bread', 'food_pizza', 'tablelamp', 'microwave', 'floor', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'laptop', 'window', 'homework', 'oil', 'closetdrawer', 'couch', 'nightstand', 'wall', 'cup', 'bed', 'food_food', 'mouthwash', 'toothbrush_holder', 'oven_mitts', 'razor', 'food_donut', 'check', 'clothes_scarf', 'bathroom_cabinet'] 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:['sheets', 'tablelamp', 'bathroom', 'drawing', 'floor', 'character', 'bedroom', 'stamp', 'computer', 'mat', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'closetdrawer', 'clothes_hat', 'pillow', 'dining_room', 'broom', 'wall', 'bed', 'doorjamb', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'home_office', 'board_game', 'dirt'] Task:Turn on light response: { "thoughts": walk to living room ,find electrical outlet , switch on eletrical outlet, "actions": ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[SWITCHON] <electrical_outlet>'] }

Scene_Objects:['pot', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'stovefan', 'plate', 'shower', 'picture', 'faucet', 'dish_soap', 'pillow', 'wall', 'powersocket', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'food_food', 'television', 'lighter', 'centerpiece', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', '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', 'food_pizza', 'tablelamp', 'chair', 'detergent', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'shower', 'mousepad', 'dustpan', 'dining_room', 'wall', 'powersocket', 'oven', 'check', 'television', 'doorjamb', 'hairbrush', 'controller', 'sink', 'home_office', 'light'] Task:Turn on light response: { "thoughts": Walk to living room. Find light switch. Switch on light switch., "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] }

Scene_Objects:['tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'controller', 'door', 'light', 'table'] Task:Work response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'phone', 'piano_bench', 'toaster', 'mat', 'faucet', 'shower', 'window', 'dining_room', 'wall', 'bench', 'hands_both', 'bed', 'television', 'oven_mitts', 'water', 'curtain', 'paper_towel', 'hairdryer', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'teeth'] Task:Wash hands response: { "thoughts": I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands., "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <water>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>'] }

Scene_Objects:['pot', 'measuring_cup', 'toilet', 'ground_coffee', 'knife', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'button', 'ceilinglamp', 'stereo', 'faucet', 'oil', 'pillow', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'coffee_filter', 'coin', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher', 'table', 'home_office'] 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:['tablelamp', 'beer', 'crayon', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'food_cake', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'television', 'curtain', 'pencil', 'kitchen_counter', 'door'] Task:Relax on sofa response: { "thoughts": I walk to the sofa, and lie down on the sofa., "actions": ['[WALK] <couch>', '[LIE] <couch>'] }

Scene_Objects:['dry_pasta', 'microwave', 'ground_coffee', 'knifeblock', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'tea_bag', 'table_cloth', 'toaster', 'shoe-shine_kit', 'faucet', 'shower', 'window', 'homework', 'wall', 'basket_for_clothes', 'coffe_maker', 'water', 'drinking_glass', 'curtain', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'comb', 'cupboard', 'sink', 'light', 'clothes_skirt'] 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', 'food_pizza', 'mop', 'walllamp', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'stovefan', 'faucet', 'window', 'pillow', 'bowl', 'wall', 'wall_clock', 'oven', 'cup', 'photoframe', 'food_food', 'toilet_paper', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'table', 'tooth_paste'] Task:Cook some food response: { "thoughts": I switch on the stove and cook my groceries there., "actions": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[SWITCHON] <oven>', '[FIND] <bowl>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <oven>', '[FIND] <food_food>', '[SWITCHOFF] <oven>'] }

Scene_Objects:['tea', 'microwave', 'band-aids', 'bathroom', 'detergent', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'tvstand', 'stereo', 'food_noodles', 'mousepad', 'food_jam', 'bowl', 'nightstand', 'wall', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'doorjamb', 'table'] 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:['filing_cabinet', 'food_ice_cream', 'toilet', 'chair', 'freezer', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bookshelf', 'mat', 'window', 'couch', 'dustpan', 'pillow', 'towel', 'wall', 'bench', 'food_food', 'television', 'coin', 'tray', 'curtain', 'doorjamb', 'bathtub', 'spoon', 'table', 'soap'] Task:Listen to music response: { "thoughts": walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music, "actions": ['[WALK] <home_office>', '[WALK] <dvd_player>', '[FIND] <dvd_player>', '[TURNTO] <dvd_player>', '[LOOKAT] <dvd_player>', '[SWITCHON] <dvd_player>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>'] }

Scene_Objects:['blender', 'microwave', 'toilet', 'toothbrush', 'bills', 'orchid', 'character', 'bedroom', 'stamp', 'stovefan', 'laptop', 'ceilinglamp', 'shower', 'mat', 'faucet', 'towel', 'pillow', 'dining_room', 'oven', 'coffe_maker', 'television', 'toothbrush_holder', 'comb', 'cupboard', 'door', 'sink', 'table', 'soap', 'tooth_paste', 'teeth'] 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:['juice', 'food_ice_cream', 'blow_dryer', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shoe-shine_kit', 'couch', 'food_orange', 'wall', 'tape', 'television', 'curtain', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'table'] Task:Relax on sofa response: { "thoughts": For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <conditioner>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[LIE] <couch>'] }

Scene_Objects:['spectacles', 'chair', 'bathroom', 'food_carrot', 'knifeblock', 'floor', 'phone', 'bedroom', 'envelope', 'mail', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'tvstand', 'shower', 'window', 'candle', 'microphone', 'pillow', 'basket_for_clothes', 'toilet_paper', 'check', 'rag', 'chessboard', 'laundry_detergent', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'washing_machine', 'coffee'] 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:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table'] Task:Watch TV response: { "thoughts": I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>'] }

Scene_Objects:['scissors', 'chair', 'detergent', 'food_carrot', 'dough', 'drawing', 'character', 'bookshelf', 'keyboard', 'mail', 'bookmark', 'stovefan', 'iron', 'window', 'pillow', 'toy', 'cup', 'photoframe', 'food_food', 'check', 'television', 'toothbrush_holder', 'wooden_spoon', 'curtain', 'chessboard', 'hairbrush', 'dresser', 'sink', 'table', '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:['toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'dresser', 'hairbrush', 'clothes_dress', 'door', 'sink', 'spoon', 'table', 'light'] Task:Change TV channel response: { "thoughts": I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] }

Scene_Objects:['pot', 'filing_cabinet', 'chair', 'freezer', 'detergent', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'desk', 'bookshelf', 'food_cake', 'keyboard', 'mail', 'mop_bucket', 'mat', 'faucet', 'window', 'food_noodles', 'mousepad', 'couch', 'cutting_board', 'food_food', 'shoes', 'dresser', 'sink', 'light', '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:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game'] Task:vacuum carpet response: { "thoughts": I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet., "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>'] }

Scene_Objects:['tablelamp', 'food_salt', 'chair', 'walllamp', 'bathroom', 'drawing', 'knifeblock', 'floor', 'ceiling', 'thread', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'closetdrawer', 'couch', 'clothes_hat', 'form', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'after_shave', 'rag', 'diary', 'headset', 'sink', 'dishwasher', '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:['sheets', 'sponge', 'crayon', 'microwave', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'floor', 'bookshelf', 'button', 'stovefan', 'mat', 'stereo', 'mousepad', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'bed', 'photoframe', 'light_bulb', 'food_food', 'television', 'kitchen_counter', 'dresser', 'door', 'sink', 'clothes_skirt', 'scrabble'] Task:Breakfast response: { "thoughts": I have breakfast in bed, watching tv., "actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[GRAB] <food_food>', '[WALK] <bedroom>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <bed>', '[LIE] <bed>', '[TURNTO] <television>', '[WATCH] <television>', '[EAT] <food_food>'] }

Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'freezer', 'ground_coffee', 'bathroom', 'walllamp', 'detergent', 'food_butter', 'floor', 'ceiling', 'computer', 'food_bacon', 'bookmark', 'toaster', 'shoe-shine_kit', 'faucet', 'stereo', 'window', 'wall', 'coffe_maker', 'coffee_filter', 'water', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'instrument_guitar', 'table', 'dishwasher'] 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:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt'] Task:Take shower response: { "thoughts": go to a bathroom, open the shower, let water wash your body, "actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>'] }

Scene_Objects:['fork', 'scissors', 'chair', 'drawing', 'wallshelf', 'floor', 'bookshelf', 'envelope', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'shower', 'picture', 'oil', 'closetdrawer', 'microphone', 'food_cheese', 'newspaper', 'bed', 'food_food', 'wine', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light'] Task:Set up table 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', 'freezer', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'microphone', 'pillow', 'wall', 'wall_clock', 'nightstand', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'home_office', 'table', 'soap'] Task:Relax on sofa response: { "thoughts": go to the living room and sit on the couch, ease into the sofa and relax., "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>'] }

Scene_Objects:['glue', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'bathroom', 'wallshelf', 'phone', 'bookshelf', 'button', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'dining_room', 'nightstand', 'photoframe', 'coffe_maker', 'ice', 'lighter', 'mouse', 'pajamas', 'cupboard', 'door', 'sink', 'spoon', 'clothes_shirt', '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', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'window', 'deck_of_cards', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'food_kiwi', 'nightstand', 'wall', 'cup', 'coffe_maker', 'television', 'food_rice', 'curtain', 'dresser', 'napkin', 'table', 'light'] 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:['glue', 'dry_pasta', 'crayon', 'band-aids', 'detergent', 'drawing', 'clothes_underwear', 'table_cloth', 'stovefan', 'laptop', 'toaster', 'faucet', 'ceilinglamp', 'closetdrawer', 'wall', 'nightstand', 'oven', 'keys', 'food_food', 'tray', 'coffee_pot', 'pencil', 'headset', 'door', 'hairdryer', 'sink', 'table', 'dishwasher', 'clothes_shirt', '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:['pot', 'food_pizza', 'tablelamp', 'beer', 'tea', 'freezer', 'walllamp', 'nail_polish', 'bathroom', 'needle', 'cpuscreen', 'keyboard', 'mail', 'computer', 'stovefan', 'ceilinglamp', 'iron', 'clothes_pants', 'food_orange', 'pillow', 'dining_room', 'bench', 'bed', 'coffe_maker', 'television', 'doorjamb', 'pencil', 'maindoor', 'napkin', 'instrument_violin'] Task:Pick up phone response: { "thoughts": I walk to the home office, find where the phone is and lift the reciever., "actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] }

Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'bathroom', 'knifeblock', 'wallshelf', 'bathroom_counter', 'character', 'bedroom', 'tea_bag', 'keyboard', 'food_cake', 'toaster', 'ceilinglamp', 'shower', 'faucet', 'couch', 'food_jam', 'clothes_pants', 'bowl', 'dining_room', 'nightstand', 'oven', 'ice', 'lighter', 'mouse', 'conditioner', 'door', 'bathroom_cabinet', 'light'] 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', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'toaster', 'shower', 'food_noodles', 'oil', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher'] Task:Cook some food response: { "thoughts": I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food., "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>'] }

Scene_Objects:['beer', 'toilet', 'bathroom', 'detergent', 'needle', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'shampoo', 'ceiling', 'character', 'desk', 'bedroom', 'toaster', 'tvstand', 'window', 'clothes_socks', 'food_jam', 'pillow', 'towel', 'dining_room', 'cup', 'bed', 'food_food', 'coffe_maker', 'toilet_paper', 'television', 'tray', 'doorjamb', '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:['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:['food_salt', 'beer', 'microwave', 'chair', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'brush', 'plate', 'faucet', 'stereo', 'ceilinglamp', 'tvstand', 'dish_soap', 'wall', 'food_food', 'video_game_controller', 'toothbrush_holder', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'cupboard', 'sink', 'light', 'table'] 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:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'toaster', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'cup', 'photoframe', 'coffee_table', 'novel', 'television', 'doorjamb', 'shoes', 'comb', 'dresser', 'instrument_violin'] Task:Watch TV response: { "thoughts": I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch, "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[WATCH] <television>'] }

Scene_Objects:['tablelamp', 'walllamp', 'detergent', 'orchid', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'tvstand', 'faucet', 'plate', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'bed', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', '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:['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:['tablelamp', 'crayon', 'bathroom', 'detergent', 'dough', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'shower', 'laptop', 'dining_room', 'wall', 'cup', 'newspaper', 'food_food', 'toothbrush_holder', 'doorjamb', 'diary', 'kitchen_counter', 'door', 'sink', 'light', 'clothes_skirt', '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:['glue', 'food_bread', 'filing_cabinet', 'bathroom', 'ceiling', 'phone', 'keyboard', 'purse', 'bookshelf', 'laptop', 'ceilinglamp', 'faucet', 'nightstand', 'bench', 'photoframe', 'bed', 'clothes_gloves', 'food_food', 'coffe_maker', 'television', 'toothbrush_holder', 'curtain', 'shaving_cream', 'pencil', 'dresser', 'conditioner', 'door', 'spoon', 'bathroom_cabinet', 'table'] Task:Shut front door response: { "thoughts": Close the storm door. Lock the storm door., "actions": ['[WALK] <home_office>'] }

Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'chair', 'dog', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'pasta', 'light_bulb', 'clothes_gloves', 'television', 'curtain', 'doorjamb', 'conditioner', 'door', 'light'] 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:['toilet', 'chair', 'freezer', 'cat', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'iron', 'balanceball', 'mousepad', 'dustpan', 'pillow', 'broom', 'wall', 'oven', 'coffee_table', 'novel', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'mouse', 'pencil', 'light', 'board_game'] Task:Read book response: { "thoughts": I walk to the living room and pick up a book from the coffee table. I find my favorite chair. I sit in the armchair and open the book. I read., "actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[WALK] <coffee_table>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] }

Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'food_butter', 'knifeblock', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'mop_bucket', 'stovefan', 'ceilinglamp', 'faucet', 'stereo', 'window', 'closetdrawer', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'oven', 'food_food', 'television', 'chessboard', 'sink', 'dishwasher', 'laser_pointer'] 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:['pot', 'chair', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'oven_mitts', 'wooden_spoon', 'doorjamb', 'mouse', 'pajamas', 'door', 'light', 'table'] Task:Write an email response: { "thoughts": Compose an email in the home office., "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] }

Scene_Objects:['scissors', 'microwave', 'dog', 'freezer', 'detergent', 'dough', 'knifeblock', 'bills', 'floor', 'tea_bag', 'thread', 'toaster', 'plate', 'faucet', 'dish_soap', 'wall', 'cutting_board', 'tape', 'food_cheese', 'bed', 'newspaper', 'coffe_maker', 'lighter', 'shaving_cream', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'sink', '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:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'chair', 'walllamp', 'cpuscreen', 'hanger', 'phone', 'computer', 'stereo', 'faucet', 'window', 'couch', 'dining_room', 'wall_clock', 'bench', 'pasta', 'coffe_maker', 'food_food', 'doorjamb', 'mouse', 'pajamas', 'controller', 'sink', 'napkin', 'light', 'table', 'dishwasher'] Task:Walk to room response: { "thoughts": Leave the living room and enter the hall, "actions": ['[WALK] <home_office>', '[WALK] <home_office>'] }

Scene_Objects:['sponge', 'water_glass', 'tea', 'microwave', 'chair', 'food_carrot', 'cpuscreen', 'kitchen_cabinet', 'floor', 'purse', 'computer', 'stovefan', 'faucet', 'food_noodles', 'wall', 'nightstand', 'oven', 'wall_clock', 'bed', 'water', 'after_shave', 'centerpiece', 'diary', 'pencil', 'kitchen_counter', 'headset', 'pajamas', 'table', 'dishwasher', 'board_game'] 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', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer'] Task:Take shower response: { "thoughts": Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower., "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>'] }

Scene_Objects:['glue', 'tablelamp', 'toilet', 'walllamp', 'cat', 'orchid', 'floor', 'ceiling', 'remote_control', 'computer', 'food_bacon', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'mouthwash', 'television', 'coin', 'food_rice', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'table', 'soap'] 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_bread', 'toilet', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'ceiling', 'cleaning_solution', 'mop_bucket', 'table_cloth', 'faucet', 'shower', 'iron', 'clothes_socks', 'pillow', 'wall', 'food_food', 'mirror', 'wine', 'doorjamb', 'coffee_pot', 'paper_towel', 'cupboard', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'scrabble'] Task:Clean mirror response: { "thoughts": First spray the mirrors with Windex or window type spray. Take paper towels and wipe until sparkly clean. If they have streaks, repeat the process., "actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>'] }

Scene_Objects:['fork', 'pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'knifeblock', 'knife', 'hanger', 'floor', 'folder', 'desk', 'toaster', 'plate', 'faucet', 'tvstand', 'dish_soap', 'bowl', 'wall', 'cup', 'keys', 'coffe_maker', 'food_onion', 'kitchen_counter', 'dishrack', 'hairbrush', 'cupboard', 'sink', 'spoon', 'table', '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:['microwave', 'walllamp', 'detergent', 'floor', 'ceiling', 'toaster', 'faucet', 'stereo', 'electric_shaver', 'window', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'cutting_board', 'coffe_maker', 'television', 'drinking_glass', 'after_shave', 'shaving_cream', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'sink', 'bathroom_cabinet', 'vase', 'clothes_shirt'] Task:Drink response: { "thoughts": First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I drink., "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>'] }

Scene_Objects:['tablelamp', 'food_salt', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'tvstand', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'oven', 'coffee_table', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'dresser', '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:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'shower', 'window', 'food_kiwi', 'wall', 'bench', 'newspaper', 'food_food', 'coffe_maker', 'food_onion', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'home_office'] 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:['filing_cabinet', 'tablelamp', 'food_salt', 'measuring_cup', 'freezer', 'bathroom', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'piano_bench', 'stovefan', 'mat', 'faucet', 'stereo', 'couch', 'dining_room', 'photoframe', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'console', 'mouse', 'dresser', 'conditioner', 'table', 'clothes_shirt', 'creditcard'] 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:['glue', 'sponge', 'scissors', 'chair', 'dog', 'drawing', 'bills', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'ceilinglamp', 'shoe-shine_kit', 'window', 'foundation', 'couch', 'wall', 'bench', 'basket_for_clothes', 'bed', 'novel', 'television', 'kitchen_counter', 'dresser', 'cupboard', 'bathroom_cabinet', 'light', 'table'] Task:Read book response: { "thoughts": Grab book. Read it., "actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <dresser>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>'] }

Scene_Objects:['sheets', 'crayon', 'microwave', 'toilet', 'chair', 'dough', 'drawing', 'knifeblock', 'clothes_underwear', 'floor', 'folder', 'bedroom', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'candle', 'clothes_hat', 'wall', 'food_food', 'food_onion', 'cards', 'mouse', 'kitchen_counter', 'cupboard', 'conditioner', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'dirt'] 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:['glue', 'pot', 'tablelamp', 'detergent', 'cat', 'knife', 'drawing', 'hanger', 'bathroom_counter', 'desk', 'food_cake', 'purse', 'envelope', 'piano_bench', 'stovefan', 'toaster', 'stereo', 'balanceball', 'floor_lamp', 'powersocket', 'love_seat', 'newspaper', 'bed', 'photoframe', 'video_game_controller', 'diary', 'maindoor', 'light', 'soap', 'board_game'] Task:Read response: { "thoughts": Sit on an easy chair. Turn on music. Take a book and read. Turn on lamp at night., "actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <newspaper>'] }

Scene_Objects:['filing_cabinet', 'tablelamp', 'food_ice_cream', 'microwave', 'walllamp', 'orchid', 'bills', 'knife', 'wallshelf', 'floor', 'ceiling', 'remote_control', 'computer', 'tvstand', 'faucet', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'lighter', 'vacuum_cleaner', 'dresser', '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:['food_salt', 'chair', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'phone', 'bedroom', 'stamp', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'nightstand', 'wall', 'oven', 'wall_clock', 'photoframe', 'coffe_maker', 'mouse', 'dresser', 'cupboard', 'bathtub', 'sink', 'home_office', 'table', 'light'] Task:Pet cat response: { "thoughts": You walk to the living room and find the cat. You look at the cat and touch it to pet it., "actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] }

Scene_Objects:['tablelamp', 'walllamp', 'bathroom', 'orchid', 'bills', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'bowl', 'nightstand', 'wall', 'oven', 'bed', 'novel', 'food_food', 'television', 'oven_mitts', 'curtain', 'dresser', 'controller', 'table', 'dishwasher', 'soap'] Task:Watch TV response:

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'toothbrush', 'bathroom_counter', 'shampoo', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'iron', 'shower', 'stereo', 'pillow', 'wall', 'wall_clock', 'photoframe', 'food_food', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'bathroom_cabinet', 'tooth_paste', 'teeth'] Task:Wash teeth response: { "thoughts": Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth., "actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[FIND] <toothbrush>', '[FIND] <water>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>'] }

Scene_Objects:['dry_pasta', 'pot', 'cd_player', 'toilet', 'blow_dryer', 'floor', 'desk', 'tea_bag', 'remote_control', 'button', 'toaster', 'plate', 'tvstand', 'couch', 'nightstand', 'cup', 'photoframe', 'keys', 'novel', 'check', 'diary', 'vacuum_cleaner', 'cd', 'comb', 'hair', 'clothes_scarf', 'home_office', 'light', 'table', 'creditcard'] 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:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'centerpiece', 'mouse', 'cupboard', 'sink', 'bathroom_cabinet', 'table'] Task:Browse internet response: { "thoughts": Go find a computer, turn it on, click google, and browse the internet., "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] }

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

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['mop', 'microwave', 'freezer', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'piano_bench', 'shoe-shine_kit', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'tape', 'food_food', 'doorjamb', 'headset', 'cupboard', 'door', 'home_office', 'table', 'light', 'bathroom_cabinet', 'board_game'] Task:Relax on sofa response: { "thoughts": I get home from work and walk into the living room. I see the couch and go to sit on it., "actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] }

Scene_Objects:['filing_cabinet', 'scissors', 'bathroom', 'food_carrot', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'folder', 'desk', 'bookshelf', 'computer', 'mat', 'window', 'clothes_socks', 'wall', 'powersocket', 'toy', 'bed', 'food_food', 'television', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'hairdryer', 'bathroom_cabinet', 'light', 'table'] 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', 'filing_cabinet', 'food_salt', 'toilet', 'chair', 'bathroom', 'food_carrot', 'cpuscreen', 'shampoo', 'phone', 'ceiling', 'bedroom', 'desk', 'computer', 'toaster', 'shower', 'foundation', 'dustpan', 'photoframe', 'coffe_maker', 'food_rice', 'tray', 'curtain', 'doorjamb', 'console', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher', 'creditcard'] Task:Put umbrella away response: { "thoughts": Place the umbrella in the umbrella bucket point first., "actions": ['[WALK] <home_office>', '[WALK] <mop_bucket>'] }

Scene_Objects:['tablelamp', 'band-aids', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'oven', 'newspaper', 'television', 'curtain', 'headset', 'dresser', 'clothes_dress', 'spoon', 'table', 'dishwasher', 'clothes_skirt'] 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:['juice', 'walllamp', 'nail_polish', 'detergent', 'dough', 'drawing', 'food_egg', 'tea_bag', 'bookshelf', 'remote_control', 'alcohol', 'button', 'mop_bucket', 'table_cloth', 'stovefan', 'tvstand', 'shoe-shine_kit', 'shower', 'stereo', 'deck_of_cards', 'mousepad', 'powersocket', 'check', 'rag', 'towel_rack', 'pencil', 'conditioner', 'door', 'bathroom_cabinet', 'soap'] Task:Change TV channel response: { "thoughts": Take the Tv Remote Control in the Living Room table And Press the Channel Change Button to change the channel, "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[PUTOBJBACK] <remote_control>'] }

Scene_Objects:['glue', 'dry_pasta', 'food_ice_cream', 'chair', 'walllamp', 'nail_polish', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'photoframe', 'toilet_paper', 'television', 'wine', 'doorjamb', 'dresser', 'clothes_shirt'] 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', 'food_pizza', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'bathroom', 'woman', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'desk', 'man', 'button', 'deck_of_cards', 'mousepad', 'clothes_pants', 'child', 'coffe_maker', 'tray', 'comb', 'dresser', 'cupboard', 'hairbrush', 'soap', 'tooth_paste'] Task:Greet guests response: { "thoughts": Greet guests when they knock on the door and invite them to enter my home, "actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>'] }

Scene_Objects:['beer', 'microwave', 'toilet', 'walllamp', 'ground_coffee', 'detergent', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'computer', 'alcohol', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'food_rice', 'tray', 'doorjamb', 'shaving_cream', 'home_office'] Task:Text friends while sitting on couch 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:['ceilingfan', 'toothbrush', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'mop_bucket', 'mat', 'tvstand', 'faucet', 'couch', 'clothes_pants', 'towel', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'wooden_spoon', 'after_shave', 'coffee', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'laser_pointer', 'hands_both', 'shoe_rack'] Task:Wash hands response: { "thoughts": Turn faucet clockwise to turn on water. Place hands under stream of water, pick up soap, rub hands with soap. Put soap back down. Rub hands together with soap on them. Rinse hands under water from faucet. Turn faucet counterclockwise to turn water off. Dry hands by rubbing them on a towel., "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] }

Scene_Objects:['chair', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap'] Task:Change TV channels 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', 'cat', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'oil', 'closetdrawer', 'food_orange', 'form', 'pillow', 'wall', 'nightstand', 'powersocket', 'tape', 'photoframe', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'dishwasher', 'clothes_skirt', 'table'] Task:Turn on light response: { "thoughts": approach the light switch, raise hand to the switch, flip the switch, "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] }

Scene_Objects:['spectacles', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'rag', 'doorjamb', 'cards', 'dresser', 'sink', '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:['fork', 'pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'knifeblock', 'knife', 'hanger', 'floor', 'folder', 'desk', 'toaster', 'plate', 'faucet', 'tvstand', 'dish_soap', 'bowl', 'wall', 'cup', 'keys', 'coffe_maker', 'food_onion', 'kitchen_counter', 'dishrack', 'hairbrush', 'cupboard', 'sink', 'spoon', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: { "thoughts": I walk to the kitchen and find the dishwasher. I open it. I find the sink and grab the dirty plates, cups, bowls, and utensils. I rinse off the dirty dishes under the faucet. I then place the dirty dishes into the dishwasher. I add soap to the dishwasher and close the lid. I turn it on and wait., "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <sink>', '[FIND] <bowl>', '[GRAB] <bowl>', '[RINSE] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[RINSE] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[RINSE] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[RINSE] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[RINSE] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[TURNTO] <dishwasher>'] }

Scene_Objects:['sponge', 'fork', 'filing_cabinet', 'tablelamp', 'chair', 'band-aids', 'floor', 'ceiling', 'stamp', 'alcohol', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'towel', 'wall', 'toy', 'bed', 'keys', 'photoframe', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'table'] Task:Wash dishes 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', 'trashcan', 'orchid', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'window', 'food_noodles', 'couch', 'pillow', 'wall', 'photoframe', 'toothbrush_holder', 'curtain', 'doorjamb', 'chessboard', 'door', 'bathtub', 'bag', 'home_office', 'light', 'table', 'dishwasher', 'instrument_violin'] Task:Admire art response: { "thoughts": Looking at painting, art, "actions": ['[WALK] <home_office>', '[WALK] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>'] }

Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'food_butter', 'food_carrot', 'bills', 'floor', 'ceiling', 'bedroom', 'computer', 'table_cloth', 'tvstand', 'shower', 'faucet', 'wall', 'oven', 'newspaper', 'photoframe', 'bed', 'coffee_filter', 'curtain', 'kitchen_counter', 'cupboard', 'controller', 'dishwasher', 'clothes_shirt'] Task:Make popcorn 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', 'mop', 'microwave', 'chair', 'freezer', 'dog', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'phone', 'dvd_player', 'character', 'bookshelf', 'computer', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'bench', 'photoframe', 'food_food', 'tray', 'curtain', 'kitchen_counter', 'door', 'sink', 'table'] Task:Pet dog response: { "thoughts": Pet my dog in hall, "actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>'] }

Scene_Objects:['tea', 'microwave', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'button', 'food_bacon', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'coffee_table', 'novel', 'mouthwash', 'television', 'doorjamb', 'diary', 'clothes_scarf', 'sink'] Task:Read book response: