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', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste']  Task:Hang up car keys  response:  {       thoughts : Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,       actions : ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']  }     Scene_Objects:['microwave', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'window', 'clothes_socks', 'couch', 'pillow', 'towel', 'broom', 'wall', 'bench', 'oven', 'toy', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'food_onion', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'scrabble']  Task:Relax on sofa  response:

{  Walk to living room. Find couch. Sit on couch }


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', 'juice', 'measuring_cup', 'microwave', 'walllamp', 'trashcan', 'floor', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'candle', 'pillow', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['toilet', 'chair', 'walllamp', 'floor', 'dvd_player', 'bedroom', 'bookshelf', 'food_cake', 'shower', 'picture', 'foundation', 'mousepad', 'closetdrawer', 'tooth_paste', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'shelf', 'food_food', 'doorjamb', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'towel_rack', 'door', 'napkin', 'bathroom_cabinet', 'board_game']  Task:Go to toilet  response:

{  I go to the bathroom. I locate the toilet. I walk 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:['glue', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'bedroom', 'computer', 'ceilinglamp', 'deck_of_cards', 'iron', 'window', 'electric_shaver', 'couch', 'food_orange', 'wall', 'wall_clock', 'bed', 'novel', 'check', 'television', 'toothbrush_holder', 'wooden_spoon', 'after_shave', 'towel_rack', 'dresser', 'conditioner', 'maindoor', 'table', 'vase']  Task:Relax on sofa  response:  {       thoughts : Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['microwave', 'food_egg', 'bathroom_counter', 'ceiling', 'computer', 'button', 'food_bacon', 'plate', 'stereo', 'shower', 'window', 'picture', 'food_kiwi', 'wall', 'wall_clock', 'toy', 'shelf', 'bed', 'toilet_paper', 'oven_mitts', 'tray', 'after_shave', 'doorjamb', 'mouse', 'pencil', 'clothes_dress', 'maindoor', 'sink', 'food_steak', 'bathroom_cabinet']  Task:Listen to music  response:

{  I go into the living room and turn on the radio.  Then, I select the station I want, which is usually a preset. }


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', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'knife', 'orchid', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'keys', 'television', 'coffee_filter', 'curtain', 'centerpiece', 'cupboard', 'bathroom_cabinet', 'table']  Task:Change TV channel  response:  {       thoughts : change the tv channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['food_ice_cream', 'tea', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'table_cloth', 'mat', 'stereo', 'window', 'foundation', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'bench', 'keys', 'toilet_paper', 'food_food', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'vacuum_cleaner', 'comb', 'maindoor', 'bathtub', 'table']  Task:Relax on sofa  response:

{  move to living room, locate sofa, move to sofa, sit on sofa, lie on 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', 'juice', 'toilet', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'phone', 'desk', 'stovefan', 'plate', 'faucet', 'window', 'mousepad', 'form', 'pillow', 'wall', 'wall_clock', 'oven', 'clothes_gloves', 'tray', 'diary', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink']  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:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'table_cloth', 'mat', 'tvstand', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall_clock', 'powersocket', 'cutting_board', 'television', 'food_donut', 'food_rice', 'towel_rack', 'controller', 'maindoor']  Task:Pet cat  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:['sponge', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'love_seat', 'clothes_gloves', 'television', 'tray', 'curtain', 'food_onion', 'dresser', 'cupboard', 'instrument_guitar', 'table', 'light']  Task:Watch TV  response:  {       thoughts : I'll watch TV,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'blender', 'milk', 'orchid', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'thread', 'stovefan', 'mat', 'toaster', 'faucet', 'plate', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'wall_clock', 'oven', 'tray', 'curtain', 'mouse', 'sink', 'napkin', 'bathroom_cabinet', 'soap']  Task:Wash hands  response:

{  walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse 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:['fork', 'food_bread', 'dog', 'ground_coffee', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'bedroom', 'alcohol', 'mop_bucket', 'stovefan', 'laptop', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'window', 'mat', 'mousepad', 'food_orange', 'pillow', 'powersocket', 'coffe_maker', 'fly', 'coffee_pot', 'kitchen_counter', 'cupboard', 'dishwasher', 'soap']  Task:Watch fly  response:  {       thoughts : Look around for a fly, often on a wall or ceiling.  Follow it's movements.,       actions : ['[WALK] <bedroom>', '[WALK] <fly>', '[FIND] <fly>', '[TURNTO] <fly>', '[LOOKAT] <fly>']  }     Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'orchid', 'hanger', 'phone', 'computer', 'piano_bench', 'nightstand', 'pasta', 'wall_clock', 'powersocket', 'toy', 'food_cheese', 'clothes_gloves', 'check', 'toilet_paper', 'television', 'after_shave', 'doorjamb', 'door', 'hairdryer', 'sink', 'home_office', 'light', 'table', 'clothes_scarf', 'soap']  Task:Read book  response:

{  go to bedroom, sit down, pick up book, read }


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', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'towel', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'coin', 'tray', 'food_onion', 'doorjamb', 'towel_rack', 'dishrack', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel.,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['food_salt', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table']  Task:Work  response:

{  Walk to the home office and turn to the desk. Switch on the computer. Grab the mouse and keyboard to start working. }


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', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'laptop', 'faucet', 'tvstand', 'window', 'couch', 'microphone', 'towel', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'food_food', 'television', 'tray', 'mouse', 'dresser', 'sink', 'clothes_scarf', 'home_office', 'table', 'clothes_skirt']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['toilet', 'chair', 'dog', 'walllamp', 'ground_coffee', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'clothes_socks', 'towel', 'wall', 'cutting_board', 'shelf', 'basket_for_clothes', 'coffe_maker', 'food_rice', 'water', 'tray', 'doorjamb', 'food_steak', 'home_office', 'vase', 'soap', 'teeth']  Task:Take shower  response:

{  Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel. }


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_ice_cream', 'toilet', 'dog', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'longboard', 'floor', 'phone', 'character', 'purse', 'computer', 'toaster', 'plate', 'balanceball', 'stereo', 'dish_soap', 'food_kiwi', 'wall', 'oven', 'tape', 'coffe_maker', 'mouthwash', 'tray', 'door', 'sink', 'napkin', 'dishwasher', 'vase']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'oil', 'pillow', 'dining_room', 'wall', 'wall_clock', 'bench', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'headset', 'napkin', 'table']  Task:Watch TV  response:

{  Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program. }


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_ice_cream', 'microwave', 'freezer', 'trashcan', 'toothbrush', 'orchid', 'hanger', 'desk', 'keyboard', 'bookmark', 'shoe-shine_kit', 'iron', 'tvstand', 'plate', 'mousepad', 'microphone', 'wall', 'bench', 'toilet_paper', 'television', 'toothbrush_holder', 'ice', 'shoes', 'chessboard', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'tooth_paste', 'teeth', 'creditcard']  Task:Wash teeth  response:  {       thoughts : walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth,       actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>']  }     Scene_Objects:['toilet', 'freezer', 'dough', 'cpuscreen', 'hanger', 'computer', 'piano_bench', 'bookmark', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'wall', 'nightstand', 'box', 'photoframe', 'toilet_paper', 'video_game_controller', 'food_food', 'doorjamb', 'towel_rack', 'hairbrush', 'hair', 'instrument_violin', 'sink', 'home_office', 'light', 'vase', 'tooth_paste']  Task:Pick up phone  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', 'toilet', 'walllamp', 'drawing', 'floor', 'ceiling', 'bedroom', 'window', 'clothes_socks', 'couch', 'dustpan', 'clothes_pants', 'food_orange', 'food_kiwi', 'wall', 'toy', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'wine', 'doorjamb', 'diary', 'console', 'mouse', 'door', 'bathroom_cabinet', 'light', 'vase', 'soap']  Task:Turn off light  response:  {       thoughts : Grasp light switch, flip light switch.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['microwave', 'toilet', 'freezer', 'ground_coffee', 'walllamp', 'dough', 'food_carrot', 'floor', 'ceiling', 'stovefan', 'toaster', 'stereo', 'clothes_hat', 'wall', 'oven', 'bench', 'cutting_board', 'food_cheese', 'coffe_maker', 'food_food', 'check', 'toothbrush_holder', 'food_donut', 'tray', 'kitchen_counter', 'dishrack', 'hairbrush', 'bag', 'bathroom_cabinet', 'creditcard']  Task:Put groceries in Fridge  response:

{  Open the fridge, put the groceries in the fridge and close 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:['walllamp', 'nail_polish', 'bathroom', 'detergent', 'knife', 'cpuscreen', 'dvd_player', 'bedroom', 'computer', 'table_cloth', 'mop_bucket', 'brush', 'toaster', 'shower', 'window', 'couch', 'dining_room', 'wall', 'pasta', 'cup', 'photoframe', 'after_shave', 'pencil', 'kitchen_counter', 'dresser', 'clothes_dress', 'sink', 'instrument_guitar', 'light', 'creditcard']  Task:Sit  response:  {       thoughts : We sit at the dining room table,       actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']  }     Scene_Objects:['glue', 'dog', 'bathroom', 'toothbrush', 'orchid', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'oven', 'razor', 'toothbrush_holder', 'tray', 'centerpiece', 'doorjamb', 'instrument_violin', 'sink', 'bathroom_cabinet', 'vase', 'tooth_paste']  Task:Brush teeth  response:

{  go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away. }


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_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:  {       thoughts : I walk over to the phone and pick it up.,       actions : ['[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['spectacles', 'blender', 'crayon', 'microwave', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'envelope', 'stovefan', 'window', 'oil', 'wall', 'powersocket', 'bench', 'toy', 'keys', 'food_donut', 'wooden_spoon', 'curtain', 'doorjamb', 'maindoor', 'bathtub', 'bathroom_cabinet', 'light', 'dirt', 'teeth']  Task:Turn on light  response:

{  walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_carrot', 'milk', 'dough', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'stereo', 'towel', 'pillow', 'wall', 'bench', 'cup', 'bed', 'photoframe', 'coffe_maker', 'wooden_spoon', 'after_shave', 'rag', 'mouse', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['dry_pasta', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'table_cloth', 'stovefan', 'mat', 'faucet', 'foundation', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'toy', 'hands_both', 'tray', 'doorjamb', 'towel_rack', 'shaving_cream', 'door', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'teeth']  Task:Wash teeth  response:

{  I need to rinse my dentures off and put them back in my mouth. }


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:['spectacles', 'pot', 'fork', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'toaster', 'plate', 'tvstand', 'dish_soap', 'food_noodles', 'bowl', 'wall', 'pasta', 'oven', 'box', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'console', 'towel_rack', 'pencil', 'maindoor', 'sink', 'instrument_guitar', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Wash a plate using the dishwasher in the kitchen.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'nail_polish', 'cpuscreen', 'bathroom_counter', 'character', 'desk', 'folder', 'keyboard', 'food_cake', 'bedroom', 'alcohol', 'stovefan', 'toaster', 'shower', 'window', 'candle', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'cutting_board', 'video_game_controller', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'board_game']  Task:Read book  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'toaster', 'shower', 'wall', 'novel', 'food_food', 'television', 'oven_mitts', 'tray', 'kitchen_counter', 'headset', 'dresser', 'cupboard', 'hair', 'bathtub']  Task:Put groceries in Fridge  response:  {       thoughts : Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['pot', 'food_pizza', 'toilet', 'detergent', 'toothbrush', 'orchid', 'wallshelf', 'hanger', 'bedroom', 'bookshelf', 'computer', 'shower', 'window', 'cutting_board', 'food_cheese', 'novel', 'check', 'mouthwash', 'toothbrush_holder', 'wine', 'doorjamb', 'pajamas', 'hairdryer', 'maindoor', 'bathtub', 'home_office', 'door', 'clothes_skirt', 'tooth_paste', 'teeth']  Task:Wash teeth  response:

{  walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both']  Task:Wash hands  response:  {       thoughts : I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']  }     Scene_Objects:['freezer', 'bathroom', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stovefan', 'mat', 'faucet', 'dining_room', 'wall', 'wall_clock', 'oven', 'newspaper', 'light_bulb', 'tray', 'curtain', 'towel_rack', 'laundry_detergent', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'bathtub', 'home_office', 'soap', 'laser_pointer', 'hands_both']  Task:Wash hands  response:

{  go to the bathroom and wash your 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:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'nightstand', 'feet_both', 'photoframe', 'bed', 'television', 'coin', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'shoes', 'hairbrush', 'door']  Task:Put on your shoes  response:  {       thoughts : Sit on a chair with your shoes in front of you.  Put them on one at a time.,       actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <feet_both>', '[PUTBACK] <shoes> <feet_both>']  }     Scene_Objects:['scissors', 'blender', 'tablelamp', 'ground_coffee', 'bathroom', 'toothbrush', 'drawing', 'knife', 'orchid', 'desk', 'keyboard', 'brush', 'shower', 'homework', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall_clock', 'check', 'television', 'toothbrush_holder', 'tray', 'kettle', 'kitchen_counter', 'maindoor', 'sink', 'clothes_skirt', 'tooth_paste', 'dirt']  Task:Wash teeth  response:

{  WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'glue', 'tablelamp', 'mop', 'microwave', 'freezer', 'walllamp', 'needle', 'food_egg', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'stovefan', 'stereo', 'form', 'dining_room', 'wall', 'oven', 'powersocket', 'cutting_board', 'toy', 'keys', 'food_food', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'clothes_scarf', 'creditcard']  Task:Put groceries in Fridge  response:  {       thoughts : Open the fridge, and put groceries in the fridge. Close the fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['dry_pasta', 'food_bread', 'microwave', 'freezer', 'ground_coffee', 'dough', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'faucet', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'cupboard', 'sink']  Task:Make coffee  response:

{  I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine 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', 'microwave', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'microphone', 'form', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'television', 'curtain', 'vacuum_cleaner', 'dishrack', 'dresser', 'hairbrush', 'door', 'table', 'soap']  Task:Watch TV  response:  {       thoughts : I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['scissors', 'crayon', 'chair', 'nail_polish', 'cat', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'computer', 'food_bacon', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'toy', 'doorjamb', 'kettle', 'mouse', 'dresser', 'hairdryer', 'sink', 'bathroom_cabinet', 'light']  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:['water_glass', 'microwave', 'freezer', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'couch', 'wall', 'wall_clock', 'oven', 'keys', 'coffe_maker', 'water', 'tray', 'curtain', 'coffee_pot', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'tooth_paste']  Task:Drink  response:  {       thoughts : I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['dry_pasta', 'pot', 'sponge', 'microwave', 'freezer', 'walllamp', 'food_carrot', 'hanger', 'bathroom_counter', 'floor', 'envelope', 'stovefan', 'mat', 'faucet', 'clothes_hat', 'wall', 'wall_clock', 'oven', 'cutting_board', 'cup', 'food_vegetable', 'food_food', 'coin', 'water', 'tray', 'kitchen_counter', 'shoes', 'door', 'sink', 'bathroom_cabinet']  Task:Cook some food  response:

{  walk to kicthen , find stove , find cooking pot , find vegetables , find water  ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'food_ice_cream', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'shower', 'mousepad', 'food_peanut_butter', 'food_jam', 'wall', 'bench', 'powersocket', 'toy', 'box', 'standingmirror', 'coffe_maker', 'water', 'doorjamb', 'cards', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'board_game']  Task:Take shower  response:  {       thoughts : go to a bathroom, open the shower, let water wash your body,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']  }     Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'knife', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'toaster', 'laptop', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'box', 'console', 'mouse', 'dresser', 'maindoor', 'hairdryer', 'board_game']  Task:Write an email  response:

{  I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email }


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', 'detergent', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'napkin']  Task:Watch TV  response:  {       thoughts : Find the remote, turn on the TV, watch.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['food_pizza', 'microwave', 'dog', 'drawing', 'hanger', 'bedroom', 'desk', 'computer', 'table_cloth', 'stovefan', 'brush', 'faucet', 'mousepad', 'dining_room', 'bowl', 'wall_clock', 'powersocket', 'novel', 'food_food', 'check', 'coffee_filter', 'kitchen_counter', 'cd', 'food_steak', 'napkin', 'home_office', 'light', 'clothes_skirt', 'vase', 'board_game']  Task:Listen to music  response:

{  Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio. }


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', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'hair', 'door', 'coffee']  Task:Browse internet  response:  {       thoughts : walk to living room. look at computer. switch on computer. sit in chair. watch computer. switch off computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[WATCH] <computer>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['sheets', 'walllamp', 'drawing', 'cpuscreen', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'alcohol', 'laptop', 'plate', 'faucet', 'homework', 'mousepad', 'dining_room', 'check', 'food_food', 'television', 'tray', 'wooden_spoon', 'mouse', 'shoes', 'conditioner', 'maindoor', 'napkin', 'home_office', 'soap', 'instrument_violin']  Task:Browse internet  response:

{  I turn on computer. I use keyboard to type. I open browser. I search. }


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', 'sheets', 'mop', 'microwave', 'chair', 'freezer', 'blow_dryer', 'nail_polish', 'orchid', 'knife', 'floor', 'keyboard', 'stovefan', 'stereo', 'foundation', 'couch', 'soap', 'food_orange', 'pillow', 'wall', 'powersocket', 'check', 'toilet_paper', 'coffe_maker', 'curtain', 'pencil', 'shoes', 'vacuum_cleaner', 'colander', 'shoe_rack']  Task:Pet cat  response:  {       thoughts : Petting the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['sheets', 'jelly', 'freezer', 'chair', 'blow_dryer', 'bathroom', 'walllamp', 'knife', 'phone', 'keyboard', 'stovefan', 'homework', 'couch', 'food_jam', 'bench', 'oven', 'toy', 'box', 'food_cheese', 'oven_mitts', 'food_rice', 'tray', 'curtain', 'after_shave', 'dresser', 'clothes_dress', 'conditioner', 'hairdryer', 'vase', 'board_game']  Task:Pet cat  response:

{  I walk to my living room, find my cat, scrub it using my hand. }


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', 'water_glass', 'food_ice_cream', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'toaster', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'coffe_maker', 'television', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'door', 'dishwasher']  Task:Drink  response:  {       thoughts : 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.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[OPEN] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     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:

{  I see my cat on the couch so I walk over, sit down and 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:['bathroom', 'ceilingfan', 'food_carrot', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'faucet', 'shower', 'window', 'wall', 'photoframe', 'novel', 'toilet_paper', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'clothes_dress', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'table', 'vase', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off.,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['fork', 'blender', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'keyboard', 'mat', 'laptop', 'tvstand', 'picture', 'window', 'clothes_socks', 'couch', 'pillow', 'food_kiwi', 'wall', 'wall_clock', 'cutting_board', 'bed', 'television', 'toothbrush_holder', 'curtain', 'food_onion', 'doorjamb', 'door', 'table']  Task:Relax on sofa  response:

{  I walk into the living room. I cross the room to the couch. I sit down and relax. }


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', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'mat', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'check', 'mouthwash', 'food_food', 'food_donut', 'wine', 'curtain', 'doorjamb', 'console', 'dresser', 'door', 'light']  Task:Pick up toys  response:  {       thoughts : Bend down and pick up the toys off of the floor.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']  }     Scene_Objects:['pot', 'filing_cabinet', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'floor', 'desk', 'bookshelf', 'plate', 'faucet', 'picture', 'iron', 'window', 'dish_soap', 'food_jam', 'wall', 'nightstand', 'toy', 'cutting_board', 'food_food', 'television', 'curtain', 'pajamas', 'conditioner', 'light', 'dishwasher', 'tooth_paste', 'shoe_rack']  Task:Wash dishes with dishwasher  response:

{  Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the 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:['glue', 'tablelamp', 'mop', 'toilet', 'chair', 'trashcan', 'knifeblock', 'hanger', 'longboard', 'floor', 'phone', 'keyboard', 'balanceball', 'foundation', 'pillow', 'wall', 'powersocket', 'box', 'photoframe', 'bed', 'check', 'rag', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'colander']  Task:Sit  response:  {       thoughts : We sit at the dining room table,       actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']  }     Scene_Objects:['filing_cabinet', 'orchid', 'hanger', 'ceiling', 'keyboard', 'piano_bench', 'tvstand', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'wall', 'powersocket', 'bench', 'cutting_board', 'toy', 'photoframe', 'bed', 'razor', 'wooden_spoon', 'after_shave', 'coffee_pot', 'dresser', 'clothes_dress', 'bathtub', 'bathroom_cabinet', 'light', 'clothes_shirt', 'washing_machine', 'shoe_rack']  Task:Wash clothes  response:

{  walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off washing machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'pot', 'fork', 'beer', 'walllamp', 'bathroom', 'orchid', 'kitchen_cabinet', 'floor', 'phone', 'toaster', 'mat', 'plate', 'tvstand', 'window', 'dish_soap', 'couch', 'bowl', 'wall', 'oven', 'bench', 'coffe_maker', 'tray', 'rag', 'console', 'kitchen_counter', 'dishrack', 'hair', 'maindoor', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet..,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>', '[GRAB] <plate>', '[WIPE] <plate>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[PUTOBJBACK] <dishrack>']  }     Scene_Objects:['sponge', 'pot', 'detergent', 'cpuscreen', 'ceiling', 'character', 'thread', 'food_bacon', 'mat', 'shower', 'window', 'candle', 'pillow', 'dining_room', 'oven', 'powersocket', 'tape', 'cutting_board', 'clothes_gloves', 'coffe_maker', 'check', 'television', 'food_onion', 'cards', 'towel_rack', 'pencil', 'maindoor', 'home_office', 'table', 'teeth']  Task:Pick up phone  response:

{  go to living room, find phone, pick up 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:['tea', 'microwave', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'button', 'food_bacon', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'coffee_table', 'novel', 'mouthwash', 'television', 'doorjamb', 'diary', 'clothes_scarf', 'sink']  Task:Read book  response:  {       thoughts : Sit down in recliner.  Pick up novel off of coffee table.  Open novel to last read page.  Begin reading,       actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <bookmark>', '[READ] <novel>']  }     Scene_Objects:['dry_pasta', 'shoe_rack', 'filing_cabinet', 'beer', 'microwave', 'freezer', 'nail_polish', 'drawing', 'stamp', 'keyboard', 'computer', 'bookmark', 'plate', 'tvstand', 'dish_soap', 'form', 'wall_clock', 'bench', 'toy', 'newspaper', 'novel', 'coffe_maker', 'food_donut', 'curtain', 'kitchen_counter', 'headset', 'cd', 'door', 'dishwasher', 'creditcard']  Task:Wash dishes with dishwasher  response:

{  Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty 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', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'sink', 'table', 'light']  Task:Change TV channel  response:  {       thoughts : I go the living room, look for my tv remote control, take the control and then sit down on the couch and turn on the TV and push the buttons on the remote control to change the channel.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['food_pizza', 'beer', 'microwave', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'cat', 'milk', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'envelope', 'stovefan', 'couch', 'food_orange', 'food_kiwi', 'wall', 'oven', 'cutting_board', 'toy', 'shelf', 'coffe_maker', 'food_food', 'tray', 'kitchen_counter', 'maindoor', 'vase']  Task:Put groceries in Fridge  response:

{  I walk to the kitchen, open the fridge and put the groceries in the fridge. Then I close the fridge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'walllamp', 'ceilingfan', 'food_carrot', 'toothbrush', 'drawing', 'desk', 'bookshelf', 'stovefan', 'balanceball', 'shower', 'window', 'candle', 'clothes_pants', 'food_orange', 'dining_room', 'bench', 'bed', 'keys', 'food_food', 'diary', 'mouse', 'shoes', 'sink', 'vase', 'tooth_paste', 'scrabble', 'teeth']  Task:Brush teeth  response:  {       thoughts : EARLY MORNING AND BEFORE GOING TO BED,       actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']  }     Scene_Objects:['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:

{  Make some dish water, grab a dish rag, put dishes in dish water and wash. }


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:['ground_coffee', 'nail_polish', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'button', 'mail', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'tape', 'television', 'curtain', 'food_onion', 'cupboard', 'table', 'shoe_rack']  Task:Watch TV  response:  {       thoughts : Go to the living room, sit on the couch, find the remote, switch on the TV and watch,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['filing_cabinet', 'freezer', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'shampoo', 'bedroom', 'bookshelf', 'thread', 'mop_bucket', 'tvstand', 'faucet', 'mousepad', 'towel', 'powersocket', 'bed', 'coffe_maker', 'television', 'oven_mitts', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'maindoor', 'home_office', 'bathroom_cabinet', 'table']  Task:Pick up phone  response:

{  Enter living room. Walk to telephone. Pick up from hook. }


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', 'chair', 'band-aids', 'walllamp', 'nail_polish', 'drawing', 'bills', 'wallshelf', 'orchid', 'hanger', 'knife', 'floor', 'ceiling', 'desk', 'alcohol', 'mat', 'foundation', 'closetdrawer', 'couch', 'pillow', 'wall', 'bed', 'novel', 'check', 'oven_mitts', 'rag', 'kitchen_counter', 'dresser', 'bag', 'napkin']  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:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'mat', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'cutting_board', 'cup', 'novel', 'food_food', 'television', 'wine', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'board_game']  Task:Relax on sofa  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', 'tablelamp', 'toilet', 'freezer', 'walllamp', 'drawing', 'character', 'bedroom', 'toaster', 'deck_of_cards', 'faucet', 'shower', 'plate', 'window', 'mousepad', 'couch', 'candle', 'clothes_hat', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'tray', 'mouse', 'pencil', 'bathtub', 'bathroom_cabinet', 'table', 'dishwasher', 'board_game']  Task:Listen to music  response:  {       thoughts : I walk into the bedroom. I walk to stereo. I turn on stereo.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['pot', 'food_ice_cream', 'chair', 'food_carrot', 'hanger', 'bathroom_counter', 'floor', 'keyboard', 'mat', 'plate', 'ceilinglamp', 'window', 'mousepad', 'couch', 'food_orange', 'pillow', 'broom', 'wall', 'toy', 'bed', 'toilet_paper', 'television', 'wine', 'curtain', 'food_onion', 'doorjamb', 'dresser', 'spoon', 'home_office', 'table']  Task:Relax on sofa  response:

{  Walk to living room. Sit on sofa. Lie down on 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', 'food_salt', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'desk', 'alcohol', 'stovefan', 'mat', 'plate', 'shower', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'food_food', 'television', 'tray', 'towel_rack', 'kitchen_counter', 'sauce_pan', 'cupboard', 'spoon', 'napkin', 'light', 'dishwasher']  Task:Cook some food  response:  {       thoughts : I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate.,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <spoon>', '[GRAB] <spoon>', '[FIND] <sauce_pan>', '[PUTBACK] <spoon> <sauce_pan>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <plate>', '[PUTBACK] <pot> <plate>']  }     Scene_Objects:['food_pizza', 'juice', 'food_salt', 'microwave', 'ground_coffee', 'nail_polish', 'drawing', 'food_egg', 'bathroom_counter', 'shampoo', 'purse', 'stovefan', 'shower', 'stereo', 'window', 'mousepad', 'towel', 'nightstand', 'oven', 'powersocket', 'curtain', 'after_shave', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'hair', 'door', 'bathtub', 'sink']  Task:Pick up phone  response:

{  walk to living room , find phone ,pick up phone 3 }


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', 'freezer', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'man', 'bookshelf', 'clothes_jacket', 'piano_bench', 'toaster', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'coffe_maker', 'doorjamb', 'cupboard', 'door', 'sink', 'home_office', 'table', 'light']  Task:Have conversation with boyfriend  response:  {       thoughts : Sit on sofa, talk,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <man>', '[GREET] <man>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table']  Task:Work  response:

{  I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'tablelamp', 'walllamp', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'mat', 'faucet', 'couch', 'pillow', 'wall', 'pasta', 'wall_clock', 'cup', 'photoframe', 'bed', 'television', 'water', 'wine', 'curtain', 'paper_towel', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:  {       thoughts : I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <water>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>']  }     Scene_Objects:['mop', 'microwave', 'bathroom', 'detergent', 'wallshelf', 'clothes_underwear', 'hanger', 'ceiling', 'bookshelf', 'tvstand', 'faucet', 'deck_of_cards', 'window', 'clothes_socks', 'clothes_pants', 'cup', 'standingmirror', 'photoframe', 'check', 'tray', 'kitchen_counter', 'hair', 'laundry_detergent', 'door', 'bathroom_cabinet', 'tooth_paste', 'clothes_shirt', 'washing_machine', 'coffee', 'shoe_rack']  Task:Wash clothes  response:

{  I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I 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:['sheets', 'detergent', 'orchid', 'wallshelf', 'floor', 'ceiling', 'tea_bag', 'stovefan', 'toaster', 'faucet', 'shower', 'foundation', 'tooth_paste', 'closetdrawer', 'candle', 'nightstand', 'cup', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'tray', 'curtain', 'rag', 'clothes_scarf', 'table', 'soap', 'instrument_violin', 'dirt', 'hands_both']  Task:Wash hands  response:  {       thoughts : Wash hands with soap,       actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>']  }     Scene_Objects:['pot', 'scissors', 'tablelamp', 'food_ice_cream', 'toilet', 'bathroom', 'toothbrush', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceilinglamp', 'faucet', 'clothes_socks', 'closetdrawer', 'tape', 'cup', 'check', 'food_food', 'razor', 'food_onion', 'centerpiece', 'mouse', 'dresser', 'bathtub', 'bathroom_cabinet', 'light', 'clothes_skirt', 'tooth_paste', 'shoe_rack']  Task:Brush teeth  response:

{  EARLY MORNING AND BEFORE GOING TO BED }


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', 'filing_cabinet', 'microwave', 'ground_coffee', 'knifeblock', 'wallshelf', 'ceiling', 'phone', 'character', 'desk', 'piano_bench', 'stovefan', 'toaster', 'couch', 'clothes_hat', 'pillow', 'bench', 'oven', 'tape', 'cutting_board', 'doorjamb', 'cards', 'mouse', 'dishrack', 'cupboard', 'hairdryer', 'sink', 'clothes_scarf', 'table', 'dishwasher']  Task:Pick up phone  response:  {       thoughts : i go find the phone. i pick up the phone,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['sheets', 'spectacles', 'sponge', 'beer', 'chair', 'freezer', 'detergent', 'food_butter', 'cpuscreen', 'hanger', 'bedroom', 'desk', 'bookshelf', 'table_cloth', 'toaster', 'ceilinglamp', 'shower', 'iron', 'window', 'wall', 'oven', 'food_food', 'razor', 'food_rice', 'curtain', 'kitchen_counter', 'food_steak', 'door', 'spoon', 'bathroom_cabinet']  Task:Listen to music  response:

{  I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'band-aids', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'television', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'door']  Task:Browse internet  response:  {       thoughts : Go to home office, turn on the computer, open the internet and browse around the internet.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['beer', 'toilet', 'chair', 'walllamp', 'blow_dryer', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'food_orange', 'wall', 'powersocket', 'cup', 'standingmirror', 'keys', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table']  Task:Work  response:

{  turn computer on, open application to work with }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'thread', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'toilet_paper', 'television', 'razor', 'coin', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table']  Task:Turn on computer  response:  {       thoughts : Push power button.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer']  Task:Take shower  response:

{  Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'wallshelf', 'food_egg', 'hanger', 'cpuscreen', 'floor', 'ceiling', 'character', 'keyboard', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'toaster', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'light', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk into the living room and turn on the light. I walk to the couch then sit on the couch.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'food_salt', 'microwave', 'toilet', 'chair', 'blow_dryer', 'hanger', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'mail', 'shoe-shine_kit', 'mousepad', 'food_noodles', 'cutting_board', 'cup', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'comb', 'pajamas', 'clothes_dress', 'door', 'home_office', 'light', 'table']  Task:Pet cat  response:

{  Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail }


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', 'orchid', 'drawing', 'floor', 'ceiling', 'toaster', 'food_noodles', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'cup', 'bed', 'photoframe', 'coffe_maker', 'toilet_paper', 'television', 'coffee_filter', 'ice', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'sink', 'clothes_scarf', 'dishwasher', 'soap', 'dirt', 'coffee']  Task:Make coffee  response:  {       thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']  }     Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'freezer', 'bathroom', 'detergent', 'bathroom_counter', 'floor', 'bedroom', 'toaster', 'plate', 'shower', 'dining_room', 'nightstand', 'oven', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'kitchen_counter', 'dresser', 'door', 'sink', 'bathtub', 'home_office', 'table', 'dishwasher', 'soap', 'board_game']  Task:Wash dishes with dishwasher  response:

{  Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer 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:['sponge', 'microwave', 'toilet', 'jelly', 'freezer', 'ground_coffee', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'button', 'mat', 'shower', 'picture', 'dustpan', 'food_orange', 'form', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'light_bulb', 'food_food', 'doorjamb', 'cd', 'door', 'light']  Task:Added meat to freezer  response:  {       thoughts : After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['sheets', 'spectacles', 'scissors', 'knife', 'hanger', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'keyboard', 'piano_bench', 'stovefan', 'stereo', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'console', 'pencil', 'shoes', 'door', 'bathtub', 'bag', 'instrument_guitar', 'table', 'home_office', 'light', 'board_game']  Task:Listen to music  response:

{  I walk into my room and turn the radio on so that I can listen to music. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'mat', 'deck_of_cards', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'bed', 'coffee_filter', 'wine', 'curtain', 'doorjamb', 'kitchen_counter', 'pajamas', 'door', 'food_steak', 'bag', 'light', 'electrical_outlet']  Task:Turn on light  response:  {       thoughts : I walk to the living room. I find the electric outlet. I switch on the light.,       actions : ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'beer', 'crayon', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'iron', 'electric_shaver', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'novel', 'food_food', 'check', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'table']  Task:Read book  response:

{  I go to the book case, I select a book, I go back and sit down, then I read. }


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', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'dishwasher']  Task:Work  response:  {       thoughts : Sit at my computer desk, Turn on Computer. Get online. Work.,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['chair', 'toothbrush', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'table_cloth', 'toaster', 'laptop', 'shower', 'mousepad', 'closetdrawer', 'dustpan', 'dining_room', 'wall', 'powersocket', 'food_cheese', 'coffe_maker', 'check', 'wooden_spoon', 'doorjamb', 'mouse', 'dresser', 'door', 'maindoor', 'food_steak', 'light']  Task:Work  response:

{  first ill go to my home office adn ill switch on my laptop and with the use of mouse and keyboard il run my computer }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'milk', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'character', 'bedroom', 'stovefan', 'toaster', 'mousepad', 'clothes_pants', 'food_kiwi', 'wall_clock', 'bed', 'television', 'toothbrush_holder', 'water', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'dirt']  Task:Brush teeth  response:  {       thoughts : today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well,       actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <toothbrush>']  }     Scene_Objects:['cat', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'iron', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'tape', 'novel', 'food_food', 'television', 'tray', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'vase', 'soap', 'hands_both']  Task:Wash hands  response:

{  I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my 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:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'knife', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'toaster', 'laptop', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'box', 'console', 'mouse', 'dresser', 'maindoor', 'hairdryer', 'board_game']  Task:Write an email  response:  {       thoughts : I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email,       actions : ['[WALK] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'button', 'bookmark', 'mat', 'picture', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'novel', 'check', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'light', 'table']  Task:Read book  response:

{  Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'scissors', 'chair', 'hanger', 'phone', 'keyboard', 'bookshelf', 'plate', 'faucet', 'window', 'mousepad', 'food_noodles', 'oil', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'bench', 'oven', 'cutting_board', 'toy', 'basket_for_clothes', 'cup', 'photoframe', 'keys', 'food_food', 'laundry_detergent', 'bathroom_cabinet', 'instrument_violin', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['tablelamp', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer']  Task:Read book  response:

{  I would go lie down in my bed and open the book and start reading. }


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

{  I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch 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:['food_salt', 'microwave', 'trashcan', 'hanger', 'floor', 'bedroom', 'computer', 'button', 'brush', 'mat', 'shower', 'faucet', 'window', 'clothes_hat', 'wall', 'child', 'oven', 'bed', 'newspaper', 'novel', 'curtain', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'hairdryer', 'clothes_scarf', 'vase', 'board_game']  Task:Story reading time  response:  {       thoughts : Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures,       actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>']  }     Scene_Objects:['glue', 'tablelamp', 'mop', 'toilet', 'chair', 'walllamp', 'bathroom', 'food_carrot', 'hanger', 'floor', 'shampoo', 'bookshelf', 'purse', 'computer', 'stovefan', 'toaster', 'shower', 'mousepad', 'dustpan', 'clothes_pants', 'wall', 'cutting_board', 'standingmirror', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'hairbrush', 'door', 'bathtub']  Task:Go to toilet  response:

{  Walk to the bathroom. Pull down pants. Use 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:['microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'mop_bucket', 'stovefan', 'ceilinglamp', 'tvstand', 'homework', 'mousepad', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'television', 'doorjamb', 'mouse', 'headset', 'cupboard', 'table', 'shoe_rack']  Task:Write an email  response:  {       thoughts : I go to the home office to find the computer. I turn switch computer on , i open the email. i write the email and  send it.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['tablelamp', 'food_ice_cream', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'shower', 'mousepad', 'food_peanut_butter', 'food_jam', 'wall', 'bench', 'powersocket', 'toy', 'box', 'standingmirror', 'coffe_maker', 'water', 'doorjamb', 'cards', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'board_game']  Task:Take shower  response:

{  go to a bathroom, open the shower, let water wash your body }


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', 'tablelamp', 'toilet', 'walllamp', 'cat', 'orchid', 'floor', 'ceiling', 'remote_control', 'computer', 'food_bacon', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'mouthwash', 'television', 'coin', 'food_rice', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'table', 'soap']  Task:Watch TV  response:  {       thoughts : Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['food_ice_cream', 'band-aids', 'dough', 'food_carrot', 'drawing', 'bookshelf', 'stovefan', 'shower', 'oil', 'towel', 'dining_room', 'wall', 'bench', 'toy', 'shelf', 'box', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'food_food', 'food_rice', 'kettle', 'shoes', 'door', 'bathtub', 'home_office', 'vase', 'soap']  Task:Wash hands  response: