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', 'knifeblock', 'knife', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'mail', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'stereo', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'novel', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'laundry_detergent', 'hairdryer', 'sink', 'home_office', 'dishwasher']  Task:Make coffee  response:  {       thoughts : Making coffee,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['spectacles', 'tablelamp', 'beer', 'measuring_cup', 'band-aids', 'woman', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'desk', 'man', 'thread', 'clothes_jacket', 'tvstand', 'stereo', 'faucet', 'window', 'shower', 'couch', 'form', 'cutting_board', 'novel', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'instrument_violin']  Task:Greet guests  response:

{  Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek. }


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', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer']  Task:Pet cat  response:  {       thoughts : I walk into the living room and I pet the cat,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'chair', 'walllamp', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'food_bacon', 'stovefan', 'ceilinglamp', 'brush', 'mat', 'oil', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'newspaper', 'novel', 'coffe_maker', 'television', 'mouse', 'chessboard', 'soap', 'instrument_violin', 'teeth']  Task:Have conversation with boyfriend  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'microwave', 'toilet', 'dog', 'freezer', 'drawing', 'knifeblock', 'longboard', 'floor', 'folder', 'computer', 'ceilinglamp', 'window', 'couch', 'wall', 'nightstand', 'bench', 'cup', 'bed', 'clothes_gloves', 'novel', 'television', 'curtain', 'towel_rack', 'cupboard', 'sink', 'home_office', 'table']  Task:Relax on sofa  response:  {       thoughts : I'm tired and want to relax on the sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['food_pizza', 'microwave', 'toilet', 'jelly', 'freezer', 'band-aids', 'drawing', 'knifeblock', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'water', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']  Task:Get drink  response:

{  I go to the fridge and open the door. I look for the water pitcher, and take it out, making sure to close the fridge door behind me. Then I take a pint glass out of the upper cabinet over the sink and use the water pitcher to pour a full glass of water. Then I return the pitcher to the fridge and shut the door again, and take my glass of water out of the kitche. }


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', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'thread', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'clothes_socks', 'wall', 'pasta', 'powersocket', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'television', 'rag', 'doorjamb', 'shoes', 'door', 'table', 'dishwasher']  Task:Watch TV  response:  {       thoughts : turn on the tv,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']  }     Scene_Objects:['sheets', 'sponge', 'mop', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'window', 'mousepad', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'pasta', 'nightstand', 'light_bulb', 'coffe_maker', 'television', 'wooden_spoon', 'mouse', 'shoes', 'vacuum_cleaner', 'sink']  Task:Check email  response:

