Datasets:

Barrybw

/

input_thoughts

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:['filing_cabinet', 'tablelamp', 'beer', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'mousepad', 'candle', 'wall', 'nightstand', 'newspaper', 'doorjamb', 'mouse', 'light', 'clothes_skirt'] 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:['sponge', 'pot', 'tablelamp', 'ground_coffee', 'walllamp', 'trashcan', 'knifeblock', 'longboard', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'tvstand', 'wall', 'clothes_gloves', 'keys', 'coffe_maker', 'check', 'video_game_controller', 'coffee_filter', 'toilet_paper', 'food_onion', 'curtain', 'kitchen_counter', 'controller', 'hairdryer', 'dishwasher', 'vase', 'soap'] Task:Make coffee response:

{ You walk into the kitchen and turn to the coffee maker. You grab the coffee filter and put into the coffee machine, you also grab the ground coffee and put it into the coffee machine. You turn on the coffee machine. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'glue', 'tea', 'chair', 'freezer', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'keyboard', 'bookshelf', 'food_bacon', 'tvstand', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'toilet_paper', 'diary', 'mouse', 'chessboard', 'spoon', 'home_office', 'table', 'light'] Task:Sit in chair response: { thoughts : I sit in a chair to rest and eat., actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>'] } Scene_Objects:['pot', 'food_bread', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'desk', 'food_cake', 'stovefan', 'ceilinglamp', 'toaster', 'food_orange', 'wall', 'pasta', 'oven', 'tape', 'tray', 'wooden_spoon', 'centerpiece', 'kitchen_counter', 'cupboard', 'napkin', 'dishwasher', 'clothes_shirt'] Task:Cook some food response:

{ Walk into the kitchen. Open the fridge. Take out the chicken. Open the kitchen cabinet. Take out the frying pan. Put the chicken in the frying pan. Put the frying pan on the stove. Turn on the stove. Cook the chicken. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'thread', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'bench', 'cup', 'light_bulb', 'coffe_maker', 'toilet_paper', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'table'] Task:Work response: { thoughts : Type on a computer in the home office., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'stereo', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'wall', 'oven', 'tape', 'check', 'television', 'doorjamb', 'mouse', 'pencil', 'cd', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light', 'table', 'instrument_violin'] Task:Relax on sofa response:

{ I want to relax on the sofa to some relaxing music in the living room. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'jelly', 'trashcan', 'food_egg', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'cleaning_solution', 'bookshelf', 'computer', 'shower', 'window', 'clothes_pants', 'dining_room', 'nightstand', 'pasta', 'oven', 'tape', 'food_cheese', 'bed', 'ice', 'coffee_pot', 'dishrack', 'sink', 'table', 'light', 'hands_both'] Task:Wash hands response: { thoughts : walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands, actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['sheets', 'juice', 'microwave', 'freezer', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'ceilinglamp', 'plate', 'window', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'powersocket', 'novel', 'food_food', 'mouthwash', 'television', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'comb', 'door', 'laser_pointer'] Task:Put groceries in Fridge response:

{ Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge, }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher'] Task:Change TV channel response: { thoughts : I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['pot', 'beer', 'microwave', 'ceilingfan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'mat', 'oil', 'couch', 'dining_room', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'kettle', 'door', 'napkin', 'table'] Task:Relax on sofa response:

{ I walk to my living room and switch on the television, and lay on the sofa. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'character', 'keyboard', 'envelope', 'clothes_jacket', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'wall', 'nightstand', 'bench', 'wall_clock', 'television', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet'] Task:Go to toilet response: { thoughts : I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[TURNTO] <toilet>', '[LOOKAT] <toilet>', '[WALK] <toilet>', '[TURNTO] <toilet>'] } Scene_Objects:['sponge', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response:

{ Using dishwasher to wash dishes }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'stamp', 'computer', 'brush', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'television', 'doorjamb', 'vacuum_cleaner', 'hairbrush', 'cupboard', 'table'] Task:Read book response: { thoughts : I pick up a book off the self that I want to read. Then, I sit down on the couch, open the book, and begin reading it., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>'] } Scene_Objects:['food_ice_cream', 'toilet', 'dog', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'longboard', 'floor', 'phone', 'character', 'purse', 'computer', 'toaster', 'plate', 'balanceball', 'stereo', 'dish_soap', 'food_kiwi', 'wall', 'oven', 'tape', 'coffe_maker', 'mouthwash', 'tray', 'door', 'sink', 'napkin', 'dishwasher', 'vase'] Task:Wash dishes with dishwasher response:

{ Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['dry_pasta', 'food_salt', 'microwave', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'bathroom_counter', 'desk', 'clothes_jacket', 'table_cloth', 'stovefan', 'plate', 'stereo', 'couch', 'food_peanut_butter', 'basket_for_clothes', 'photoframe', 'novel', 'mouthwash', 'toothbrush_holder', 'food_donut', 'lighter', 'laundry_detergent', 'conditioner', 'home_office', 'dishwasher', 'soap', 'washing_machine'] Task:Wash clothes response:

{ Walk to the kitchen and find the basket of clothes. Put the soap and clothes into the washing machine. Turn on the washing machine. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'detergent', 'drawing', 'orchid', 'floor', 'character', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'coffe_maker', 'kitchen_counter', 'shoes', 'cd', 'hairbrush', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'scrabble', 'hands_both'] Task:Wash hands response: { thoughts : I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'computer', 'stereo', 'shower', 'towel', 'wall', 'wall_clock', 'pasta', 'nightstand', 'bed', 'doorjamb', 'dresser', 'cupboard', 'conditioner', 'door', 'clothes_scarf', 'light', 'clothes_shirt'] Task:Turn on light response:

{ approach the light switch, raise hand to the switch, flip the switch }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'pot', 'glue', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'floor', 'ceiling', 'phone', 'food_cake', 'table_cloth', 'plate', 'faucet', 'stereo', 'dish_soap', 'towel', 'bowl', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'centerpiece', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'spoon'] Task:Wash dishes by hand response: { thoughts : I enter the kitchen, walk to the sink, turn on the faucet, grab the sponge and get it wet, then apply dish soap to the sponge. I take a dish, scrub it with the sponge, rinse it, and place it on the dish rack to dry, and repeat until all the dishes are clean. I rinse the sponge, put it down, and turn off the faucet., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <sponge>', '[FIND] <dish_soap>', '[GRAB] <sponge>', '[RINSE] <sponge>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[SQUEEZE] <sponge>', '[FIND] <bowl>', '[GRAB] <bowl>', '[SCRUB] <bowl>', '[RINSE] <bowl>', '[FIND] <dishrack>', '[PUTBACK] <bowl> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[SCRUB] <spoon>', '[RINSE] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[RINSE] <sponge>', '[SQUEEZE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'freezer', 'blow_dryer', 'trashcan', 'orchid', 'hanger', 'floor', 'computer', 'button', 'stovefan', 'ceilinglamp', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'bed', 'novel', 'tray', 'curtain', 'after_shave', 'towel_rack', 'pencil', 'maindoor', 'sink', 'light', 'dishwasher'] Task:Go to sleep response:

{ Walk to bedroom. Walk to bed, lie in bed. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_salt', 'food_butter', 'food_carrot', 'drawing', 'food_egg', 'floor', 'phone', 'ceiling', 'character', 'purse', 'mat', 'plate', 'window', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'bed', 'photoframe', 'tray', 'coffee_pot', 'kitchen_counter', 'shoes', 'pajamas', 'sink', 'spoon', 'bathtub', 'table', 'vase'] Task:Set up table response: { thoughts : Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above the plate., actions : ['[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[DROP] <plate>', '[FIND] <fork>', '[GRAB] <fork>', '[DROP] <fork>', '[FIND] <spoon>', '[GRAB] <spoon>', '[DROP] <spoon>'] } Scene_Objects:['fork', 'microwave', 'ceilingfan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'food_cake', 'thread', 'faucet', 'towel', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'water', 'rag', 'lighter', 'cards', 'console', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'table', 'soap', 'laser_pointer', 'hands_both'] Task:Wash hands response:

{ Go into the bathroom and go over to the sink. Grab soap and turn on the water. Wet your hands and rub them together so that the soap lathers. Rub the soap all over your hands thoroughly. Rinse off the soap with water and turn off the sink. Dry your hands with a towel. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'alcohol', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'curtain', 'rag', 'doorjamb', 'dresser', 'table', 'clothes_skirt'] Task:Watch TV response: { thoughts : go to living room, sit on couch, get remote, switch on tv, watch tv, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>'] } 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:

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

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'freezer', 'trashcan', 'knife', 'longboard', 'floor', 'shampoo', 'computer', 'button', 'tvstand', 'stereo', 'window', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'nightstand', 'bed', 'novel', 'check', 'wine', 'curtain', 'cupboard', 'hair', 'sink', 'bathroom_cabinet', 'soap', 'creditcard'] Task:Read book response: { thoughts : I would go lie down in my bed and open the book and start reading., actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'desk', 'food_cake', 'stovefan', 'toaster', 'deck_of_cards', 'faucet', 'candle', 'pillow', 'dining_room', 'oven', 'photoframe', 'check', 'food_food', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'board_game', 'clothes_shirt'] Task:Pet cat response:

{ Walk to living room. Find cat. Walk to cat. Pull cat. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'filing_cabinet', 'cat', 'food_butter', 'hanger', 'floor', 'ceiling', 'food_cake', 'ceilinglamp', 'deck_of_cards', 'tvstand', 'homework', 'mousepad', 'closetdrawer', 'teeth', 'food_jam', 'nightstand', 'powersocket', 'bed', 'check', 'video_game_controller', 'mouthwash', 'towel_rack', 'mouse', 'console', 'cd', 'cupboard', 'instrument_guitar', 'coffee', 'shoe_rack'] Task:Clean response: { thoughts : Clean the welcome mat, actions : ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['pot', 'chair', 'freezer', 'food_butter', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bedroom', 'desk', 'bookshelf', 'button', 'bookmark', 'toaster', 'ceilinglamp', 'deck_of_cards', 'iron', 'tvstand', 'pillow', 'pasta', 'bench', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'mouse', 'dresser', 'controller'] Task:Pick up phone response:

{ walk into living room, look at the phone when it ringing, grab the phone or pickup the phone }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'bathroom', 'detergent', 'ceilingfan', 'milk', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_rice', 'mouse', 'pencil', 'pajamas', 'maindoor', 'board_game', 'teeth', 'shoe_rack'] Task:Wipe down baseboards please response: { thoughts : Use a rag to get all the dust off the baseboards please., actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'stereo', 'mousepad', 'food_noodles', 'form', 'food_kiwi', 'wall', 'nightstand', 'photoframe', 'check', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'light'] Task:Work response:

{ Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bench', 'food_food', 'water', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : I turn on faucet. I hold out my hands. I get my hands wet., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>'] } Scene_Objects:['filing_cabinet', 'juice', 'microwave', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'clothes_jacket', 'button', 'ceilinglamp', 'mat', 'window', 'couch', 'food_jam', 'wall', 'nightstand', 'cutting_board', 'cup', 'television', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'table', 'vase', 'coffee'] Task:Pet cat response:

{ Walk into bedrrom and to the sofa. Sit on the sofa and touch cat. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Browse internet response: { thoughts : I walk into my home office and walk up to my desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on the google icon. I enter Disney Cruise Line into the search bar and browse the internet., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['fork', 'sponge', 'scissors', 'microwave', 'ground_coffee', 'dough', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'tea_bag', 'food_cake', 'toaster', 'stovefan', 'tvstand', 'food_orange', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'coffee_filter', 'hairbrush', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'vase'] Task:Make coffee response:

{ Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'tablelamp', 'blender', 'food_ice_cream', 'toothbrush', 'knifeblock', 'hanger', 'dvd_player', 'alcohol', 'button', 'stovefan', 'stereo', 'homework', 'mousepad', 'powersocket', 'cup', 'food_cheese', 'bed', 'food_donut', 'tray', 'after_shave', 'doorjamb', 'lighter', 'dresser', 'home_office', 'light', 'bathroom_cabinet', 'dishwasher', 'soap', 'creditcard'] Task:Pet cat response: { thoughts : I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['filing_cabinet', 'tea', 'chair', 'freezer', 'bathroom', 'trashcan', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'bedroom', 'computer', 'plate', 'stereo', 'window', 'food_kiwi', 'wall', 'nightstand', 'box', 'bed', 'clothes_gloves', 'coffe_maker', 'wooden_spoon', 'curtain', 'shoes', 'dishwasher', 'creditcard'] Task:Listen to music response:

{ I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'character', 'bedroom', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'pasta', 'bench', 'cup', 'bed', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'headset', 'cupboard', 'instrument_guitar', 'table'] Task:Relax on sofa response: { thoughts : I walk into the living room. I bend down. I sit on the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'microwave', 'ground_coffee', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'button', 'toaster', 'tvstand', 'shower', 'picture', 'couch', 'food_jam', 'food_orange', 'dining_room', 'wall', 'powersocket', 'coffe_maker', 'toilet_paper', 'coffee_filter', 'water', 'centerpiece', 'cupboard', 'door', 'sink', 'bag', 'table', 'dishwasher', 'tooth_paste'] Task:Make coffee response:

{ Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'tea_bag', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'pasta', 'nightstand', 'photoframe', 'novel', 'food_food', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'light', 'board_game'] Task:Read book response: { thoughts : Bring book, lie on the sofa, read book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>'] } Scene_Objects:['glue', 'food_pizza', 'filing_cabinet', 'juice', 'toilet', 'freezer', 'trashcan', 'toothbrush', 'character', 'remote_control', 'tvstand', 'faucet', 'picture', 'deck_of_cards', 'clothes_socks', 'clothes_hat', 'pillow', 'oven', 'coffe_maker', 'coin', 'curtain', 'rag', 'towel_rack', 'dishrack', 'dresser', 'cupboard', 'laundry_detergent', 'light', 'clothes_skirt', 'teeth'] Task:Watch TV response:

{ I walk to the living room and sit on the couch. I grab the TV remote. I press the power button on the TV remote and the TV turns on. I grab the surround sound remote. I press the power button on the surround sound remote and the system turns on. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'window', 'mousepad', 'form', 'dining_room', 'wall', 'cutting_board', 'bed', 'clothes_gloves', 'check', 'television', 'oven_mitts', 'curtain', 'mouse', 'hair', 'napkin', 'vase', 'instrument_violin', 'laser_pointer'] Task:Gaze out window response: { thoughts : Look at the yard from the window, actions : ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>'] } Scene_Objects:['microwave', 'walllamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'phone', 'bedroom', 'bookshelf', 'electric_shaver', 'window', 'towel', 'wall', 'nightstand', 'oven', 'powersocket', 'basket_for_clothes', 'newspaper', 'check', 'oven_mitts', 'after_shave', 'towel_rack', 'mouse', 'kettle', 'dresser', 'laundry_detergent', 'bag', 'table', 'dishwasher', 'washing_machine', 'shoe_rack'] Task:Wash clothes response:

{ Pick up my dirty clothes, load the washer, add detergent, turn on washer }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'nail_polish', 'trashcan', 'milk', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'computer', 'faucet', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'check', 'coffe_maker', 'wine', 'after_shave', 'towel_rack', 'comb', 'controller', 'sink', 'bathroom_cabinet', 'light', 'table', 'instrument_violin', 'teeth'] Task:Get toilet paper response: { thoughts : There are extra toilet papers in the bottom cabinet., actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>'] } Scene_Objects:['sponge', 'beer', 'microwave', 'chair', 'ceilingfan', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'shampoo', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'dining_room', 'wall', 'pasta', 'oven', 'photoframe', 'television', 'curtain', 'coffee_pot', 'comb', 'controller', 'table'] Task:Change TV channel response:

{ walk to living room ,find television ,find remote control ,switch on remote control and change the channel }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'pot', 'food_pizza', 'scissors', 'tablelamp', 'microwave', 'band-aids', 'floor', 'folder', 'food_cake', 'mail', 'computer', 'table_cloth', 'toaster', 'brush', 'plate', 'shower', 'dish_soap', 'wall', 'coffe_maker', 'oven_mitts', 'food_donut', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'home_office', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['tea', 'toilet', 'chair', 'detergent', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'character', 'bookshelf', 'purse', 'envelope', 'toaster', 'tvstand', 'shower', 'window', 'pillow', 'tape', 'cup', 'coffe_maker', 'check', 'oven_mitts', 'curtain', 'rag', 'lighter', 'mouse', 'pencil', 'hairbrush', 'table', 'vase'] Task:Pet cat response:

{ find the cat, go near the cat and pet the cat }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'ceilingfan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'mat', 'oil', 'couch', 'dining_room', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'kettle', 'door', 'napkin', 'table'] Task:Relax on sofa response: { thoughts : I walk to my living room and switch on the television, and lay on the sofa., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>'] } Scene_Objects:['walllamp', 'ceilingfan', 'drawing', 'needle', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table', 'laser_pointer'] Task:Watch TV response:

{ Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch the television. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', '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: { thoughts : Walk to home office. Walk to computer. Switch on Computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['tablelamp', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'longboard', 'bedroom', 'keyboard', 'clothes_jacket', 'bookmark', 'toaster', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'pillow', 'nightstand', 'wall', 'photoframe', 'food_food', 'mouthwash', 'tray', 'diary', 'comb', 'pajamas', 'maindoor', 'bag', 'spoon', 'light'] Task:Pet cat response:

{ Go to the living room where the cat sleeps. Find cat. Proceed to petting cat. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'bathroom', 'cat', 'cpuscreen', 'bathroom_counter', 'bedroom', 'food_cake', 'computer', 'alcohol', 'toaster', 'stovefan', 'ceilinglamp', 'mousepad', 'closetdrawer', 'clothes_hat', 'nightstand', 'wall_clock', 'newspaper', 'coffee_filter', 'oven_mitts', 'kettle', 'kitchen_counter', 'dresser', 'hair', 'sink', 'napkin', 'bag', 'light'] Task:Pet cat response: { thoughts : find the cat, go near the cat and pet the cat, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['sheets', 'filing_cabinet', 'board_game', 'freezer', 'food_butter', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'keyboard', 'faucet', 'stereo', 'window', 'food_peanut_butter', 'towel', 'dining_room', 'wall', 'bench', 'photoframe', 'towel_rack', 'kitchen_counter', 'coffee', 'sink', 'bathroom_cabinet', 'dishwasher', 'tooth_paste', 'teeth', 'creditcard'] Task:Wash teeth response:

{ I go to sleep and i eat the dinner so i have to clean my mouth }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'shoe_rack', 'food_salt', 'beer', 'measuring_cup', 'microwave', 'trashcan', 'food_carrot', 'orchid', 'drawing', 'bookshelf', 'envelope', 'alcohol', 'ceilinglamp', 'plate', 'food_jam', 'pillow', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'lighter', 'doorjamb', 'coffee_pot', 'towel_rack', 'cupboard', 'hairdryer', 'creditcard'] Task:Pet cat response: { thoughts : find a cat, touch it gently, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['chair', 'freezer', 'trashcan', 'ceilingfan', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'oil', 'food_orange', 'pillow', 'bowl', 'wall', 'wall_clock', 'bench', 'keys', 'light_bulb', 'food_food', 'check', 'television', 'drinking_glass', 'water', 'centerpiece', 'dishrack', 'hairbrush'] Task:Drink response:

{ go to the kitchen }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'filing_cabinet', 'mop', 'microwave', 'trashcan', 'drawing', 'ceiling', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'tvstand', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'form', 'pillow', 'nightstand', 'newspaper', 'bed', 'curtain', 'towel_rack', 'dishrack', 'home_office', 'light', 'dishwasher', 'table', 'scrabble'] Task:Wash dishes by hand response: { thoughts : walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <dishrack>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <dishrack> <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['food_salt', 'microwave', 'trashcan', 'drawing', 'floor', 'dvd_player', 'desk', 'envelope', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'check', 'television', 'coin', 'colander', 'after_shave', 'cd', 'cupboard', 'table', 'vase', 'soap'] Task:Relax on sofa response:

{ Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer'] Task:Pet cat response:

{ I walk into the living room and I pet the cat }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'microwave', 'chair', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'mail', 'computer', 'toaster', 'mat', 'stovefan', 'faucet', 'mousepad', 'dining_room', 'wall', 'nightstand', 'coffe_maker', 'water', 'food_rice', 'drinking_glass', 'curtain', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher'] Task:Drink response: { thoughts : I walk to the kitchen and approach the sink. I take a drinking glass and set it under the faucet. I turn the faucet until the water fills the glass, then turn it back. Finally I lift the glass out of the sink and drink the water., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>'] } Scene_Objects:['sheets', 'pot', 'chair', 'ground_coffee', 'orchid', 'knifeblock', 'longboard', 'floor', 'ceiling', 'stamp', 'computer', 'toaster', 'picture', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'bed', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'vase', 'colander'] Task:Make coffee response:

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

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'dvd_player', 'desk', 'bedroom', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'tray', 'curtain', 'controller', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'light'] Task:Listen to music response: { thoughts : walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music, actions : ['[WALK] <home_office>', '[WALK] <dvd_player>', '[FIND] <dvd_player>', '[TURNTO] <dvd_player>', '[LOOKAT] <dvd_player>', '[SWITCHON] <dvd_player>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>'] } Scene_Objects:['sponge', 'food_salt', 'chair', 'detergent', 'trashcan', 'dough', 'drawing', 'character', 'computer', 'button', 'brush', 'mat', 'couch', 'clothes_pants', 'clothes_hat', 'wall', 'nightstand', 'basket_for_clothes', 'food_cheese', 'rag', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'laundry_detergent', 'conditioner', 'sink', 'home_office', 'table', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response:

{ Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee'] Task:Bring dirty plate to sink response: { thoughts : Stand up from the table. Pick up dirty plate. Walk to sink. Put plate in sink., actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>'] } Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'crayon', 'bills', 'knifeblock', 'hanger', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'form', 'wall', 'nightstand', 'coffe_maker', 'food_food', 'razor', 'coin', 'video_game_controller', 'check', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'spoon', 'napkin', 'dishwasher', 'vase'] Task:Read book response:

{ walk to living room ,find a book ,open the book ,read the book }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tea', 'microwave', 'jelly', 'band-aids', 'freezer', 'bathroom', 'needle', 'ceiling', 'character', 'keyboard', 'mop_bucket', 'ceilinglamp', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'check', 'television', 'cards', 'laundry_detergent', 'clothes_dress', 'home_office', 'table'] Task:Put umbrella away response: { thoughts : Place the umbrella in the umbrella bucket point first., actions : ['[WALK] <home_office>', '[WALK] <mop_bucket>'] } Scene_Objects:['fork', 'microwave', 'freezer', 'blow_dryer', 'food_carrot', 'milk', 'drawing', 'floor', 'phone', 'keyboard', 'bookshelf', 'button', 'piano_bench', 'laptop', 'plate', 'oil', 'mousepad', 'wall', 'bench', 'photoframe', 'keys', 'food_food', 'check', 'tray', 'kitchen_counter', 'dishrack', 'hair', 'table', 'soap', 'teeth'] Task:Set up table response:

{ I walk to the table. I put down the dish. I put down the silverware. I put down the napkin. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'dustpan', 'pillow', 'broom', 'wall', 'powersocket', 'cup', 'video_game_controller', 'television', 'doorjamb', 'hairbrush', 'door', 'sink', 'bag', 'table'] Task:Watch TV response: { thoughts : Walk to living room. Find remote control. Find television. Point remote at television. Press on button. Watch., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'jelly', 'trashcan', 'food_egg', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'cleaning_solution', 'bookshelf', 'computer', 'shower', 'window', 'clothes_pants', 'dining_room', 'nightstand', 'pasta', 'oven', 'tape', 'food_cheese', 'bed', 'ice', 'coffee_pot', 'dishrack', 'sink', 'table', 'light', 'hands_both'] Task:Wash hands response:

{ walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'chair', 'jelly', 'ground_coffee', 'nail_polish', 'detergent', 'orchid', 'needle', 'drawing', 'hanger', 'character', 'envelope', 'ceilinglamp', 'shower', 'electric_shaver', 'tooth_paste', 'mousepad', 'food_kiwi', 'powersocket', 'oven', 'tape', 'cup', 'photoframe', 'wooden_spoon', 'cards', 'kitchen_counter', 'cd', 'instrument_violin', 'laser_pointer'] Task:Wash dishes with dishwasher response: { thoughts : grab the vesseles and wash, actions : ['[WALK] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dining_room>', '[WASH] <bowl>', '[WALK] <detergent>', '[FIND] <detergent>', '[RINSE] <detergent>'] } Scene_Objects:['dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'detergent', 'ceilingfan', 'orchid', 'drawing', 'bathroom_counter', 'character', 'bookshelf', 'stovefan', 'tvstand', 'balanceball', 'electric_shaver', 'window', 'clothes_socks', 'oven', 'light_bulb', 'television', 'food_rice', 'tray', 'after_shave', 'wooden_spoon', 'towel_rack', 'kettle', 'mouse', 'dishrack', 'dresser', 'instrument_violin'] Task:Pet cat response:

{ Go into the living room and pet the cat }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'milk', 'floor', 'ceiling', 'shampoo', 'purse', 'ceilinglamp', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'tape', 'novel', 'food_food', 'food_donut', 'wooden_spoon', 'mouse', 'kitchen_counter', 'door', 'home_office', 'bathroom_cabinet', 'vase', 'soap', 'instrument_violin', 'creditcard'] Task:Put groceries in Fridge response: { thoughts : I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['microwave', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'remote_control', 'mop_bucket', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'form', 'food_kiwi', 'wall', 'oven', 'powersocket', 'cutting_board', 'cup', 'bed', 'toilet_paper', 'food_food', 'television', 'curtain', 'centerpiece', 'maindoor', 'napkin', 'table', 'vase'] Task:Watch TV response:

{ Walk to living room. Sit on the sofa. Grab the remote control and plug in TV. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'curtain', 'shoes', 'cd', 'vacuum_cleaner', 'dresser', 'cupboard', 'clothes_dress', 'home_office', 'table', 'shoe_rack'] Task:Take off shoes response: { thoughts : Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area., actions : ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['toilet', 'walllamp', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'purse', 'stovefan', 'ceilinglamp', 'stereo', 'faucet', 'window', 'balanceball', 'electric_shaver', 'couch', 'wall', 'bench', 'food_food', 'television', 'curtain', 'diary', 'mouse', 'dresser', 'hair', 'bathroom_cabinet', 'table', 'home_office', 'vase', 'teeth', 'shoe_rack'] Task:Relax on sofa response:

{ Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'shampoo', 'ceiling', 'button', 'deck_of_cards', 'shower', 'clothes_pants', 'food_kiwi', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'home_office', 'light', 'clothes_skirt', 'dishwasher', 'coffee'] Task:Grab things response: { thoughts : The robot will need some kind of hands or grabbing device to transport objects., actions : ['[WALK] <novel>', '[TURNTO] <novel>', '[GRAB] <novel>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'scissors', 'freezer', 'ceilingfan', 'knifeblock', 'knife', 'hanger', 'phone', 'desk', 'clothes_jacket', 'toaster', 'ceilinglamp', 'electric_shaver', 'window', 'mousepad', 'couch', 'candle', 'cutting_board', 'food_cheese', 'food_rice', 'food_onion', 'pencil', 'cd', 'comb', 'door', 'maindoor', 'napkin', 'soap'] Task:Pet cat response:

{ You walk to the living room and find the cat. You look at the cat and touch it to pet it. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'beer', 'toilet', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'folder', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'microphone', 'wall', 'bench', 'light_bulb', 'television', 'curtain', 'food_steak', 'sink', 'napkin', 'home_office', 'table'] Task:Watch TV response: { thoughts : I walk into my living room, find the remote and sit on my sofa. I look at the remote and switch on the television. I look at the Television., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['dry_pasta', 'blender', 'knife', 'orchid', 'drawing', 'longboard', 'character', 'desk', 'computer', 'button', 'toaster', 'tvstand', 'faucet', 'clothes_socks', 'dirt', 'cutting_board', 'basket_for_clothes', 'cup', 'photoframe', 'bed', 'novel', 'coffe_maker', 'razor', 'curtain', 'mouse', 'pencil', 'table', 'dishwasher', 'soap', 'washing_machine'] Task:Wash clothes response:

{ put clothes and soap in the washing machine, turn it on }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', '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: { thoughts : walk to home office ,find computer ,switch on computer and work, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['drawing', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'computer', 'button', 'mat', 'ceilinglamp', 'shower', 'faucet', 'tvstand', 'food_peanut_butter', 'towel', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'curtain', 'mouse', 'kitchen_counter', 'shoes', 'laundry_detergent', 'food_steak', 'sink', 'bag', 'bathroom_cabinet', 'door', 'vase', 'soap'] Task:Take shower response:

{ I want to take a shower so I go to the bathroom, turn on the shower, get the soap, lather and wash, then I rinse, turn off shower, get a towel and dry off. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'coin', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'table'] Task:Watch TV response: { thoughts : Watch the television, actions : ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['glue', 'filing_cabinet', 'chair', 'walllamp', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'window', 'couch', 'clothes_pants', 'wall', 'cup', 'novel', 'toilet_paper', 'television', 'wine', 'kitchen_counter', 'dishrack', 'comb', 'dresser', 'coffee_cup', 'table', 'teeth'] Task:Relax on sofa response:

{ you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'newspaper', 'television', 'food_donut', 'food_rice', 'doorjamb', 'mouse', 'cd', 'dresser'] 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:['glue', 'sheets', 'tablelamp', 'scissors', 'measuring_cup', 'knifeblock', 'orchid', 'desk', 'mop_bucket', 'toaster', 'deck_of_cards', 'window', 'couch', 'towel', 'pillow', 'broom', 'nightstand', 'toothbrush_holder', 'food_onion', 'centerpiece', 'mouse', 'vacuum_cleaner', 'hairbrush', 'door', 'napkin', 'home_office', 'table', 'bag', 'light', 'teeth'] Task:Pick up phone response:

{ Walk to the living room, Find Phone stand. Find Phone. Pickup the receiver to attend the call. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'dustpan', 'dining_room', 'wall', 'nightstand', 'pasta', 'tape', 'photoframe', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'light'] Task:Turn on computer response: { thoughts : Press the power button on the computer to turn it on, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['sheets', 'food_salt', 'microwave', 'chair', 'freezer', 'band-aids', 'bathroom', 'detergent', 'knife', 'knifeblock', 'bathroom_counter', 'longboard', 'dvd_player', 'desk', 'bookshelf', 'computer', 'bookmark', 'stovefan', 'tvstand', 'faucet', 'balanceball', 'powersocket', 'bench', 'check', 'razor', 'after_shave', 'dresser', 'controller', 'table', 'scrabble'] Task:Pick up phone response:

{ Walk to home office 1. Walk over to phone 1 on table 1. Grab phone 1. lift phone 1. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'beer', 'measuring_cup', 'toilet', 'drawing', 'knife', 'hanger', 'floor', 'desk', 'tea_bag', 'keyboard', 'piano_bench', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'foundation', 'clothes_pants', 'towel', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'bag', 'table', 'vase', 'soap'] Task:Wash hands response: { thoughts : BEFORE EATING, actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <towel>', '[WIPE] <towel>'] } Scene_Objects:['tablelamp', 'food_salt', 'tea', 'mop', 'microwave', 'toilet', 'orchid', 'longboard', 'character', 'stamp', 'purse', 'stovefan', 'laptop', 'mat', 'shower', 'faucet', 'clothes_socks', 'food_peanut_butter', 'wall', 'box', 'bed', 'coffe_maker', 'doorjamb', 'towel_rack', 'dishrack', 'maindoor', 'sink', 'dishwasher', 'clothes_shirt', 'coffee'] Task:Turn on light response:

{ I walk into the living room and then I walk to the light switch in there and turn the lights on }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office'] Task:Make coffee response: { thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'tablelamp', 'cat', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'character', 'keyboard', 'remote_control', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'pillow', 'wall', 'check', 'television', 'curtain', 'door', 'home_office', 'table', 'bathroom_cabinet'] Task:Change TV channel response:

{ Pickup remote control for the living room TV and push the change channel button }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tea', 'toilet', 'freezer', 'band-aids', 'knifeblock', 'food_egg', 'shampoo', 'phone', 'bookshelf', 'purse', 'thread', 'deck_of_cards', 'shower', 'picture', 'clothes_socks', 'oven', 'food_cheese', 'novel', 'food_food', 'check', 'coffe_maker', 'tray', 'after_shave', 'curtain', 'doorjamb', 'cupboard', 'controller', 'bag', 'table', 'scrabble'] Task:Drink response: { thoughts : Pour water into a glass and drink from the glass., actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['tablelamp', 'food_ice_cream', 'mop', 'nail_polish', 'detergent', 'trashcan', 'food_carrot', 'drawing', 'hanger', 'longboard', 'floor', 'keyboard', 'ceilinglamp', 'plate', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'powersocket', 'bench', 'novel', 'food_food', 'television', 'wine', 'doorjamb', 'conditioner', 'bathroom_cabinet', 'table', 'clothes_skirt'] Task:Relax on sofa response:

{ Walk into the living room. Walk up to the sofa. Sit down on the sofa. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'bathroom', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'keyboard', 'bookshelf', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'window', 'food_peanut_butter', 'clothes_pants', 'oven', 'basket_for_clothes', 'food_food', 'television', 'kettle', 'dresser', 'laundry_detergent', 'door', 'bathtub', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine., actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['spectacles', 'tablelamp', 'blender', 'food_ice_cream', 'toothbrush', 'knifeblock', 'hanger', 'dvd_player', 'alcohol', 'button', 'stovefan', 'stereo', 'homework', 'mousepad', 'powersocket', 'cup', 'food_cheese', 'bed', 'food_donut', 'tray', 'after_shave', 'doorjamb', 'lighter', 'dresser', 'home_office', 'light', 'bathroom_cabinet', 'dishwasher', 'soap', 'creditcard'] Task:Pet cat response:

{ I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'filing_cabinet', 'toilet', 'jelly', 'walllamp', 'drawing', 'orchid', 'needle', 'bathroom_counter', 'floor', 'folder', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'food_noodles', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'light_bulb', 'television', 'curtain', 'food_onion', 'chessboard', 'cupboard', 'door', 'napkin', 'instrument_guitar', 'table'] Task:Relax on sofa response: { thoughts : walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>'] } Scene_Objects:['microwave', 'freezer', 'ground_coffee', 'food_carrot', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'brush', 'ceilinglamp', 'mat', 'picture', 'clothes_socks', 'couch', 'microphone', 'food_orange', 'wall', 'powersocket', 'oven', 'tape', 'cup', 'keys', 'novel', 'food_food', 'check', 'mouthwash', 'curtain', 'pajamas', 'sink'] Task:Put groceries in Fridge response:

{ take every item from groceries bag and put them in the fridge }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'jelly', 'trashcan', 'food_egg', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'cleaning_solution', 'bookshelf', 'computer', 'shower', 'window', 'clothes_pants', 'dining_room', 'nightstand', 'pasta', 'oven', 'tape', 'food_cheese', 'bed', 'ice', 'coffee_pot', 'dishrack', 'sink', 'table', 'light', 'hands_both'] Task:Wash hands response: { thoughts : walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands, actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['sheets', 'glue', 'beer', 'chair', 'walllamp', 'detergent', 'knifeblock', 'floor', 'phone', 'keyboard', 'computer', 'toaster', 'stereo', 'dish_soap', 'food_noodles', 'wall', 'oven', 'cutting_board', 'box', 'coffe_maker', 'television', 'tray', 'centerpiece', 'towel_rack', 'mouse', 'door', 'maindoor', 'bag', 'spoon', 'dishwasher'] Task:Wash dishes with dishwasher response:

{ walk to kitchen, find the dishwasher, apply dish soap into vessels or dishwasher, wash the dishes with a dishwasher }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bills', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'shelf', 'cup', 'television', 'doorjamb', 'mouse', 'address_book', 'dresser', 'conditioner', 'bathtub', 'spoon', 'light', 'table', 'soap'] Task:Work response: { thoughts : Walk to home office. Walk to computer. Switch on computer. Open the address book., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <address_book>'] } Scene_Objects:['bathroom', 'ceilingfan', 'food_carrot', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'faucet', 'shower', 'window', 'wall', 'photoframe', 'novel', 'toilet_paper', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'clothes_dress', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'table', 'vase', 'soap', 'hands_both'] Task:Wash hands response:

{ I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth'] 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:['toilet', 'detergent', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'remote_control', 'button', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'clothes_socks', 'couch', 'wall', 'basket_for_clothes', 'light_bulb', 'television', 'razor', 'curtain', 'food_onion', 'towel_rack', 'coffee_pot', 'pencil', 'kitchen_counter', 'bag', 'table'] Task:Watch TV response:

{ turn on the tv }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'crayon', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'shampoo', 'keyboard', 'remote_control', 'thread', 'food_bacon', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'photoframe', 'bed', 'television', 'coffee_filter', 'curtain', 'mouse', 'table', 'light', 'laser_pointer'] Task:Watch TV response: { thoughts : I go into the living room. I find the remote. I turn on the tv. I sit on the couch and watch tv., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['filing_cabinet', 'chair', 'ceilingfan', 'knifeblock', 'orchid', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'computer', 'couch', 'broom', 'wall', 'coffe_maker', 'video_game_controller', 'wine', 'doorjamb', 'towel_rack', 'cards', 'pencil', 'kitchen_counter', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'board_game'] Task:Turn on light response:

{ Walk over to light switch. Turn on lights. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'plate', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'bathtub', 'light', 'table'] 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', 'scissors', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'food_kiwi', 'wall', 'oven', 'powersocket', 'cup', 'light_bulb', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'kitchen_counter', 'dresser', 'table', 'light'] Task:Watch TV response:

{ walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'measuring_cup', 'chair', 'freezer', 'drawing', 'floor', 'ceiling', 'character', 'toaster', 'plate', 'shower', 'floor_lamp', 'window', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'oven', 'toilet_paper', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'cd', 'laundry_detergent', 'door', 'light', 'table'] Task:Turn on light response: { thoughts : walk to wall, find light switch, turn on lights, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['blender', 'chair', 'dog', 'bathroom', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'computer', 'ceilinglamp', 'window', 'mousepad', 'couch', 'towel', 'wall', 'cup', 'television', 'curtain', 'doorjamb', 'dresser', 'cupboard', 'door', 'sink', 'light', 'table'] Task:Relax on sofa response:

{ I walk into the living room and turn on the light. I walk to the couch then sit on the couch. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'measuring_cup', 'microwave', 'toilet', 'dog', 'bathroom', 'knifeblock', 'bills', 'bathroom_counter', 'floor', 'table_cloth', 'toaster', 'plate', 'faucet', 'couch', 'towel', 'wall', 'bed', 'oven_mitts', 'water', 'shaving_cream', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Walk to kitchen. Find sink. Walk to sink. Find soap. Put soap on sink. Pour water into hands. Scrub soap. Wash water., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <sink>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>', '[SCRUB] <soap>', '[WASH] <water>'] } Scene_Objects:['juice', 'microwave', 'freezer', 'nail_polish', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'foundation', 'mousepad', 'food_jam', 'wall', 'nightstand', 'oven', 'cup', 'bed', 'food_food', 'check', 'television', 'wine', 'curtain', 'cupboard', 'door', 'bathroom_cabinet', 'home_office', 'dishwasher'] Task:Put groceries in Fridge response:

{ Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'bathroom', 'detergent', 'food_butter', 'longboard', 'bookshelf', 'stovefan', 'shower', 'pillow', 'towel', 'dining_room', 'nightstand', 'powersocket', 'toy', 'basket_for_clothes', 'newspaper', 'light_bulb', 'photoframe', 'food_food', 'coin', 'doorjamb', 'headset', 'shoes', 'hairbrush', 'cupboard', 'napkin', 'home_office'] Task:Listen to music response: { thoughts : I walk into my room and turn the radio on so that I can listen to music., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'drawing', 'floor', 'bookshelf', 'toaster', 'ceilinglamp', 'stereo', 'picture', 'window', 'couch', 'towel', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'kitchen_counter', 'cd', 'dresser', 'hairbrush', 'cupboard', 'home_office', 'table', 'bathroom_cabinet', 'light'] Task:Listen to music response:

{ Walk to living room. Walk to radio. Switch on the radio. Walk to sofa and sit on it. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'ground_coffee', 'walllamp', 'milk', 'knife', 'needle', 'wallshelf', 'hanger', 'bookshelf', 'clothes_jacket', 'bookmark', 'stovefan', 'mat', 'stereo', 'faucet', 'floor_lamp', 'oil', 'pillow', 'cup', 'curtain', 'after_shave', 'kitchen_counter', 'conditioner', 'sink', 'home_office', 'table', 'dishwasher', 'soap'] Task:Turn on light response: { thoughts : Walk over to light switch, flip the switch to the on position, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['food_bread', 'food_ice_cream', 'mop', 'microwave', 'detergent', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'candle', 'wall', 'bed', 'television', 'curtain', 'dresser', 'maindoor', 'table', 'dishwasher', 'vase', 'coffee'] Task:Watch TV response:

{ Walk to livingroom, sit on couch, grab remote and turn on tv. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'food_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: { thoughts : I grab the remote. I find the red power circular button. I point the remote at the television. I push button down and TV screen lights up. I sit and watch., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>'] } Scene_Objects:['fork', 'water_glass', 'pot', 'food_pizza', 'walllamp', 'trashcan', 'knife', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'computer', 'toaster', 'stovefan', 'plate', 'dish_soap', 'food_kiwi', 'wall', 'oven', 'food_cheese', 'coffe_maker', 'tray', 'kitchen_counter', 'cupboard', 'spoon', 'napkin', 'coffee_cup', 'dishwasher', 'soap'] Task:Wash dishes with dishwasher response:

{ I go to the kitchen and put plates, cutlery and glasses into the dishwasher, put the soap, close the machine and switch it on. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'juice', 'chair', 'jelly', 'nail_polish', 'cat', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'iron', 'clothes_pants', 'food_kiwi', 'wall', 'photoframe', 'food_food', 'water', 'wooden_spoon', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'teeth'] Task:Wash teeth response: { thoughts : Wash the teeth, actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[TURNTO] <water>', '[POINTAT] <water>', '[FIND] <teeth>', '[WASH] <teeth>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['dry_pasta', 'water_glass', 'pot', 'spectacles', 'walllamp', 'food_carrot', 'kitchen_cabinet', 'shampoo', 'longboard', 'computer', 'bookmark', 'mat', 'stereo', 'shower', 'homework', 'oil', 'clothes_socks', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'water', 'food_onion', 'headset', 'cd', 'dresser', 'controller', 'sink', 'napkin', 'clothes_skirt'] Task:Drink response:

{ Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'couch', 'candle', 'clothes_hat', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'curtain', 'diary', 'towel_rack', 'mouse', 'dishrack', 'home_office', 'table'] Task:Relax on sofa response: { thoughts : I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['glue', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'needle', 'floor', 'ceiling', 'phone', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'stereo', 'iron', 'stovefan', 'couch', 'pillow', 'wall', 'television', 'food_rice', 'curtain', 'doorjamb', 'bag', 'bathroom_cabinet', 'table', 'laser_pointer'] Task:Watch TV response:

{ Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'remote_control', 'purse', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'oven', 'mouthwash', 'television', 'wine', 'curtain', 'after_shave', 'towel_rack', 'maindoor', 'clothes_scarf', 'hairdryer', 'table', 'light', 'dishwasher'] Task:Watch TV response: { thoughts : SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['band-aids', 'ceilingfan', 'milk', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'folder', 'remote_control', 'button', 'piano_bench', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'foundation', 'mat', 'couch', 'dustpan', 'wall', 'nightstand', 'powersocket', 'coffee_table', 'television', 'tray', 'curtain', 'table', 'laser_pointer'] Task:Change TV channel response:

{ Go to the living room, find the remote control on the coffee table, and change the TV channel. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'orchid', 'knifeblock', 'hanger', 'floor', 'ceiling', 'dvd_player', 'stamp', 'bedroom', 'desk', 'keyboard', 'toaster', 'faucet', 'shower', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'home_office', 'table', 'light', 'dishwasher'] 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:['glue', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'bedroom', 'computer', 'ceilinglamp', 'deck_of_cards', 'iron', 'window', 'electric_shaver', 'couch', 'food_orange', 'wall', 'wall_clock', 'bed', 'novel', 'check', 'television', 'toothbrush_holder', 'wooden_spoon', 'after_shave', 'towel_rack', 'dresser', 'conditioner', 'maindoor', 'table', 'vase'] Task:Relax on sofa response:

{ Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'chair', 'jelly', 'bathroom', 'detergent', 'knife', 'floor', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'bowl', 'wall', 'cup', 'coffe_maker', 'food_food', 'after_shave', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'spoon', 'home_office', '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:['juice', 'toilet', 'chair', 'detergent', 'bathroom_counter', 'ceiling', 'character', 'desk', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'bench', 'powersocket', 'cup', 'bed', 'novel', 'razor', 'oven_mitts', 'curtain', 'after_shave', 'cd', 'headset', 'dresser', 'pajamas', 'bathroom_cabinet', 'tooth_paste'] Task:Pick up phone response:

{ I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'glue', 'tablelamp', 'microwave', 'walllamp', 'knife', 'knifeblock', 'longboard', 'floor', 'phone', 'computer', 'toaster', 'plate', 'shoe-shine_kit', 'dish_soap', 'mousepad', 'food_orange', 'wall', 'nightstand', 'oven', 'toy', 'newspaper', 'coffe_maker', 'tray', 'vacuum_cleaner', 'dresser', 'hairdryer', 'dishwasher', 'vase'] Task:Wash dishes with dishwasher response: { thoughts : Walk to the kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher., 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] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['dry_pasta', 'spectacles', 'food_pizza', 'tablelamp', 'blender', 'microwave', 'chair', 'cat', 'trashcan', 'dough', 'orchid', 'knifeblock', 'clothes_underwear', 'desk', 'food_bacon', 'shoe-shine_kit', 'balanceball', 'deck_of_cards', 'couch', 'towel', 'nightstand', 'oven', 'newspaper', 'keys', 'pencil', 'laundry_detergent', 'maindoor', 'bag', 'laser_pointer', 'shoe_rack'] Task:Drink response:

{ Drink water }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_carrot', 'longboard', 'ceiling', 'stamp', 'food_cake', 'stovefan', 'mat', 'oil', 'food_peanut_butter', 'dining_room', 'broom', 'pasta', 'basket_for_clothes', 'bed', 'coffe_maker', 'television', 'razor', 'tray', 'after_shave', 'mouse', 'laundry_detergent', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'dishwasher', 'laser_pointer', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: { thoughts : Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on., actions : ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'bedroom', 'mop_bucket', 'faucet', 'balanceball', 'towel', 'wall', 'photoframe', 'keys', 'novel', 'razor', 'television', 'diary', 'kettle', 'coffee_pot', 'cd', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both', 'shoe_rack'] Task:Wash hands response:

{ I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'water_glass', 'food_salt', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'stovefan', 'mat', 'iron', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'keys', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'tooth_paste'] Task:Drink response: { thoughts : walk to kitchen ,find fridge ,open fridge ,find water glass , drink from water glass, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['tablelamp', 'walllamp', 'drawing', 'knife', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'shower', 'food_noodles', 'oil', 'dining_room', 'wall', 'oven', 'photoframe', 'newspaper', 'check', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'cards', 'pencil', 'shoes', 'cupboard', 'controller', 'door', 'maindoor', 'light', 'teeth'] Task:Turn on light response:

{ flip the switch and turn on the lights }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'phone', 'ceiling', 'character', 'desk', 'bookmark', 'toaster', 'stovefan', 'shoe-shine_kit', 'shower', 'window', 'wall', 'pasta', 'oven', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'coin', 'curtain', 'doorjamb', 'cards', 'towel_rack', 'kitchen_counter', 'chessboard', 'napkin', 'bathroom_cabinet', 'light'] 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:['freezer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'stamp', 'remote_control', 'computer', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'shoe-shine_kit', 'shower', 'mousepad', 'deck_of_cards', 'couch', 'food_kiwi', 'wall', 'cup', 'television', 'ice', 'curtain', 'conditioner', 'door', 'table', 'vase', 'tooth_paste'] Task:Watch TV response:

{ walk to living room ,find television , switch on remote control }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['jelly', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office'] Task:Turn on light response: { thoughts : I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['fork', 'walllamp', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'shampoo', 'dvd_player', 'character', 'keyboard', 'mop_bucket', 'toaster', 'dining_room', 'wall', 'oven', 'cutting_board', 'light_bulb', 'coffe_maker', 'food_food', 'razor', 'tray', 'wooden_spoon', 'pencil', 'dishrack', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'colander', 'laser_pointer'] Task:Wash dishes by hand response:

{ walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game'] Task:Write school paper response: { thoughts : Writing and drafting a paper for class work, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>'] } Scene_Objects:['sponge', 'pot', 'juice', 'cd_player', 'toilet', 'freezer', 'trashcan', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'toaster', 'laptop', 'ceilinglamp', 'plate', 'homework', 'dining_room', 'broom', 'bench', 'tape', 'keys', 'coffe_maker', 'television', 'towel_rack', 'hair', 'cupboard', 'maindoor', 'sink', 'clothes_skirt', 'vase'] Task:Listen to music response:

{ I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'picture', 'mousepad', 'wall', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'cards', 'mouse', 'door', 'light', 'printing_paper'] Task:Add paper to printer response: { thoughts : Take a stack of paper, about 25 pieces. Place carefully in the paper tray., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[WALK] <fax_machine>', '[PUTBACK] <printing_paper> <fax_machine>'] } Scene_Objects:['nail_polish', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'faucet', 'couch', 'dining_room', 'wall', 'nightstand', 'bench', 'wall_clock', 'photoframe', 'coffe_maker', 'food_food', 'lighter', 'doorjamb', 'towel_rack', 'diary', 'shoes', 'comb', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'dirt', 'hands_both'] Task:Wash hands response:

{ Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tablelamp', 'chair', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'tape', 'photoframe', 'coffee_table', 'television', 'toothbrush_holder', 'razor', 'curtain', 'dresser', 'pajamas', '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:['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:

{ I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'table', 'coffee'] Task:Call family member with skype application response: { thoughts : Sit down on desk chair located in front of computer. Turn on computer. Log in to skype application. Locate individual to call on contacts list. Press the call button with computer mouse., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>'] } Scene_Objects:['sponge', 'filing_cabinet', 'tea', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'toothbrush', 'orchid', 'needle', 'shampoo', 'tea_bag', 'alcohol', 'mat', 'shower', 'mousepad', 'towel', 'wall', 'cup', 'bed', 'light_bulb', 'coffe_maker', 'wooden_spoon', 'shoes', 'home_office', 'vase', 'soap'] Task:Pick up phone response:

{ Walk into the living room, walk over to phone, grab the phone, put it to your ear . }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tea', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'alcohol', 'mat', 'faucet', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'bench', 'coffee_filter', 'ice', 'paper_towel', 'conditioner', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <hands_both>'] } Scene_Objects:['filing_cabinet', 'shoe_rack', 'food_salt', 'mop', 'microwave', 'dog', 'jelly', 'walllamp', 'drawing', 'needle', 'food_egg', 'desk', 'stamp', 'computer', 'ceilinglamp', 'window', 'mousepad', 'food_orange', 'pillow', 'bench', 'cup', 'oven_mitts', 'wooden_spoon', 'pencil', 'dresser', 'maindoor', 'bag', 'table', 'instrument_violin', 'creditcard'] Task:Listen to music response:

{ go to radio. run on radio. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['detergent', 'trashcan', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'bookshelf', 'toaster', 'ceilinglamp', 'deck_of_cards', 'faucet', 'balanceball', 'shower', 'mousepad', 'wall', 'nightstand', 'photoframe', 'light_bulb', 'novel', 'food_food', 'water', 'kitchen_counter', 'sink', 'bag', 'bathroom_cabinet', 'napkin', 'soap', 'hands_both'] Task:Wash hands response:

{ I turn on faucet. I hold out my hands. I get my hands wet. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'knifeblock', 'needle', 'cpuscreen', 'floor', 'character', 'keyboard', 'table_cloth', 'plate', 'faucet', 'window', 'oil', 'mousepad', 'pillow', 'wall', 'oven', 'food_cheese', 'bed', 'tray', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'light'] Task:Wash dishes by hand response: { thoughts : Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>'] } Scene_Objects:['dry_pasta', 'bathroom', 'ceilingfan', 'knife', 'drawing', 'needle', 'knifeblock', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'phone', 'piano_bench', 'faucet', 'window', 'teeth', 'clothes_pants', 'wall', 'photoframe', 'check', 'oven_mitts', 'tray', 'pencil', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', 'soap', 'hands_both'] Task:Wash hands response:

{ Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'blow_dryer', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'dishwasher'] Task:Write an email response: { thoughts : Turn on PC and log onto email account. Type email and send it. Switch off computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHOFF] <computer>'] } Scene_Objects:['sheets', 'pot', 'ceilingfan', 'drawing', 'cpuscreen', 'phone', 'desk', 'keyboard', 'mail', 'mat', 'window', 'towel', 'dining_room', 'wall', 'pasta', 'oven', 'cup', 'check', 'curtain', 'rag', 'doorjamb', 'cards', 'cupboard', 'conditioner', 'clothes_scarf', 'napkin', 'home_office', 'vase', 'soap', 'laser_pointer'] Task:Listen to music response:

{ I go to my bedroom, and then I switch on the radio }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'microwave', 'chair', 'dog', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'laptop', 'mat', 'mousepad', 'closetdrawer', 'couch', 'wall', 'powersocket', 'coffe_maker', 'wine', 'doorjamb', 'kettle', 'mouse', 'pencil', 'dresser', 'light'] Task:Work response: { thoughts : I walk in. Turn on the light. Set in my chair. Turn on lap top. And start to work., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[GRAB] <laptop>', '[SWITCHON] <laptop>'] } 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:

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

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'pot', 'food_salt', 'mop', 'freezer', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'purse', 'button', 'piano_bench', 'food_bacon', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'form', 'wall', 'bench', 'food_food', 'television', 'water', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'maindoor', 'table'] Task:Drink response: { thoughts : I need to go to Kitchen. Get a cup. Fill cup. Drink, actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['chair', 'food_butter', 'ceilingfan', 'drawing', 'food_egg', 'floor', 'keyboard', 'purse', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'food_food', 'television', 'oven_mitts', 'tray', 'curtain', 'diary', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'table', 'light', 'board_game', 'clothes_shirt', 'shoe_rack'] Task:Relax on sofa response:

{ Go to living room. Find sofa. Sit on sofa. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'shoe-shine_kit', 'faucet', 'couch', 'form', 'wall', 'bench', 'toy', 'cup', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap'] Task:Wash hands response: { thoughts : walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,, actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <soap>'] } Scene_Objects:['pot', 'beer', 'toilet', 'jelly', 'milk', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'faucet', 'balanceball', 'mousepad', 'towel', 'dining_room', 'wall', 'photoframe', 'light_bulb', 'towel_rack', 'dresser', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'home_office', 'light', 'soap', 'hands_both'] Task:Wash hands response:

{ I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'tablelamp', 'food_salt', 'cd_player', 'chair', 'freezer', 'bathroom', 'food_carrot', 'orchid', 'knifeblock', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'remote_control', 'computer', 'window', 'mousepad', 'wall', 'nightstand', 'light_bulb', 'check', 'food_onion', 'curtain', 'mouse', 'door', 'light', 'tooth_paste'] Task:Listen to music response: { thoughts : Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music., actions : ['[WALK] <cd_player>', '[SWITCHON] <cd_player>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <remote_control>', '[TOUCH] <remote_control>'] } Scene_Objects:['glue', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'bench', 'food_food', 'doorjamb', 'kettle', 'mouse', 'pencil', 'headset', 'light'] Task:Browse internet response:

{ go to the office, turn computer on, open an browser or any application to open any website. }

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

{ Switch on computer, Use keybord and mouse to open e-mail provider, type requested e-mail, click send, close e-mail provider, turn off computer }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin'] Task:Go to toilet response: { thoughts : Walk to the bathroom. Find the toilet. Lift the top of the toilet. Sit on the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>'] } Scene_Objects:['spectacles', 'sheets', 'chair', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'stereo', 'window', 'clothes_hat', 'wall', 'nightstand', 'bench', 'box', 'food_cheese', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'hair', 'door', 'light'] Task:Turn on light response:

{ Walk to living room. Find light switch. Switch on light switch. }

You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'faucet', 'picture', 'window', 'dustpan', 'towel', 'wall', 'nightstand', 'photoframe', 'keys', 'toothbrush_holder', 'food_donut', 'mouse', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'vase', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Cleaning hands, actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['sheets', 'pot', 'toilet', 'blow_dryer', 'bathroom', 'trashcan', 'orchid', 'dvd_player', 'keyboard', 'mail', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'picture', 'window', 'couch', 'clothes_pants', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'television', 'food_onion', 'coffee_pot', 'sink', 'bathroom_cabinet', 'light', 'dishwasher', 'vase'] Task:Wash dishes with dishwasher response:

{ grab the vesseles and wash }