Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'computer', 'stovefan', 'tvstand', 'faucet', 'shower', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'television', 'tray', 'lighter', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Walk to the sink, turn on the faucet, put soap on hands, rub hands together under the water, rinse off hands, turn off faucet, dry hands,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[WALK] <sink>', '[FIND] <soap>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'pencil', 'bathtub', 'home_office', 'table']  Task:Browse internet  response:

{  For browsing internet walk to home office. Find Computer. Walk to Computer. Find Chair. Sit in a chair and switch on computer. Connect with internet and browse the net. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'bookmark', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'cup', 'bed', 'television', 'coffee_filter', 'mouse', 'door']  Task:Answer emails  response:  {       thoughts : Open email application.  Open new emails.  Respond accordingly,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>']  }     Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'toaster', 'tvstand', 'faucet', 'mousepad', 'towel', 'wall', 'wall_clock', 'bench', 'powersocket', 'nightstand', 'bed', 'toilet_paper', 'television', 'wine', 'curtain', 'doorjamb', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'clothes_skirt', 'soap']  Task:Wash hands  response:

{  I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'stereo', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'food_donut', 'towel_rack', 'mouse', 'shoes', 'dishrack', 'sink', 'spoon', 'light', 'coffee']  Task:Go to toilet  response:  {       thoughts : Walk to bathroom, find toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>']  }     Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'dining_room', 'wall', 'oven', 'powersocket', 'food_food', 'coffe_maker', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'bathroom_cabinet']  Task:Put groceries in Fridge  response:

{  go to the kitchen and put the groceries in the fridge }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf']  Task:Watch TV  response:  {       thoughts : Sit and watch the television,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'jelly', 'freezer', 'cpuscreen', 'floor', 'phone', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'foundation', 'clothes_socks', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'photoframe', 'tray', 'curtain', 'kitchen_counter', 'sink', 'clothes_scarf']  Task:Go to toilet  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'chair', 'walllamp', 'drawing', 'needle', 'wallshelf', 'bills', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'tooth_paste']  Task:Watch TV  response:  {       thoughts : I enter the living room and sit on the couch. I grab the remote and turn on the TV.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'water_glass', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'wall', 'powersocket', 'oven', 'food_food', 'check', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light']  Task:Drink  response:

{  walk to kitchen ,find fridge ,open fridge ,find water  glass , drink from water glass }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['measuring_cup', 'detergent', 'orchid', 'clothes_underwear', 'floor', 'character', 'button', 'stovefan', 'ceilinglamp', 'toaster', 'homework', 'mousepad', 'couch', 'dustpan', 'microphone', 'form', 'towel', 'powersocket', 'basket_for_clothes', 'bed', 'light_bulb', 'oven_mitts', 'tray', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'colander', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. Turn on machine.,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[PUTOBJBACK] <laundry_detergent>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'character', 'bedroom', 'keyboard', 'table_cloth', 'toaster', 'stovefan', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'wall', 'oven', 'lighter', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'home_office']  Task:Go to toilet  response:

{  Travel through the house and locate the bathroom, and proceed to the toilet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'measuring_cup', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'cup', 'photoframe', 'novel', 'check', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light', 'table']  Task:Read book  response:  {       thoughts : I go to the book case, I select a book, I go back and sit down, then I read.,       actions : ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>']  }     Scene_Objects:['fork', 'freezer', 'walllamp', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'ceiling', 'character', 'keyboard', 'food_cake', 'computer', 'stovefan', 'mat', 'plate', 'window', 'closetdrawer', 'wall', 'powersocket', 'tape', 'television', 'tray', 'curtain', 'towel_rack', 'sink', 'spoon', 'bathtub', 'table', 'bathroom_cabinet']  Task:Set up table  response:

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


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