{  Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond. }


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', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'laptop', 'faucet', 'mousepad', 'candle', 'microphone', 'food_orange', 'wall', 'photoframe', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'cupboard', 'pajamas', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt', 'hands_both']  Task:Wash hands  response:  {       thoughts : I go into the bathroom and turn on the light. I walk to the sink and turn on the water. I grab the soap and wash my hands,       actions : ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[PUTOBJBACK] <soap>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['microwave', 'toilet', 'jelly', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'floor', 'ceiling', 'toaster', 'plate', 'faucet', 'dish_soap', 'wall', 'nightstand', 'powersocket', 'oven', 'food_food', 'television', 'coffee_filter', 'wine', 'curtain', 'rag', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bag']  Task:Wash dishes  response:

{  Run hot water into tub of dirty dishes in the sink.  Add liquid soap.  Scrub dishes with wash rag. Rinse and place on drying rack. }


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', 'food_pizza', 'tablelamp', 'blender', 'food_salt', 'blow_dryer', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'purse', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'microphone', 'oven', 'food_food', 'check', 'tray', 'dresser', 'napkin', 'bathroom_cabinet', 'clothes_shirt']  Task:Leave home  response:  {       thoughts : Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.,       actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']  }     Scene_Objects:['tablelamp', 'jelly', 'freezer', 'detergent', 'woman', 'orchid', 'drawing', 'phone', 'character', 'man', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'stereo', 'food_orange', 'nightstand', 'box', 'food_cheese', 'coffe_maker', 'food_food', 'check', 'video_game_controller', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'table', 'tooth_paste']  Task:Greet people  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'chair', 'walllamp', 'knife', 'food_egg', 'floor', 'food_cake', 'toaster', 'plate', 'tvstand', 'window', 'dish_soap', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'check', 'razor', 'television', 'food_donut', 'tray', 'centerpiece', 'doorjamb', 'dishrack', 'food_steak', 'spoon', 'light', 'dishwasher', 'colander']  Task:Wash dishes with dishwasher  response:  {       thoughts : put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <dishrack>', '[PUTBACK] <fork> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishrack>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game']  Task:vacuum carpet  response:

{  I bring my vacuum cleaner into the living room.  I plug it into the wall.  I press the on switch on the vacuum cleaner.  I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet.  I turn the vacuum cleaner off.  I take the vacuum cleaner back to the hall closet. }


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', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'longboard', 'character', 'bedroom', 'computer', 'faucet', 'homework', 'clothes_socks', 'food_noodles', 'dining_room', 'photoframe', 'check', 'television', 'after_shave', 'rag', 'lighter', 'towel_rack', 'kitchen_counter', 'dresser', 'clothes_dress', 'home_office', 'light', 'laser_pointer', 'scrabble']  Task:Pick up phone  response:  {       thoughts : I walk to the home office. I find the telephone. I pick up the telephone handset.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['tablelamp', 'scissors', 'chair', 'bathroom', 'toothbrush', 'drawing', 'cpuscreen', 'floor', 'keyboard', 'piano_bench', 'ceilinglamp', 'oil', 'form', 'food_orange', 'wall', 'nightstand', 'oven', 'photoframe', 'check', 'food_food', 'television', 'coffee_filter', 'tray', 'mouse', 'cd', 'cupboard', 'door', 'table', 'light', 'creditcard']  Task:Eat dinner  response:

{  In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'microwave', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'stovefan', 'deck_of_cards', 'shower', 'pillow', 'wall', 'powersocket', 'cup', 'coffe_maker', 'check', 'wine', 'food_onion', 'curtain', 'lighter', 'kitchen_counter', 'cupboard', 'hair', 'controller', 'table', 'dishwasher', 'colander']  Task:Take dishes out of dishwasher  response:  {       thoughts : Take clean dishes out of the dishwasher and put away,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>']  }     Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'milk', 'cpuscreen', 'ceiling', 'phone', 'keyboard', 'stovefan', 'plate', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'wine', 'tray', 'food_onion', 'mouse', 'kitchen_counter', 'headset', 'comb', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']  Task:Get out dish  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:['food_pizza', 'chair', 'freezer', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'window', 'oil', 'couch', 'wall', 'bench', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'after_shave', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'light']  Task:Open bathroom window  response:  {       thoughts : Make sure bathroom window is unlocked. Lift up bathroom window so it is open.,       actions : ['[WALK] <bathroom>', '[WALK] <window>', '[FIND] <window>', '[OPEN] <window>']  }     Scene_Objects:['sheets', 'pot', 'food_salt', 'cpuscreen', 'clothes_underwear', 'floor', 'bedroom', 'food_cake', 'computer', 'stovefan', 'ceilinglamp', 'oil', 'couch', 'powersocket', 'cutting_board', 'food_cheese', 'photoframe', 'food_food', 'razor', 'oven_mitts', 'coffee_pot', 'mouse', 'shoes', 'dishrack', 'chessboard', 'cupboard', 'controller', 'food_steak', 'hairdryer', 'spoon']  Task:Clean  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:['food_bread', 'food_ice_cream', 'mop', 'microwave', 'detergent', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'candle', 'wall', 'bed', 'television', 'curtain', 'dresser', 'maindoor', 'table', 'dishwasher', 'vase', 'coffee']  Task:Watch TV  response:  {       thoughts : Walk to livingroom, sit on couch, grab remote and turn on tv.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'measuring_cup', 'microwave', 'jelly', 'ground_coffee', 'drawing', 'knifeblock', 'bathroom_counter', 'character', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'picture', 'mat', 'closetdrawer', 'powersocket', 'oven', 'cup', 'basket_for_clothes', 'clothes_gloves', 'novel', 'television', 'kettle', 'cupboard', 'sink', 'spoon', 'table']  Task:Read book  response:

{  Go to the book shelf, get a book, open the book and read the book. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'tablelamp', 'crayon', 'tea', 'mop', 'ground_coffee', 'detergent', 'drawing', 'floor', 'phone', 'ceilinglamp', 'laptop', 'shower', 'iron', 'window', 'oil', 'couch', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'toilet_paper', 'television', 'door', 'sink', 'table', 'scrabble', 'dirt']  Task:Read book  response:  {       thoughts : Bring book, lie on the sofa, read book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>']  }     Scene_Objects:['dry_pasta', 'food_pizza', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'bathroom', 'woman', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'desk', 'man', 'button', 'deck_of_cards', 'mousepad', 'clothes_pants', 'child', 'coffe_maker', 'tray', 'comb', 'dresser', 'cupboard', 'hairbrush', 'soap', 'tooth_paste']  Task:Greet guests  response:

{  Greet guests when they knock on the door and invite them to enter my home }


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', 'sheets', 'tablelamp', 'toilet', 'chair', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'check', 'television', 'curtain', 'lighter', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:  {       thoughts : walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'food_bread', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'mat', 'toaster', 'shower', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'food_vegetable', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'tooth_paste']  Task:Cook some food  response:

{  I prepare meals and cook them on the 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:['filing_cabinet', 'chair', 'knifeblock', 'knife', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'mail', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'stereo', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'novel', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'laundry_detergent', 'hairdryer', 'sink', 'home_office', 'dishwasher']  Task:Make coffee  response:  {       thoughts : Making coffee,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'oven_mitts', 'wooden_spoon', 'doorjamb', 'mouse', 'pajamas', 'door', 'light', 'table']  Task:Write an email  response:

{  Compose an email in the home office. }


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:['spectacles', 'sheets', 'tablelamp', 'toilet', 'chair', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'check', 'television', 'curtain', 'lighter', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:

{  walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['beer', 'microwave', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'keyboard', 'ceilinglamp', 'mat', 'picture', 'window', 'couch', 'dining_room', 'wall', 'oven', 'powersocket', 'toy', 'photoframe', 'television', 'oven_mitts', 'tray', 'centerpiece', 'kettle', 'towel_rack', 'pencil', 'dishrack', 'table', 'vase']  Task:Relax on sofa  response:  {       thoughts : go to the living room and sit on the couch, ease into the sofa and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'food_butter', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'button', 'table_cloth', 'stovefan', 'mat', 'brush', 'stereo', 'picture', 'mousepad', 'couch', 'clothes_pants', 'food_jam', 'powersocket', 'oven', 'newspaper', 'cards', 'shoes', 'controller', 'clothes_skirt', 'board_game']  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:['freezer', 'walllamp', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'video_game_console', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'video_game_controller', 'television', 'food_rice', 'ice', 'curtain', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet', 'table', 'laser_pointer']  Task:Play games  response:  {       thoughts : Turn on game.  Use controller,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack']  Task:Make coffee  response:

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


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', 'freezer', 'walllamp', 'bathroom', 'dough', 'knife', 'orchid', 'thread', 'computer', 'ceilinglamp', 'deck_of_cards', 'shower', 'clothes_socks', 'food_noodles', 'dustpan', 'nightstand', 'photoframe', 'light_bulb', 'television', 'coffee_filter', 'mirror', 'curtain', 'doorjamb', 'laundry_detergent', 'sink', 'bag', 'table', 'soap', 'clothes_shirt', 'creditcard']  Task:Look at mirror  response:  {       thoughts : I look at my reflection to check my cleanliness.,       actions : ['[WALK] <bathroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>']  }     Scene_Objects:['microwave', 'dog', 'walllamp', 'cat', 'knifeblock', 'drawing', 'bills', 'floor', 'ceiling', 'clothes_jacket', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'dish_soap', 'food_noodles', 'mousepad', 'couch', 'wall', 'nightstand', 'mouthwash', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'conditioner', 'door', 'sink', 'dishwasher']  Task:Wash dishes by hand  response:

{  Walk to Kitchen, find sink, find dishes and dish soap. Put soap on plate. open faucet, rinse dishes close faucet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'keys', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light', 'table']  Task:Relax on sofa  response:  {       thoughts : I want to relax on the sofa to some relaxing music in the living room.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['sponge', 'toilet', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'mat', 'shower', 'food_noodles', 'couch', 'towel', 'wall', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'newspaper', 'water', 'food_donut', 'curtain', 'doorjamb', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap', 'tooth_paste']  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:['dry_pasta', 'pot', 'water_glass', 'tablelamp', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'tea_bag', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'water', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bag', 'table', 'dishwasher', 'light']  Task:Drink  response:  {       thoughts : Going to the kitchen to get a drink of water.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <water_glass> <sink>', '[GRAB] <water_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <water_glass>', '[FIND] <kitchen_counter>', '[PUTBACK] <water_glass> <kitchen_counter>']  }     Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'detergent', 'food_butter', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'remote_control', 'button', 'piano_bench', 'toaster', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'clothes_pants', 'pillow', 'towel', 'wall', 'novel', 'razor', 'diary', 'conditioner', 'table', 'coffee']  Task:Change TV channel  response:

{  Take the Tv Remote Control  in the Living Room table And Press the Channel Change Button to change the channel }


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', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light']  Task:Go to toilet  response:  {       thoughts : walk to bathroom , run to toilet,       actions : ['[WALK] <bathroom>', '[RUN] <toilet>']  }     Scene_Objects:['pot', 'food_pizza', 'food_salt', 'microwave', 'freezer', 'orchid', 'drawing', 'hanger', 'button', 'table_cloth', 'tvstand', 'homework', 'couch', 'dining_room', 'nightstand', 'keys', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'cards', 'kitchen_counter', 'comb', 'dresser', 'food_steak', 'home_office', 'light', 'clothes_skirt']  Task:Pet cat  response:

{  I go to the living room then go to the cat and touch 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', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'light', 'table']  Task:Watch TV  response:  {       thoughts : walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sponge', 'spectacles', 'pot', 'microwave', 'knifeblock', 'floor', 'ceiling', 'folder', 'character', 'toaster', 'plate', 'drying_rack', 'faucet', 'dish_soap', 'couch', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'dirt', 'coffee']  Task:Wash dishes by hand  response:

{  I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off. }


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', '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:  {       thoughts : 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.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['sponge', 'sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom_counter', 'ceiling', 'folder', 'shower', 'iron', 'window', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'toy', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'food_food', 'tray', 'cd', 'dishrack', 'door', 'napkin', 'light', 'dishwasher', '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:['filing_cabinet', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'mat', 'closetdrawer', 'teeth', 'dining_room', 'wall', 'pasta', 'toy', 'shelf', 'standingmirror', 'novel', 'check', 'television', 'curtain', 'console', 'dresser', 'napkin', 'table', 'light', 'scrabble', 'coffee']  Task:Look at painting  response:  {       thoughts : Walk to the painting.  Look up at the painting.  Admire it on the wall.,       actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']  }     Scene_Objects:['tablelamp', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'mat', 'tvstand', 'shower', 'homework', 'dining_room', 'wall', 'bed', 'clothes_gloves', 'toothbrush_holder', 'after_shave', 'doorjamb', 'mouse', 'pencil', 'cd', 'tooth_paste', 'shoe_rack']  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', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap']  Task:Read book  response:  {       thoughts : Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']  }     Scene_Objects:['fork', 'juice', 'food_salt', 'measuring_cup', 'chair', 'detergent', 'milk', 'drawing', 'kitchen_cabinet', 'floor', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'plate', 'tvstand', 'candle', 'towel', 'food_cheese', 'light_bulb', 'television', 'razor', 'curtain', 'kitchen_counter', 'headset', 'table', 'soap']  Task:Set up table  response:

{  Walk into kitchen. Grab plates and forks. Walk into dining room. Put plates and forks on table. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack']  Task:Read book  response:  {       thoughts : Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']  }     Scene_Objects:['food_salt', 'ceiling', 'phone', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'homework', 'mousepad', 'food_jam', 'form', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'television', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'controller', 'laundry_detergent', 'door', 'napkin', 'light', 'dishwasher', 'table', 'teeth']  Task:Pick up phone  response:

{  I walk to the home office. I find the telephone. I pick up the telephone handset. }


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', 'tea', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'piano_bench', 'mat', 'shoe-shine_kit', 'balanceball', 'oil', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouthwash', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'door', 'home_office', 'light', 'soap']  Task:Turn on light  response:  {       thoughts : switching on the light,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['sheets', 'food_pizza', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'alcohol', 'mat', 'shower', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'coffee']  Task:Put groceries in Fridge  response:

{  I get my groceries and go to the fridge. I open the fridge and put the groceries there. }


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', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'novel', 'check', 'television', 'curtain', 'conditioner', 'hairdryer', 'clothes_dress', 'table']  Task:Watch TV  response:  {       thoughts : watching TV from sofa,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['pot', 'mop', 'microwave', 'walllamp', 'detergent', 'food_carrot', 'knifeblock', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'stereo', 'window', 'oil', 'clothes_socks', 'wall', 'oven', 'food_vegetable', 'bed', 'photoframe', 'television', 'food_donut', 'water', 'tray', 'kitchen_counter', 'cupboard', 'dishwasher']  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:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game']  Task:Write  school paper  response:  {       thoughts : Writing  and drafting a paper for  class work,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer']  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:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light']  Task:Read book  response:  {       thoughts : Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']  }     Scene_Objects:['spectacles', 'filing_cabinet', 'blender', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'dining_room', 'nightstand', 'wall_clock', 'video_game_controller', 'food_donut', 'curtain', 'kettle', 'shoes', 'dresser', 'cupboard', 'hairbrush', 'controller', 'home_office', 'light', 'clothes_skirt', 'soap']  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:['filing_cabinet', 'microwave', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'character', 'keyboard', 'toaster', 'plate', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'dining_room', 'oven', 'powersocket', 'cup', 'bed', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'dresser', 'sink', 'bathtub', 'home_office', 'table']  Task:Drink  response:  {       thoughts : I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.,       actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'bathroom', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'ceiling', 'folder', 'character', 'keyboard', 'bookshelf', 'envelope', 'computer', 'dining_room', 'wall', 'nightstand', 'cup', 'clothes_gloves', 'light_bulb', 'check', 'curtain', 'pencil', 'kitchen_counter', 'controller', 'sink', 'napkin', 'clothes_skirt', 'tooth_paste']  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:['freezer', 'cat', 'drawing', 'knife', 'knifeblock', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'faucet', 'iron', 'window', 'mousepad', 'couch', 'form', 'dining_room', 'wall', 'oven', 'box', 'newspaper', 'bed', 'novel', 'toilet_paper', 'television', 'tray', 'sink', 'table']  Task:Pet cat  response:  {       thoughts : I walk to the living room.  I locate the cat.  I walk to the couch and sit down beside the cat.  I pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'measuring_cup', 'microwave', 'dog', 'orchid', 'wallshelf', 'floor', 'bedroom', 'computer', 'mop_bucket', 'ceilinglamp', 'faucet', 'electric_shaver', 'couch', 'food_peanut_butter', 'broom', 'cutting_board', 'photoframe', 'newspaper', 'mouthwash', 'ice', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'headset', 'bathroom_cabinet', '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:['tablelamp', 'crayon', 'toilet', 'chair', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'computer', 'tvstand', 'faucet', 'stereo', 'food_orange', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'home_office']  Task:Get dressed  response:  {       thoughts : I get dressed in my bedroom in the mornings.,       actions : ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']  }     Scene_Objects:['sponge', 'microwave', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'folder', 'desk', 'alcohol', 'stovefan', 'plate', 'mousepad', 'wall', 'oven', 'food_food', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'sink', 'clothes_scarf', 'light', 'clothes_shirt', 'teeth']  Task:Pick up phone  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'mop', 'microwave', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'orchid', 'drawing', 'clothes_underwear', 'floor', 'thread', 'mat', 'closetdrawer', 'wall', 'nightstand', 'toy', 'standingmirror', 'light_bulb', 'novel', 'check', 'tray', 'cards', 'mouse', 'pencil', 'vacuum_cleaner', 'headset', 'maindoor', 'napkin', 'light']  Task:Read book  response:  {       thoughts : Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,       actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['pot', 'freezer', 'blow_dryer', 'bathroom', 'nail_polish', 'drawing', 'knife', 'cpuscreen', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'bookmark', 'faucet', 'homework', 'nightstand', 'wall', 'novel', 'check', 'coffee_filter', 'coffee_pot', 'shaving_cream', 'kitchen_counter', 'pajamas', 'cupboard', 'clothes_dress', 'laundry_detergent', 'napkin', 'table', 'washing_machine']  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:['measuring_cup', 'mop', 'walllamp', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'tvstand', 'window', 'clothes_socks', 'closetdrawer', 'oil', 'dining_room', 'wall', 'toy', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'console', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'bathroom_cabinet', 'table', 'tooth_paste']  Task:Put away shoes  response:  {       thoughts : Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.,       actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'dough', 'knifeblock', 'hanger', 'keyboard', 'alcohol', 'toaster', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'check', 'television', 'razor', 'tray', 'doorjamb', 'chessboard', 'dishrack', 'hairbrush', 'napkin', 'bathroom_cabinet', 'light', 'dishwasher', 'table']  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:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack']  Task:Play games  response:  {       thoughts : Turn on game.  Use controller,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'toaster', 'shower', 'food_noodles', 'oil', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']  Task:Cook some food  response:

{  I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food. }


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', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble']  Task:Wash dishes  response:  {       thoughts : Place all of the dirty dishes in a sink full of clean, soapy water.  Wash them.  Rinse them in fresh, running water.  Place them in the strainer to dry.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[SWITCHON] <faucet>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[GRAB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'chair', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'thread', 'ceilinglamp', 'laptop', 'faucet', 'mousepad', 'couch', 'candle', 'food_jam', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'tray', 'after_shave', 'food_onion', 'shoes', 'cupboard']  Task:Relax on sofa  response:

{  I walk to the living room. I sit in the sofa and I 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:['filing_cabinet', 'band-aids', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'stamp', 'desk', 'cleaning_solution', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'tvstand', 'window', 'couch', 'wall', 'nightstand', 'coffe_maker', 'television', 'mirror', 'after_shave', 'paper_towel', 'clothes_dress', 'sink', 'bag', 'bathroom_cabinet', 'dishwasher', 'laser_pointer']  Task:Clean mirror  response:  {       thoughts : First spray the mirrors with Windex or window type spray.  Take paper towels and wipe until sparkly clean.  If they have streaks, repeat the process.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'chair', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'bedroom', 'button', 'plate', 'dish_soap', 'wall', 'nightstand', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'check', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'door', 'table', 'dishwasher', 'light']  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:['sponge', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard']  Task:Relax on sofa  response:  {       thoughts : walk to living room, walk to sofa, sit on sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['spectacles', 'food_salt', 'microwave', 'walllamp', 'dough', 'hanger', 'ceiling', 'phone', 'character', 'keyboard', 'bookmark', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'oil', 'food_peanut_butter', 'tape', 'check', 'video_game_controller', 'razor', 'oven_mitts', 'food_rice', 'curtain', 'kitchen_counter', 'hairbrush', 'food_steak', 'bathroom_cabinet', 'home_office']  Task:Listen to music  response:

{  I walk into the bedroom. I walk to stereo. I turn on stereo. }


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', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'stereo', 'shower', 'mousepad', 'closetdrawer', 'dustpan', 'wall', 'powersocket', 'box', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'printing_paper']  Task:Print out papers  response:  {       thoughts : Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,       actions : ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']  }     Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'beer', 'toilet', 'jelly', 'freezer', 'blow_dryer', 'detergent', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'mail', 'computer', 'bookmark', 'stereo', 'window', 'couch', 'microphone', 'check', 'television', 'rag', 'pencil', 'controller', 'dishwasher']  Task:Pet cat  response:


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', 'bathroom', 'knife', 'bathroom_counter', 'floor', 'shampoo', 'ceiling', 'stovefan', 'mat', 'faucet', 'mousepad', 'couch', 'food_peanut_butter', 'dustpan', 'towel', 'wall', 'wall_clock', 'oven', 'novel', 'ice', 'tray', 'rag', 'shoes', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'tooth_paste', 'hands_both']  Task:Wash hands  response:  {       thoughts : I go to the sink, turn on the water,  put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'orchid', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'button', 'alcohol', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'check', 'mouthwash', 'television', 'coffe_maker', 'curtain', 'dresser', 'clothes_dress', 'door', 'sink', 'table']  Task:Change TV channel  response:

{  I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed. }


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', 'filing_cabinet', 'chair', 'walllamp', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'window', 'couch', 'clothes_pants', 'wall', 'cup', 'novel', 'toilet_paper', 'television', 'wine', 'kitchen_counter', 'dishrack', 'comb', 'dresser', 'coffee_cup', 'table', 'teeth']  Task:Relax on sofa  response:  {       thoughts : you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']  }     Scene_Objects:['tablelamp', 'beer', 'crayon', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'food_cake', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'television', 'curtain', 'pencil', 'kitchen_counter', 'door']  Task:Relax on sofa  response:

{  I walk to the sofa, and lie down on the sofa. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'mop', 'toilet', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'food_food', 'mouthwash', 'television', 'food_donut', 'curtain', 'after_shave', 'dresser', 'table']  Task:Look at painting  response:  {       thoughts : Walk to the painting.  Look up at the painting.  Admire it on the wall.,       actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']  }     Scene_Objects:['tablelamp', 'juice', 'toilet', 'freezer', 'walllamp', 'detergent', 'milk', 'drawing', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'ceilinglamp', 'shower', 'food_orange', 'pillow', 'dining_room', 'nightstand', 'wall', 'powersocket', 'photoframe', 'newspaper', 'food_food', 'toothbrush_holder', 'doorjamb', 'door', 'sink', 'light']  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:['dry_pasta', 'food_ice_cream', 'walllamp', 'nail_polish', 'cat', 'orchid', 'drawing', 'floor', 'ceiling', 'purse', 'alcohol', 'mail', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'towel', 'wall', 'oven', 'cup', 'food_cheese', 'television', 'curtain', 'doorjamb', 'door', 'table', 'clothes_shirt']  Task:Straighten paintings on wall  response:  {       thoughts : Go up to the painting and tilt it which ever way it is uneven until it looks straight.,       actions : ['[WALK] <home_office>', '[WALK] <wall>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']  }     Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'orchid', 'knifeblock', 'wallshelf', 'character', 'keyboard', 'stovefan', 'mat', 'closetdrawer', 'dining_room', 'food_kiwi', 'box', 'cup', 'bed', 'coffe_maker', 'television', 'water', 'colander', 'tray', 'curtain', 'kitchen_counter', 'cd', 'cupboard', 'door', 'bag', 'soap', 'creditcard']  Task:Wash hands  response:

{  put soap on hands, scrub it and rinse with water }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'bathroom_counter', 'bedroom', 'keyboard', 'button', 'toaster', 'tvstand', 'food_noodles', 'pillow', 'check', 'television', 'oven_mitts', 'wine', 'curtain', 'rag', 'doorjamb', 'kettle', 'mouse', 'pencil', 'hairbrush', 'food_steak', 'home_office', 'dishwasher']  Task:Pet cat  response:  {       thoughts : Find the cat; pet the cat by touching it,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['food_bread', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'wallshelf', 'floor', 'shampoo', 'character', 'computer', 'bookmark', 'toaster', 'plate', 'faucet', 'shoe-shine_kit', 'dish_soap', 'wall', 'toy', 'light_bulb', 'coffe_maker', 'rag', 'kitchen_counter', 'hairbrush', 'cupboard', 'dresser', 'controller', 'sink', 'home_office', 'table', 'dishwasher']  Task:Wash dishes by hand  response:

{  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:['tablelamp', 'chair', 'ground_coffee', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'keyboard', 'mail', 'mat', 'faucet', 'wall', 'nightstand', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'curtain', 'doorjamb', 'diary', 'cupboard', 'door', 'sink', 'instrument_guitar']  Task:Read book  response:  {       thoughts : Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.,       actions : ['[WALK] <bedroom>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']  }     Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'food_ice_cream', 'jelly', 'bathroom', 'orchid', 'knifeblock', 'wallshelf', 'bathroom_counter', 'desk', 'keyboard', 'ceilinglamp', 'iron', 'stereo', 'closetdrawer', 'clothes_pants', 'food_jam', 'cup', 'photoframe', 'toothbrush_holder', 'tray', 'curtain', 'centerpiece', 'coffee_pot', 'kitchen_counter', 'door', 'spoon', 'dishwasher', 'clothes_shirt']  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:['mop', 'chair', 'jelly', 'walllamp', 'drawing', 'wallshelf', 'food_egg', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'food_rice', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'coffee']  Task:Watch  horror  movie  response:  {       thoughts : I would  find something  scary  to  watch on dvd,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'water_glass', 'pot', 'glue', 'filing_cabinet', 'knife', 'wallshelf', 'bathroom_counter', 'stamp', 'bedroom', 'keyboard', 'clothes_jacket', 'piano_bench', 'electric_shaver', 'food_jam', 'cutting_board', 'novel', 'check', 'coffee_filter', 'water', 'ice', 'curtain', 'food_onion', 'pencil', 'kitchen_counter', 'cd', 'headset', 'dresser', 'door', 'light']  Task:Drink  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', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Using dishwasher to wash dishes,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['sheets', 'blender', 'food_salt', 'crayon', 'tea', 'cat', 'milk', 'knifeblock', 'hanger', 'shampoo', 'bedroom', 'bookshelf', 'computer', 'brush', 'stovefan', 'toaster', 'foundation', 'window', 'mousepad', 'clothes_pants', 'clothes_hat', 'tape', 'bed', 'coffe_maker', 'food_onion', 'after_shave', 'dresser', 'light', 'dishwasher', 'laser_pointer']  Task:Pet cat  response:

{  Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner. }


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', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'keyboard', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'cupboard', 'door', 'light', 'table']  Task:Gaze out window  response:  {       thoughts : Look at the yard from the window,       actions : ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']  }     Scene_Objects:['fork', 'filing_cabinet', 'food_pizza', 'knifeblock', 'food_egg', 'hanger', 'phone', 'desk', 'tea_bag', 'purse', 'envelope', 'clothes_jacket', 'table_cloth', 'faucet', 'window', 'closetdrawer', 'clothes_pants', 'food_jam', 'wall', 'basket_for_clothes', 'bed', 'cd', 'comb', 'laundry_detergent', 'clothes_scarf', 'napkin', 'home_office', 'bathroom_cabinet', 'washing_machine', 'teeth']  Task:Wash clothes  response:

{  Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine. }


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', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : Using dishwasher to wash dishes,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['toilet', 'chair', 'dog', 'ground_coffee', 'detergent', 'floor', 'ceiling', 'shampoo', 'envelope', 'clothes_jacket', 'piano_bench', 'ceilinglamp', 'mat', 'couch', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'coffee_pot', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'pajamas', 'bathroom_cabinet', 'light', 'dishwasher']  Task:Make coffee  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:['food_bread', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'crayon', 'chair', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cup', 'bed', 'keys', 'food_food', 'television', 'food_onion', 'doorjamb', 'mouse', 'home_office']  Task:Lock door  response:  {       thoughts : Turn the lock.,       actions : ['[WALK] <bedroom>']  }     Scene_Objects:['fork', 'tablelamp', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'envelope', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'check', 'video_game_controller', 'television', 'kitchen_counter', 'hairdryer', 'light', 'table']  Task:Relax on sofa  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_cake', 'mat', 'faucet', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'toilet_paper', 'television', 'water', 'drinking_glass', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'table']  Task:Drink  response:  {       thoughts : I go to the kitchen to get a glass from the cabinet. I turn on the faucet and fill up the glass. I take a drink.,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <water>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'milk', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'folder', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'bed', 'television', 'razor', 'toothbrush_holder', 'tray', 'curtain', 'dresser', 'laundry_detergent', 'table']  Task:Watch TV  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:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table']  Task:Pick up phone  response:  {       thoughts : I walk to the home office. I find the telephone. I pick up the telephone handset.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['dry_pasta', 'tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'bed', 'coffe_maker', 'television', 'curtain', 'dresser', 'door', 'instrument_guitar', 'table']  Task:Watch TV  response:

{  I go to the living room, switch on the tv, take the remote and sit on the sofa. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'tape', 'photoframe', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'light']  Task:Use laptop  response:  {       thoughts : Sit down on a couch and perform tasks such as navigating the internet on a laptop,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']  }     Scene_Objects:['chair', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard']  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:['filing_cabinet', 'food_ice_cream', 'chair', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'mousepad', 'couch', 'towel', 'wall', 'bed', 'photoframe', 'curtain', 'after_shave', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both', 'shoe_rack']  Task:Wash hands  response:  {       thoughts : Wash hands with soap and hot water,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['juice', 'microwave', 'toilet', 'ground_coffee', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'phone', 'character', 'bookshelf', 'computer', 'table_cloth', 'mat', 'tvstand', 'shower', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'novel', 'food_food', 'video_game_controller', 'check', 'food_onion', 'doorjamb', 'napkin', 'home_office', 'coffee']  Task:Listen to music  response:

{  I walk into the living room. I find the stereo and turn it on, and I listen to the 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:['microwave', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'shower', 'closetdrawer', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'sink', 'home_office', 'table', 'light', 'coffee']  Task:Walk through  response:  {       thoughts : Walk through the hallway.,       actions : ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']  }     Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game']  Task:Brush teeth  response:

{  EARLY MORNING AND BEFORE GOING TO BED }