{  Walk to kitchen. Open fridge. Put groceries in fridge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Work  response:  {       thoughts : I sit at my desk and work on the computer.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'toilet', 'chair', 'freezer', 'drawing', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'shower', 'window', 'wall', 'oven', 'powersocket', 'cup', 'coffe_maker', 'coffee_filter', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dirt', 'coffee']  Task:Make coffee  response:

{  Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'cat', 'floor', 'character', 'stamp', 'table_cloth', 'piano_bench', 'mat', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'cup', 'mouthwash', 'television', 'coffee_filter', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'food_steak', 'bathtub', 'bag', 'table']  Task:Pet cat  response:  {       thoughts : I see my cat on the couch so I walk over, sit down and pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']  }     Scene_Objects:['ground_coffee', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'toaster', 'mat', 'faucet', 'electric_shaver', 'towel', 'pillow', 'wall', 'wall_clock', 'bench', 'bed', 'coffe_maker', 'curtain', 'doorjamb', 'dresser', 'sink', 'bag', 'bathroom_cabinet', 'table', 'soap', 'hands_both']  Task:Wash hands  response:

{  Go to bathroom, turn on faucet, wet hands, apply soap, rub hands, rinse hands, turn off faucet, dry hands }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'filing_cabinet', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'floor', 'ceiling', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'powersocket', 'wall_clock', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'razor', 'coffee_filter', 'doorjamb', 'hairbrush', 'door', 'home_office', 'light', 'soap']  Task:Put away groceries  response:  {       thoughts : Place groceries in refrigerator from shopping at the grocery store.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'brush', 'ceilinglamp', 'tvstand', 'plate', 'mousepad', 'closetdrawer', 'dustpan', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'table']  Task:Write an email  response:

{  walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'blender', 'crayon', 'walllamp', 'ceilingfan', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'stovefan', 'wall', 'powersocket', 'oven', 'bench', 'cutting_board', 'food_rice', 'doorjamb', 'cd', 'door', 'light', 'vase', 'creditcard']  Task:Turn on light  response:  {       thoughts : I enter the bedroom and find the light. Then I turn it on.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'closetdrawer', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'wall_clock', 'photoframe', 'food_food', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'home_office']  Task:Put groceries in Fridge  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_salt', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'phone', 'bookshelf', 'computer', 'toaster', 'tvstand', 'stereo', 'closetdrawer', 'food_peanut_butter', 'clothes_pants', 'form', 'wall', 'oven', 'cup', 'bed', 'mouthwash', 'rag', 'towel_rack', 'kitchen_counter', 'pajamas', 'food_steak', 'door', 'napkin', 'bathroom_cabinet']  Task:Listen to music  response:  {       thoughts : Find the playback device you want to listen to. turn on. press play. enjoyu music.,       actions : ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']  }     Scene_Objects:['pot', 'tablelamp', 'microwave', 'toothbrush', 'drawing', 'orchid', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'pillow', 'wall', 'pasta', 'oven', 'coffe_maker', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'sauce_pan', 'cupboard']  Task:Cook some food  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'walllamp', '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:  {       thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer,       actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']  }     Scene_Objects:['food_salt', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'needle', 'floor', 'ceiling', 'computer', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'oven', 'cup', 'photoframe', 'toilet_paper', 'coffe_maker', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'light', 'creditcard']  Task:Go to toilet  response:

{  i go to the bathroom. I find the toilet }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'band-aids', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'stamp', 'desk', 'cleaning_solution', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'tvstand', 'window', 'couch', 'wall', 'nightstand', 'coffe_maker', 'television', 'mirror', 'after_shave', 'paper_towel', 'clothes_dress', 'sink', 'bag', 'bathroom_cabinet', 'dishwasher', 'laser_pointer']  Task:Clean mirror  response:  {       thoughts : First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_cake', 'stovefan', 'faucet', 'closetdrawer', 'couch', 'form', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'tray', 'doorjamb', 'cards', 'kitchen_counter', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'light', 'teeth']  Task:Wash teeth  response:

{  Walk to bathroom.  Find mouthwash or turn on water.  Put mouthwash or water in mouth.  Swish around for 30 seconds.  Spit mouthwash out. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'ceilinglamp', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'novel', 'check', 'tray', 'doorjamb', 'towel_rack', 'console', 'pencil', 'light']  Task:Read book  response:  {       thoughts : Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,       actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['microwave', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'computer', 'stovefan', 'tvstand', 'faucet', 'shower', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'television', 'tray', 'lighter', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:

{  Walk to the sink, turn on the faucet, put soap on hands, rub hands together under the water, rinse off hands, turn off faucet, dry hands }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'ground_coffee', 'detergent', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'bookshelf', 'envelope', 'mat', 'shower', 'faucet', 'homework', 'mousepad', 'wall', 'toy', 'photoframe', 'check', 'coffee_filter', 'food_onion', 'shaving_cream', 'cards', 'mouse', 'dresser', 'hairbrush', 'door', 'soap', 'scrabble']  Task:Clean  response:  {       thoughts : Enter inside kid's room, begin picking up toys from the floor and putting them in a toy box, leave once once.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'bedroom', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'stereo', 'closetdrawer', 'couch', 'broom', 'wall', 'wall_clock', 'photoframe', 'bed', 'television', 'mouse', 'kitchen_counter', 'comb', 'dresser', 'sink', 'spoon', 'clothes_skirt']  Task:Go to toilet  response:

{  I walk into the bath room and go to the toilet }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'mop', 'chair', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'phone', 'folder', 'desk', 'bookshelf', 'remote_control', 'computer', 'toaster', 'stovefan', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'photoframe', 'novel', 'television', 'coin', 'coffee_filter', 'doorjamb', 'shoes', 'cupboard', 'sink', 'light']  Task:Watch TV  response:  {       thoughts : 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.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']  }     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:

{  Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'door', 'light', 'table']  Task:Vacuum  response:  {       thoughts : Keep my keyboard vacuumed and free of debris.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']  }     Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'ceilinglamp', 'window', 'floor_lamp', 'couch', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'bathroom_cabinet', 'coffee']  Task:Turn on light  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'toilet', 'freezer', 'detergent', 'drawing', 'knife', 'wallshelf', 'dvd_player', 'character', 'bookshelf', 'plate', 'shower', 'tvstand', 'dish_soap', 'closetdrawer', 'pillow', 'food_kiwi', 'nightstand', 'powersocket', 'cutting_board', 'photoframe', 'wooden_spoon', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'spoon', 'light', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <dishrack>', '[PUTBACK] <fork> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishrack>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['water_glass', 'filing_cabinet', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'tvstand', 'wall', 'oven', 'box', 'food_food', 'coffe_maker', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub']  Task:Drink  response:

{  I enter the kitchen and grab a waterglass from the cupboard. I open the fridge and grap some water. I pour the water into the cup and drink it. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'dining_room', 'wall', 'powersocket', 'oven', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table']  Task:Turn on computer  response:  {       thoughts : Push power button.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'table_cloth', 'tvstand', 'shower', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'television', 'tray', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'board_game']  Task:Turn on light  response:

{  walk into living room, walk to light, turn on light switch. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['juice', 'nail_polish', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'stovefan', 'mat', 'plate', 'faucet', 'picture', 'tvstand', 'dish_soap', 'food_noodles', 'pillow', 'food_kiwi', 'wall', 'wall_clock', 'oven', 'tape', 'shelf', 'coin', 'tray', 'curtain', 'sink', 'napkin', 'bathroom_cabinet']  Task:Wash dishes by hand  response:  {       thoughts : Make some dish water, grab a dish rag, put dishes in dish water and wash.,       actions : ['[RUN] <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[PUTBACK] <dish_soap> <plate>', '[RINSE] <dish_soap>', '[FIND] <plate>', '[WASH] <plate>']  }     Scene_Objects:['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:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'food_bread', 'walllamp', 'bathroom', 'cpuscreen', 'kitchen_cabinet', 'floor', 'tea_bag', 'toaster', 'mat', 'stereo', 'balanceball', 'dish_soap', 'towel', 'wall', 'oven', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'check', 'coin', 'food_donut', 'tray', 'doorjamb', 'towel_rack', 'sink', 'dishwasher', 'vase', 'clothes_shirt']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTIN] <dish_soap> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['pot', 'walllamp', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'toaster', 'window', 'oil', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'coffe_maker', 'television', 'curtain', 'mouse', 'home_office', 'table', 'coffee']  Task:Pet cat  response:

{  I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin']  Task:Wash dishes with dishwasher  response:  {       thoughts : I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'scissors', 'tablelamp', 'microwave', 'chair', 'bathroom', 'trashcan', 'drawing', 'clothes_underwear', 'phone', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'candle', 'clothes_pants', 'wall', 'photoframe', 'curtain', 'mouse', 'cupboard', 'clothes_dress', 'soap', 'tooth_paste', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  I need to get the dirty clothes basket.  Walk to bathroom.  Put all the clothes in washing machine.  Add soap.  Turn on machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Work  response:  {       thoughts : Using desktop computer in home office,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['food_ice_cream', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'window', 'wall', 'wall_clock', 'powersocket', 'box', 'cup', 'bed', 'video_game_controller', 'television', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'teeth']  Task:Pick up phone  response:

{  I walk over to the phone and pick it up. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'blow_dryer', 'cat', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'shower', 'window', 'couch', 'wall', 'powersocket', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light', 'table', 'dishwasher']  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:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'cat', 'trashcan', 'drawing', 'wallshelf', 'floor', 'desk', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cup', 'food_food', 'television', 'curtain', 'towel_rack', 'mouse', 'sink', 'bathroom_cabinet', 'table', 'scrabble']  Task:Pet cat  response:

{  I walk to the living room.  I locate the cat.  I walk to the couch and sit down beside the cat.  I pet the cat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'laptop', 'plate', 'stovefan', 'shower', 'dish_soap', 'wall', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher', 'coffee']  Task:Wash dishes with dishwasher  response:  {       thoughts : Put the dishes on dinner table in the dishwasher and wash them,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[WALK] <table>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <dishwasher>', '[PUTBACK] <pot> <dishwasher>', '[CLOSE] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'ceilinglamp', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'novel', 'check', 'tray', 'doorjamb', 'towel_rack', 'console', 'pencil', 'light']  Task:Read book  response:

{  Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink']  Task:Use computer  response:  {       thoughts : Browse the internet,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'freezer', 'bathroom', 'nail_polish', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'faucet', 'picture', 'powersocket', 'oven', 'bed', 'photoframe', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'food_steak', 'sink', 'door', 'table', 'instrument_violin']  Task:Pick up phone  response:

{  walk to living room, walk to the phone reach for the phone and pick up the phone. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'knifeblock', 'wallshelf', 'folder', 'desk', 'stamp', 'bedroom', 'computer', 'toaster', 'mat', 'floor_lamp', 'dustpan', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'check', 'curtain', 'console', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'dishwasher']  Task:Turn on light  response:  {       thoughts : I go home and it's dark so I can not see anything,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'nail_polish', 'trashcan', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'television', 'curtain', 'mouse', 'bathtub', 'home_office', 'table', 'bathroom_cabinet']  Task:Relax on sofa  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']  Task:Pet cat  response:  {       thoughts : First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'food_egg', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'bench', 'box', 'television', 'curtain', 'towel_rack', 'table', 'light']  Task:Change TV channel  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'freezer', 'walllamp', 'food_butter', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'faucet', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'bed', 'coffee_table', 'television', 'doorjamb', 'pencil', 'dresser', 'clothes_dress', 'door', 'table', 'dishwasher']  Task:Change TV channel  response:  {       thoughts : Walk to the living room and look at the coffee table. Grab the remote control and turn to the television and point the remote control. Put back the remote control.,       actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <coffee_table>', '[TURNTO] <coffee_table>', '[LOOKAT] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUTOBJBACK] <remote_control>']  }     Scene_Objects:['scissors', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'couch', 'pillow', 'wall', 'television', 'wine', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'cupboard', 'controller', 'sink', 'table', 'light']  Task:Change TV channel  response:

{  Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'scissors', 'chair', 'freezer', 'knifeblock', 'clothes_underwear', 'bookshelf', 'mop_bucket', 'stovefan', 'shower', 'window', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'powersocket', 'photoframe', 'keys', 'bed', 'towel_rack', 'cd', 'dresser', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'board_game']  Task:Pet cat  response:  {       thoughts : Find the cat.  Pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'toaster', 'mat', 'shower', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'food_food', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'napkin']  Task:Put groceries in Fridge  response:

{  Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'chair', 'milk', 'bathroom_counter', 'floor', 'bookshelf', 'table_cloth', 'toaster', 'tvstand', 'shower', 'foundation', 'pillow', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'coffe_maker', 'food_onion', 'kitchen_counter', 'dishrack', 'cupboard', 'clothes_dress', 'sink', 'bag', 'table', 'dishwasher', 'dirt', 'shoe_rack']  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_bread', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'phone', 'desk', 'bookshelf', 'toaster', 'ceilinglamp', 'shower', 'faucet', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'wall', 'bed', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both']  Task:Wash hands  response:

{  walk to bathroom, look at the water, wash hands }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table']  Task:Change TV channel  response:  {       thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['microwave', 'chair', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mousepad', 'bowl', 'wall', 'newspaper', 'bed', 'novel', 'curtain', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'light', 'table']  Task:Browse internet  response:

{  go to the room, sit in the chair, turn on the computer, look for the news }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar']  Task:Turn on light  response:  {       thoughts : I walk into the living room and then I walk to the light switch in there and turn the lights on,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'toilet', 'trashcan', 'hanger', 'bathroom_counter', 'bedroom', 'keyboard', 'stovefan', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'lighter', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'light', 'instrument_guitar', 'teeth']  Task:Set up table  response:

{  Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'freezer', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'toaster', 'window', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'wall_clock', 'television', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'clothes_shirt']  Task:Organize closet  response:  {       thoughts : Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear.,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[CLOSE] <dresser>', '[WALK] <basket_for_clothes>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>']  }     Scene_Objects:['sheets', 'tablelamp', 'microwave', 'chair', 'bathroom', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'phone', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'wall_clock', 'bench', 'powersocket', 'cup', 'bed', 'food_food', 'television', 'mouse', 'pencil', 'bathroom_cabinet', 'table']  Task:Set up table  response:

{  walk to entrance hall. find a table. pull table. walk to living rook. push table. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'headset', 'dresser', 'bathroom_cabinet', 'soap']  Task:Change TV channel  response:  {       thoughts : I find the remote then I push the button to switch it to the tv channel i want to watch,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUSH] <remote_control>']  }     Scene_Objects:['fork', 'tablelamp', 'chair', 'walllamp', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'toaster', 'plate', 'dish_soap', 'mousepad', 'closetdrawer', 'oven', 'powersocket', 'bed', 'photoframe', 'check', 'water', 'cards', 'hairbrush', 'sink', 'bathroom_cabinet', 'light']  Task:Wash dishes by hand  response:

{  walk to kitchen, fins soap, arrange dishes, wash dishes }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'wooden_spoon', 'curtain', 'diary', 'dresser', 'cupboard', 'clothes_dress', 'table', 'light']  Task:Watch TV  response:  {       thoughts : You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you watch television.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[WATCH] <television>']  }     Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'freezer', 'trashcan', 'dough', 'cpuscreen', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'mousepad', 'closetdrawer', 'dining_room', 'wall_clock', 'bench', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'clothes_dress', 'sink', 'home_office', 'dishwasher', 'coffee']  Task:Wash dishes with dishwasher  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'crayon', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'mail', 'food_bacon', 'clothes_jacket', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'food_jam', 'nightstand', 'powersocket', 'novel', 'food_food', 'centerpiece', 'diary', 'console', 'cupboard', 'bathroom_cabinet', 'table', 'light']  Task:Pick up phone  response:  {       thoughts : Pick up the ringing phone,       actions : ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[POINTAT] <table>', '[FIND] <phone>', '[GRAB] <phone>', '[PUTOBJBACK] <phone>']  }     Scene_Objects:['microwave', 'toilet', 'chair', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'floor_lamp', 'mousepad', 'couch', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'doorjamb', 'cd', 'door', 'bathtub', 'home_office', 'light']  Task:Turn on light  response:

{  walk to wall, find light switch, turn on lights }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'orchid', 'drawing', 'wallshelf', 'floor', 'phone', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'mousepad', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'bed', 'novel', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light', 'laser_pointer']  Task:Read book  response:  {       thoughts : Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book.,       actions : ['[WALK] <bedroom>', '[WALK] <nightstand>', '[FIND] <nightstand>', '[OPEN] <nightstand>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[TURNTO] <bed>', '[SIT] <bed>', '[READ] <novel>']  }     Scene_Objects:['freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'bookshelf', 'clothes_jacket', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'shower', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'table']  Task:Relax on sofa  response:

{  I walk to the living room and find the sofa. I sit on the sofa and get comfortable. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'stamp', 'bedroom', 'stovefan', 'toaster', 'plate', 'faucet', 'shower', 'dish_soap', 'food_jam', 'towel', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'ice', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'orchid', 'floor', 'desk', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'pillow', 'nightstand', 'wall_clock', 'oven', 'wall', 'coffe_maker', 'mouthwash', 'television', 'tray', 'towel_rack', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light']  Task:Pick up phone  response:

{  walk to phone, grab phone, pick up phone, put to ear }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'mouse', 'hairdryer', 'door', 'sink', 'home_office', 'table']  Task:Work  response:  {       thoughts : Using desktop computer in home office,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['tea', 'toilet', 'dog', 'walllamp', 'trashcan', 'orchid', 'drawing', 'bedroom', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'bench', 'basket_for_clothes', 'tray', 'wooden_spoon', 'kitchen_counter', 'clothes_dress', 'hairdryer', 'sink', 'light', 'table', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'food_bread', 'crayon', 'tea', 'freezer', 'walllamp', 'bathroom', 'detergent', 'blow_dryer', 'drawing', 'floor', 'desk', 'thread', 'mop_bucket', 'tvstand', 'towel', 'wall', 'toy', 'cup', 'check', 'razor', 'food_donut', 'wine', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'laundry_detergent', 'light', 'soap']  Task:Vacuum  response:  {       thoughts : Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor.,       actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <dining_room>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <home_office>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <filing_cabinet>', '[PUTBACK] <vacuum_cleaner> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'window', 'mat', 'closetdrawer', 'wall', 'wall_clock', 'bed', 'photoframe', 'doorjamb', 'console', 'kitchen_counter', 'door', 'hairdryer', 'sink', 'light', 'clothes_skirt']  Task:Turn on light  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'food_ice_cream', 'toothbrush', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'alcohol', 'brush', 'shoe-shine_kit', 'faucet', 'mousepad', 'closetdrawer', 'candle', 'clothes_pants', 'wall', 'standingmirror', 'food_food', 'television', 'tray', 'coffee_pot', 'towel_rack', 'dresser', 'bathtub', 'bathroom_cabinet', 'vase']  Task:Dust  response:  {       thoughts : Using soft brush, carefully dust both Indonesian wedding doll statues.,       actions : ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <brush>', '[GRAB] <brush>', '[CLOSE] <dresser>']  }     Scene_Objects:['chair', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'dvd_player', 'bookshelf', 'remote_control', 'button', 'piano_bench', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'wall_clock', 'bench', 'oven', 'nightstand', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'cd', 'door', 'table', 'light']  Task:Change TV channel  response:

{  Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'freezer', 'blow_dryer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'shoe-shine_kit', 'couch', 'microphone', 'food_jam', 'wall', 'coffe_maker', 'check', 'television', 'curtain', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'colander', 'tooth_paste']  Task:Watch TV  response:  {       thoughts : Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['sponge', 'filing_cabinet', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'table_cloth', 'toaster', 'stovefan', 'tvstand', 'shower', 'faucet', 'closetdrawer', 'nightstand', 'wall', 'bench', 'coffe_maker', 'check', 'television', 'tray', 'pencil', 'shoes', 'sink', 'bathtub', 'light']  Task:Listen to music  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', '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:  {       thoughts : go to radio. run on radio.,       actions : ['[WALK] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['sponge', 'pot', 'scissors', 'tea', 'freezer', 'walllamp', 'wallshelf', 'hanger', 'kitchen_cabinet', 'floor', 'bathroom_counter', 'bedroom', 'bookshelf', 'ceilinglamp', 'dish_soap', 'dining_room', 'nightstand', 'wall_clock', 'bed', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'door', 'clothes_scarf', 'bathtub', 'light', 'dishwasher', 'table', 'shoe_rack']  Task:Wash dishes with dishwasher  response:

{  I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'keyboard', 'mail', 'mat', 'faucet', 'wall', 'nightstand', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'curtain', 'doorjamb', 'diary', 'cupboard', 'door', 'sink', 'instrument_guitar']  Task:Read book  response:  {       thoughts : Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.,       actions : ['[WALK] <bedroom>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'oven', 'box', 'television', 'ice', 'curtain', 'pencil', 'kitchen_counter', 'door', 'hairdryer', 'instrument_guitar', 'table']  Task:Relax on sofa  response:

{  allow sofa to support weight in order to decrease gravity induced entropy }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'beer', 'toilet', 'jelly', 'freezer', 'blow_dryer', 'detergent', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'mail', 'computer', 'bookmark', 'stereo', 'window', 'couch', 'microphone', 'check', 'television', 'rag', 'pencil', 'controller', 'dishwasher']  Task:Pet cat  response:  {       thoughts : Pet Cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']  Task:Pet cat  response:

{  First I need to find the cat in the living room. Then I walk over to the cat and pet it gently. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee']  Task:Browse internet  response:  {       thoughts : The task is browse and surf on the internet regarding a particular topic,       actions : ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']  }     Scene_Objects:['tablelamp', 'crayon', 'chair', 'walllamp', 'toothbrush', 'wallshelf', 'dvd_player', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'mousepad', 'couch', 'form', 'pillow', 'bowl', 'nightstand', 'wall_clock', 'bench', 'oven', 'powersocket', 'clothes_gloves', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'hairdryer', 'bathtub', 'home_office', 'table']  Task:Write an email  response:

{  I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'band-aids', 'toothbrush', 'orchid', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'faucet', 'picture', 'shower', 'mousepad', 'candle', 'food_orange', 'oven', 'basket_for_clothes', 'bed', 'check', 'food_food', 'television', 'tray', 'after_shave', 'headset', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'bathroom_cabinet']  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:['sheets', 'filing_cabinet', 'tablelamp', 'tea', 'trashcan', 'drawing', 'orchid', 'floor', 'character', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'stovefan', 'tvstand', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'wall_clock', 'cup', 'bed', 'food_donut', 'curtain', 'towel_rack', 'sink', 'napkin', 'bathtub']  Task:Go to sleep  response:

{  Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'homework', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'keys', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Work  response:  {       thoughts : walk to Office,Walk to desk ,sit down in chair, turn on computer, start homework.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[FIND] <homework>', '[TURNTO] <homework>', '[LOOKAT] <homework>']  }     Scene_Objects:['spectacles', 'pot', 'band-aids', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'television', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'home_office', 'table', 'clothes_shirt']  Task:Relax on sofa  response:

{  Sitting down and relaxing on the sofa }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'freezer', 'blow_dryer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'shoe-shine_kit', 'couch', 'microphone', 'food_jam', 'wall', 'coffe_maker', 'check', 'television', 'curtain', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'colander', 'tooth_paste']  Task:Watch TV  response:  {       thoughts : Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['tablelamp', 'chair', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'television', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'instrument_violin']  Task:Turn on light  response:

{  I enter the bedroom and find the light. Then I turn it on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['crayon', 'microwave', 'toilet', 'freezer', 'ground_coffee', 'longboard', 'shampoo', 'character', 'thread', 'food_bacon', 'piano_bench', 'balanceball', 'stereo', 'window', 'picture', 'mousepad', 'pillow', 'toy', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'oven_mitts', 'colander', 'doorjamb', 'shaving_cream', 'dresser', 'soap', 'washing_machine', 'creditcard']  Task:Wash clothes  response:  {       thoughts : walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'food_jam', 'wall', 'nightstand', 'oven', 'newspaper', 'food_food', 'vacuum_cleaner', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'hands_both']  Task:Wash hands  response:

{  I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'phone', 'character', 'keyboard', 'mat', 'faucet', 'wall', 'oven', 'bed', 'keys', 'coffe_maker', 'mouthwash', 'food_onion', 'curtain', 'centerpiece', 'console', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'home_office']  Task:Pet cat  response:  {       thoughts : First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['sheets', 'scissors', 'milk', 'wallshelf', 'cpuscreen', 'hanger', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'table_cloth', 'stovefan', 'tvstand', 'window', 'closetdrawer', 'candle', 'dining_room', 'wall_clock', 'oven', 'bench', 'photoframe', 'television', 'tray', 'kitchen_counter', 'door', 'bathtub', 'sink', 'table', 'soap', 'creditcard']  Task:Listen to music  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'microwave', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'plate', 'faucet', 'tvstand', 'clothes_hat', 'pillow', 'wall', 'oven', 'powersocket', 'newspaper', 'photoframe', 'check', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'clothes_scarf', 'table', 'clothes_skirt', 'dishwasher']  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:['food_pizza', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'phone', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'rag', 'cupboard', 'table', 'colander']  Task:Relax on sofa  response:

{  I go to the living room and sit in the sofa }