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', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'cards', 'dresser', 'door', 'colander']  Task:Change TV channel  response:  {       thoughts : I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['pot', 'microwave', 'detergent', 'toothbrush', 'orchid', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'teeth', 'couch', 'pillow', 'nightstand', 'wall_clock', 'wall', 'powersocket', 'cup', 'photoframe', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'home_office', 'table', 'tooth_paste', 'coffee']  Task:Wash teeth  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher']  Task:Change TV channel  response:  {       thoughts : I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['food_bread', 'measuring_cup', 'chair', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'keyboard', 'alcohol', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'oven', 'bench', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'toothbrush_holder', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'home_office', 'tooth_paste']  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:['filing_cabinet', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'desk', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_orange', 'pillow', 'form', 'dining_room', 'wall', 'bench', 'coffe_maker', 'television', 'rag', 'pencil', 'comb', 'table', 'tooth_paste', 'clothes_shirt', 'scrabble', 'creditcard']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']  }     Scene_Objects:['water_glass', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'chair', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'check', 'television', 'curtain', 'mouse', 'door', 'home_office', 'table', 'bathroom_cabinet', 'light']  Task:Do homework  response:  {       thoughts : Sit on the couch in the Living room and pick u some papers,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <check>', '[GRAB] <check>', '[DROP] <check>']  }     Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'food_steak', 'sink', 'bathroom_cabinet', 'table']  Task:Browse internet  response:

{  I sit at my computer desk and open the browser. }


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', 'chair', 'detergent', 'food_carrot', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'balanceball', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'tray', 'doorjamb', 'cards', 'mouse', 'shaving_cream', 'shoes', 'dresser', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'vase']  Task:Turn on light  response:  {       thoughts : switching on light in an area,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'bathroom', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'computer', 'button', 'toaster', 'mat', 'stereo', 'foundation', 'window', 'couch', 'bench', 'oven', 'cup', 'check', 'television', 'tray', 'dresser', 'home_office', 'light', 'bathroom_cabinet']  Task:Listen to music  response:

{  Walk into living room, look for radio, grab on button }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']  Task:Pick up phone  response:  {       thoughts : Enter the Home office, then walk to the phone, pickup the phone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'bed', 'coffe_maker', 'television', 'food_donut', 'doorjamb', 'mouse', 'door', 'table', 'shoe_rack']  Task:Work  response:

{  Walk to living-room. Look at the desk where Computer stays. Sit in chair. Switch on computer. Work on computer. Switch off computer. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'ceilingfan', 'drawing', 'needle', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table', 'laser_pointer']  Task:Watch TV  response:  {       thoughts : Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch the television.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'bed', 'television', 'doorjamb', 'centerpiece', 'mouse', 'door', 'bathtub', 'sink', 'napkin', 'table', 'light']  Task:Work  response:

{  Sit down on chair in front of computer, turn on computer, find mouse. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'crayon', 'detergent', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'ceiling', 'keyboard', 'stovefan', 'tvstand', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'basket_for_clothes', 'television', 'centerpiece', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'clothes_dress', 'laundry_detergent', 'door', 'sink', 'table', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine.,       actions : ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['pot', 'tablelamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'keyboard', 'envelope', 'stovefan', 'toaster', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'bench', 'food_vegetable', 'bed', 'coffe_maker', 'check', 'water', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard']  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:['sponge', 'sheets', 'filing_cabinet', 'food_bread', 'toilet', 'ground_coffee', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'plate', 'iron', 'mousepad', 'wall', 'oven', 'photoframe', 'light_bulb', 'coffe_maker', 'centerpiece', 'mouse', 'dresser', 'maindoor']  Task:Go to toilet  response:  {       thoughts : I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[TURNTO] <toilet>', '[LOOKAT] <toilet>', '[WALK] <toilet>', '[TURNTO] <toilet>']  }     Scene_Objects:['microwave', 'chair', 'freezer', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'food_cake', 'envelope', 'computer', 'ceilinglamp', 'window', 'mousepad', 'clothes_socks', 'closetdrawer', 'wall', 'toy', 'cup', 'coffe_maker', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table']  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:['microwave', 'freezer', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'toaster', 'window', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'wall_clock', 'television', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'clothes_shirt']  Task:Organize closet  response:  {       thoughts : Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear.,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[CLOSE] <dresser>', '[WALK] <basket_for_clothes>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>']  }     Scene_Objects:['filing_cabinet', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'plate', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'bathtub', 'light', 'table']  Task:Pet cat  response:

{  My cat looks like it wants attention, so I will go pet it on the couch. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'tablelamp', 'measuring_cup', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'character', 'desk', 'bedroom', 'table_cloth', 'mat', 'shower', 'stereo', 'microphone', 'clothes_hat', 'pillow', 'nightstand', 'wall_clock', 'oven', 'keys', 'light_bulb', 'check', 'razor', 'tray', 'doorjamb', 'dresser', 'clothes_dress', 'bag', 'dishwasher']  Task:Listen to music  response:  {       thoughts : I find a radio. I turn on the radio. I listen to music.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'detergent', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'wall_clock', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'table', 'light']  Task:Pet cat  response:

{  I see my cat on the couch so I walk over, sit down and pet the cat. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'chair', 'bathroom', 'orchid', 'knifeblock', 'floor', 'phone', 'desk', 'keyboard', 'food_cake', 'foundation', 'floor_lamp', 'pillow', 'nightstand', 'powersocket', 'box', 'basket_for_clothes', 'razor', 'tray', 'doorjamb', 'cupboard', 'bathtub', 'spoon', 'home_office', 'table', 'bathroom_cabinet', 'light', 'dishwasher']  Task:Turn on light  response:  {       thoughts : walk to living room, find lamp, switch on.,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>']  }     Scene_Objects:['tablelamp', 'microwave', 'freezer', 'band-aids', 'cat', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'folder', 'desk', 'tea_bag', 'keyboard', 'stovefan', 'toaster', 'shower', 'faucet', 'couch', 'bench', 'photoframe', 'coffe_maker', 'television', 'tray', 'vacuum_cleaner', 'hairbrush', 'dresser', 'door', 'bathtub', 'light']  Task:Pet cat  response:

{  Find the cat; pet the cat by touching 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:['sheets', 'microwave', 'toilet', 'chair', 'band-aids', 'cat', 'food_carrot', 'knife', 'foundation', 'electric_shaver', 'mousepad', 'clothes_socks', 'pillow', 'dining_room', 'nightstand', 'oven', 'toy', 'check', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'chessboard', 'cupboard', 'conditioner', 'door', 'food_steak', 'clothes_skirt', 'duster']  Task:Dust  response:  {       thoughts : Get a broom or duster with long handle. Dust blades of ceiling fan.,       actions : ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>']  }     Scene_Objects:['toilet', 'walllamp', 'trashcan', 'drawing', 'floor', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'shower', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'novel', 'coffe_maker', 'television', 'tray', 'curtain', 'cupboard', 'controller', 'door', 'bathtub', 'table', 'light']  Task:Read book  response:

{  Walk to the couch in the living room, sit on ti 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', 'microwave', 'detergent', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'mail', 'toaster', 'stovefan', 'faucet', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'coin', 'drinking_glass', 'water', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'sink', 'dishwasher', 'coffee']  Task:Drink  response:  {       thoughts : I walk to the kitchen and approach the sink. I take a drinking glass and set it under the faucet. I turn the faucet until the water fills the glass, then turn it back. Finally I lift the glass out of the sink and drink the water.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'desk', 'envelope', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'oven_mitts', 'curtain', 'controller', 'home_office', 'table']  Task:Relax on sofa  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'toilet', 'walllamp', 'cat', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'food_cake', 'piano_bench', 'shower', 'faucet', 'pillow', 'wall', 'photoframe', 'bed', 'curtain', 'doorjamb', 'diary', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'soap', 'instrument_violin']  Task:Go to toilet  response:  {       thoughts : Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'shower', 'window', 'food_kiwi', 'wall', 'bench', 'newspaper', 'food_food', 'coffe_maker', 'food_onion', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'home_office']  Task:Put groceries in Fridge  response:

{  walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'food_butter', 'dough', 'food_carrot', 'drawing', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'powersocket', 'oven', 'wall_clock', 'cutting_board', 'food_food', 'coffe_maker', 'oven_mitts', 'wooden_spoon', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'maindoor', 'sink', 'bathroom_cabinet', 'light']  Task:Cook some food  response:  {       thoughts : I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[WALK] <oven>', '[PUTBACK] <food_chicken> <oven>']  }     Scene_Objects:['food_pizza', 'filing_cabinet', 'nail_polish', 'toothbrush', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'food_food', 'toothbrush_holder', 'tray', 'dresser', 'cupboard', 'controller', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'light', 'tooth_paste']  Task:Wash teeth  response:

{  I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'microwave', 'toilet', 'walllamp', 'cat', 'food_carrot', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'mop_bucket', 'stovefan', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'bed', 'novel', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'controller', 'door', 'food_steak', 'spoon', 'light']  Task:Turn on light  response:  {       thoughts : I walk to wall. I put my hand on the switch. I push the button. I turn on the lights.,       actions : ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'food_chicken', 'stovefan', 'mat', 'toaster', 'shower', 'faucet', 'window', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink']  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:['fork', 'scissors', 'microwave', 'bathroom', 'nail_polish', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'faucet', 'window', 'electric_shaver', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'newspaper', 'keys', 'television', 'curtain', 'doorjamb', 'diary', 'sink', 'spoon', 'table', 'soap']  Task:Relax on sofa  response:  {       thoughts : Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'coffe_maker', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'table']  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:['scissors', 'toilet', 'chair', 'walllamp', 'ceilingfan', 'bathroom_counter', 'floor', 'phone', 'character', 'mail', 'computer', 'toaster', 'foundation', 'clothes_socks', 'food_peanut_butter', 'dining_room', 'wall', 'oven', 'powersocket', 'tape', 'cup', 'coffe_maker', 'video_game_controller', 'television', 'tray', 'curtain', 'cd', 'maindoor', 'bathroom_cabinet', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['microwave', 'toilet', 'jelly', 'dog', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'stereo', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'curtain', 'mouse', 'cupboard', 'bathtub', 'home_office', 'light', 'bathroom_cabinet']  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:['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:['filing_cabinet', 'shoe_rack', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'mat', 'window', 'dish_soap', 'couch', 'pillow', 'wall', 'basket_for_clothes', 'bed', 'towel_rack', 'light', 'dishwasher', 'creditcard']  Task:Wash dishes with dishwasher  response:

{  Wash a plate using the dishwasher in the kitchen. }


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', 'crayon', 'cat', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'food_cake', 'computer', 'brush', 'electric_shaver', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'toy', 'food_food', 'towel_rack', 'mouse', 'dresser', 'pajamas', 'sink', 'napkin', 'light', 'colander', 'tooth_paste']  Task:Pick up toys  response:  {       thoughts : Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <toy> <dresser>', '[CLOSE] <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'bathroom', 'food_butter', 'milk', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'coffe_maker', 'television', 'tray', 'curtain', 'dresser', 'bathtub', 'bathroom_cabinet', 'table']  Task:Pick up phone  response:

{  Walk to the entrance hall. Find the telephone. Grab the telephone. }


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', 'microwave', 'food_butter', 'knife', 'wallshelf', 'bathroom_counter', 'phone', 'character', 'bedroom', 'keyboard', 'computer', 'faucet', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'oven', 'shelf', 'cup', 'bed', 'food_rice', 'tray', 'mouse', 'headset', 'comb', 'dresser', 'conditioner', 'home_office', 'table']  Task:Brush teeth  response:  {       thoughts : go to the bathroom and brush your teeth,       actions : ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>']  }     Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'headset', 'cupboard', 'sink', 'table']  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:['microwave', 'walllamp', 'detergent', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'phone', 'character', 'computer', 'piano_bench', 'shoe-shine_kit', 'faucet', 'food_noodles', 'mousepad', 'clothes_hat', 'towel', 'broom', 'cutting_board', 'shelf', 'keys', 'novel', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'sink', 'table', 'light', 'coffee']  Task:Change TV channel  response:  {       thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>']  }     Scene_Objects:['dry_pasta', 'filing_cabinet', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'ceiling', 'computer', 'shower', 'window', 'mousepad', 'couch', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'bench', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'razor', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'home_office', 'light', 'washing_machine']  Task:Wash clothes  response:

{  \ I walk to entrance hall\  \ I walk to bedroom\  \ I find basket of clothes\  \ I lift basket of  clothes\  \ I walk to kitchen\  \ I find washing machine\  \ I open washing machine \  \ I put laundry in washing machine\  \ I add laundry detergent\  \  \ I close washing machine lid\  \ I switch washing machine on\  }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'bathroom', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'character', 'thread', 'piano_bench', 'toaster', 'deck_of_cards', 'homework', 'couch', 'dustpan', 'powersocket', 'newspaper', 'clothes_gloves', 'novel', 'coffe_maker', 'doorjamb', 'chessboard', 'cd', 'napkin', 'home_office', 'instrument_guitar', 'clothes_skirt', 'light']  Task:Close door  response:  {       thoughts : Push the door shut until it latches.,       actions : ['[RUN] <home_office>']  }     Scene_Objects:['tablelamp', 'toilet', 'jelly', 'freezer', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'computer', 'food_bacon', 'plate', 'faucet', 'shower', 'window', 'dish_soap', 'mousepad', 'couch', 'wall', 'wall_clock', 'powersocket', 'bench', 'shoes', 'hairbrush', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office']  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:['sheets', 'mop', 'bathroom', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'food_cake', 'window', 'electric_shaver', 'microphone', 'food_jam', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'chessboard', 'dresser', 'hairbrush', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher', 'instrument_violin']  Task:Put on coat  response:  {       thoughts : I remove my scarf from a coat peg in the entrance hall.  I wrap the scarf around my neck,       actions : ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>']  }     Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'milk', 'hanger', 'bathroom_counter', 'desk', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'tray', 'curtain', 'chessboard', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'table']  Task:Pet cat  response:

{  Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with 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:['blender', 'microwave', 'toilet', 'toothbrush', 'bills', 'orchid', 'character', 'bedroom', 'stamp', 'stovefan', 'laptop', 'ceilinglamp', 'shower', 'mat', 'faucet', 'towel', 'pillow', 'dining_room', 'oven', 'coffe_maker', 'television', 'toothbrush_holder', 'comb', 'cupboard', 'door', 'sink', 'table', 'soap', 'tooth_paste', 'teeth']  Task:Brush teeth  response:  {       thoughts : Walk to bathroom. Find toothbrush.  Find toothpaste.  Put toothpaste on toothbrush.  Brush teeth.,       actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[FIND] <teeth>', '[SCRUB] <teeth>']  }     Scene_Objects:['water_glass', 'food_salt', 'microwave', 'freezer', 'orchid', 'cpuscreen', 'ceiling', 'character', 'bedroom', 'desk', 'food_bacon', 'bookmark', 'toaster', 'stovefan', 'faucet', 'shower', 'mousepad', 'wall', 'wall_clock', 'oven', 'bench', 'coffe_maker', 'television', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'light']  Task:Drink  response:

{  I go to the kitchen, take a glass from the cupboard, fill with water and drink }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tea', 'walllamp', 'detergent', 'cat', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'remote_control', 'mail', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'couch', 'wall', 'bench', 'clothes_gloves', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'home_office', 'table', 'coffee']  Task:Change TV channel  response:  {       thoughts : walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>']  }     Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'cat', 'dough', 'knife', 'bathroom_counter', 'floor', 'keyboard', 'computer', 'brush', 'laptop', 'plate', 'faucet', 'deck_of_cards', 'window', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'wall', 'oven', 'bench', 'television', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathtub']  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:['pot', 'tablelamp', 'blender', 'microwave', 'toilet', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'keyboard', 'computer', 'brush', 'mat', 'laptop', 'faucet', 'ceilinglamp', 'window', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'towel_rack', 'mouse', 'kitchen_counter', 'pajamas', 'dishwasher']  Task:Go to sleep  response:  {       thoughts : go to bedroom, put pajamas on, lie in bed, sleep,       actions : ['[WALK] <bedroom>', '[WALK] <pajamas>', '[FIND] <pajamas>', '[GRAB] <pajamas>', '[PUTON] <pajamas>', '[FIND] <bed>', '[LIE] <bed>']  }     Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'window', 'mousepad', 'wall', 'nightstand', 'powersocket', 'bench', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'cd', 'sink', 'bathtub', 'table', 'dirt']  Task:Write an email  response:

{  I go to my office and sit at my desk. Turn on the computer and type my email at the keyboard. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'knife', 'knifeblock', 'orchid', 'drawing', 'floor', 'phone', 'character', 'bedroom', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'dining_room', 'powersocket', 'newspaper', 'ice', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'home_office', 'table']  Task:Change TV channel  response:  {       thoughts : I pick up the remote. I press button on remote.,       actions : ['[WALK] <bedroom>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['tablelamp', 'beer', 'toilet', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'ceiling', 'phone', 'character', 'keyboard', 'toaster', 'mat', 'floor_lamp', 'oil', 'pillow', 'dining_room', 'nightstand', 'wall_clock', 'bench', 'novel', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table']  Task:Read book  response:

{  Turn a light on and read a book in the bedroom. }


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', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light']  Task:Turn on light  response:  {       thoughts : walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,       actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom', 'nail_polish', 'trashcan', 'food_carrot', 'hanger', 'floor', 'computer', 'toaster', 'window', 'food_jam', 'nightstand', 'oven', 'bench', 'tape', 'photoframe', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'doorjamb', 'dresser', 'pajamas', 'cupboard', 'door', 'sink', 'home_office']  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:['fork', 'microwave', 'chair', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'purse', 'computer', 'toaster', 'mat', 'tvstand', 'clothes_socks', 'food_peanut_butter', 'microphone', 'food_jam', 'pillow', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'pajamas', 'laundry_detergent', 'door', 'light', 'tooth_paste']  Task:Turn on light  response:  {       thoughts : Coming home turning on lights.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'food_food', 'television', 'doorjamb', 'mouse', 'table']  Task:Work  response:

{  turn computer on, open application to work with }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'food_bread', 'scissors', 'microwave', 'freezer', 'milk', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'food_kiwi', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'diary', 'dishrack', 'controller', 'conditioner', 'home_office']  Task:Get glass of milk  response:  {       thoughts : Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass.,       actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>']  }     Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'piano_bench', 'stovefan', 'mat', 'tvstand', 'shower', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'sink', 'table']  Task:Put groceries in Fridge  response:

{  Walk to kitchen. Grab groceries and walk to the fridge. Open fridge and put groceries in the fridge. 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:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'laptop', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dishrack', 'door', 'light', 'shoe_rack']  Task:Browse internet  response:  {       thoughts : Walk to home office, walk to desk, sit in chair, turn on laptop, grab mouse, open a web page to look at it, move mouse, keep looking at laptop screen.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']  }     Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'bookshelf', 'mail', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'oven', 'toy', 'mouthwash', 'television', 'wine', 'tray', 'curtain', 'cd', 'dresser', 'bathtub', 'sink', 'table', 'light']  Task:Relax on sofa  response:

{  go to the living room,find the sofa,sat down in the sofa,take some relaxation. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'photoframe', 'novel', 'television', 'mouse', 'kitchen_counter', 'door', 'sink', 'clothes_skirt', 'clothes_shirt']  Task:Read book  response:  {       thoughts : Go to home office, find the book. Sit in the chair and read the book.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['microwave', 'toilet', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'window', 'tvstand', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'water', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'light', 'table']  Task:Drink  response:

{  Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['scissors', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'couch', 'dining_room', 'food_kiwi', 'wall', 'toilet_paper', 'razor', 'television', 'curtain', 'diary', 'towel_rack', 'door', 'bathroom_cabinet', 'table', 'creditcard']  Task:Watch TV  response:  {       thoughts : Sit on the couch and use the remote control to turn on the TV,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['tablelamp', 'food_salt', 'orchid', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'window', 'closetdrawer', 'powersocket', 'oven', 'cup', 'curtain', 'doorjamb', 'mouse', 'comb', 'cupboard', 'clothes_dress', 'door', 'bathtub', 'home_office', 'table', 'dishwasher', 'dirt']  Task:Wash dishes with dishwasher  response:

{  Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'beer', 'crayon', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'iron', 'electric_shaver', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'novel', 'food_food', 'check', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'table']  Task:Read book  response:  {       thoughts : I go to the book case, I select a book, I go back and sit down, then I read.,       actions : ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>']  }     Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'desk', 'bookshelf', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'window', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'broom', 'nightstand', 'oven', 'bench', 'coffe_maker', 'check', 'towel_rack', 'mouse', 'cupboard', 'light', 'table']  Task:Listen to music  response:

{  I find a radio. I turn on the radio. I listen to music. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['water_glass', 'food_bread', 'food_ice_cream', 'crayon', 'microwave', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'tvstand', 'window', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'water', 'tray', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'light', 'instrument_violin']  Task:Drink  response:  {       thoughts : walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass,       actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <water>', '[GRAB] <water>', '[WALK] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['tablelamp', 'beer', 'freezer', 'bathroom', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'computer', 'ceilinglamp', 'mat', 'faucet', 'couch', 'clothes_pants', 'wall', 'wall_clock', 'bench', 'powersocket', 'nightstand', 'photoframe', 'novel', 'tray', 'curtain', 'doorjamb', 'sink', 'napkin', 'bathroom_cabinet', 'hands_both']  Task:Wash hands  response:

{  Going to the sink and scrubbing hands }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'orchid', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'picture', 'foundation', 'dish_soap', 'clothes_socks', 'pillow', 'powersocket', 'cutting_board', 'basket_for_clothes', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'sink', 'spoon', 'home_office']  Task:Wash dishes by hand  response:  {       thoughts : Pick up dish.  Put in soapy water.  Wash dish.,       actions : ['[WALK] <dining_room>', '[WALK] <dish_soap>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <dish_soap> <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WIPE] <plate>']  }     Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'wallshelf', 'phone', 'desk', 'toaster', 'stovefan', 'mat', 'shower', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'photoframe', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'bathroom_cabinet', 'light']  Task:Pet cat  response:

{  Walk into the living room. Walk up to the cat. Pet the cat with your 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:['chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'keyboard', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'toilet_paper', 'mouthwash', 'television', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:  {       thoughts : walk to living room, find sofa, sit in sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['water_glass', 'microwave', 'freezer', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'couch', 'wall', 'wall_clock', 'oven', 'keys', 'coffe_maker', 'water', 'tray', 'curtain', 'coffee_pot', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'tooth_paste']  Task:Drink  response:

{  I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink 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:['spectacles', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'desk', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'iron', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'television', 'doorjamb', 'mouse', 'door', 'home_office', 'light', 'table']  Task:Write an email  response:  {       thoughts : enter office, find computer, turn it on,,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['sheets', 'blender', 'microwave', 'toilet', 'freezer', 'detergent', 'cat', 'food_carrot', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'ceilinglamp', 'faucet', 'oil', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'bed', 'television', 'coffee_filter', 'tray', 'mouse', 'dresser', 'hair', 'light', 'table']  Task:Listen to music  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'detergent', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'window', 'oil', 'clothes_socks', 'couch', 'food_orange', 'pillow', 'wall', 'novel', 'coffe_maker', 'television', 'food_rice', 'rag', 'doorjamb', 'cupboard', 'door', 'sink', 'napkin', 'table', 'light']  Task:Relax  response:  {       thoughts : Lie down on the couch.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['filing_cabinet', 'measuring_cup', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'cup', 'photoframe', 'novel', 'check', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light', 'table']  Task:Read book  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'knife', 'hanger', 'floor', 'phone', 'ceiling', 'keyboard', 'computer', 'brush', 'deck_of_cards', 'food_jam', 'bowl', 'dining_room', 'wall', 'bench', 'razor', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'table', 'light']  Task:Pick up phone  response:  {       thoughts : Pick up phone,       actions : ['[WALK] <table>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'mousepad', 'pillow', 'dining_room', 'wall', 'coffee_table', 'novel', 'television', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'cupboard', 'light']  Task:Read book  response:

{  I walk to the living room and pick up a book from the coffee table. I find my favorite chair.  I sit in the armchair and open the book.  I read. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tea', 'microwave', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'button', 'food_bacon', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'coffee_table', 'novel', 'mouthwash', 'television', 'doorjamb', 'diary', 'clothes_scarf', 'sink']  Task:Read book  response:  {       thoughts : Sit down in recliner.  Pick up novel off of coffee table.  Open novel to last read page.  Begin reading,       actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <bookmark>', '[READ] <novel>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'freezer', 'walllamp', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'food_orange', 'nightstand', 'bench', 'photoframe', 'bed', 'food_food', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'table', 'washing_machine']  Task:Wash clothes  response:

{  Walk into laundry room. Open washing machine door. Put dirty clothes into washing machine. Measure laundry detergent and place into washing machine. Turn dial to appropriate wash setting. Power on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'freezer', 'knifeblock', 'drawing', 'wallshelf', 'ceiling', 'phone', 'desk', 'keyboard', 'face', 'toaster', 'laptop', 'tvstand', 'shower', 'stereo', 'homework', 'oil', 'towel', 'oven', 'basket_for_clothes', 'tray', 'towel_rack', 'hair', 'cupboard', 'door', 'bathtub', 'clothes_shirt']  Task:Rain welcome  response:  {       thoughts : The robot would greet me and then hand me a towel.  It would make an appropriate quip about the weather while I dried off.  It would receive the wet towel when I was done.,       actions : ['[WALK] <bedroom>', '[WALK] <towel>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <hair>', '[WIPE] <hair>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['microwave', 'toilet', 'trashcan', 'toothbrush', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'stovefan', 'faucet', 'shower', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'photoframe', 'towel_rack', 'mouse', 'cupboard', 'conditioner', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'tooth_paste']  Task:Wash teeth  response:

{  Upon entering the restroom, walk to the sink. Take a toothbrush and apply enough toothpaste so that 1/4 of the brush is covered (this is the appropriate amount). Proceed to \ brush\  your teeth using an up and down motion with the brush in your mouth. Brush for 2 minutes covering all areas of the teeth. Rinse with water and clean toothbrush with water too. }


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', 'food_bread', 'toilet', 'chair', 'freezer', 'bathroom', 'food_carrot', 'hanger', 'keyboard', 'envelope', 'mail', 'tvstand', 'clothes_pants', 'bowl', 'dining_room', 'oven', 'powersocket', 'bed', 'clothes_gloves', 'check', 'wine', 'curtain', 'food_onion', 'kettle', 'dresser', 'vase', 'home_office', 'light', 'clothes_skirt', 'dishwasher']  Task:Pick up phone  response:  {       thoughts : I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>', '[SWITCHON] <phone>']  }     Scene_Objects:['pot', 'filing_cabinet', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'laptop', 'shower', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'oven', 'cutting_board', 'coffe_maker', 'television', 'tray', 'doorjamb', 'mouse', 'hair', 'door', 'sink', 'home_office', 'table']  Task:Write an email  response:

{  I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer 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:['filing_cabinet', 'detergent', 'bills', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'mat', 'laptop', 'shower', 'faucet', 'ceilinglamp', 'mousepad', 'microphone', 'form', 'pillow', 'broom', 'wall', 'newspaper', 'after_shave', 'doorjamb', 'cd', 'comb', 'controller', 'door', 'bathroom_cabinet', 'light', 'table', 'creditcard']  Task:Turn on light  response:  {       thoughts : I walk to wall. I put my hand on the switch. I push the button. I turn on the lights.,       actions : ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'bedroom', 'computer', 'toaster', 'mat', 'oil', 'couch', 'dining_room', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'food_rice', 'tray', 'curtain', 'mouse', 'dresser', 'bathtub', 'home_office', 'table', 'bathroom_cabinet', 'coffee', 'shoe_rack']  Task:Browse internet  response:

{  I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'window', 'homework', 'couch', 'dustpan', 'food_orange', 'dining_room', 'wall', 'nightstand', 'photoframe', 'clothes_gloves', 'coffe_maker', 'check', 'television', 'mouse', 'pencil', 'table', 'laser_pointer']  Task:Relax on sofa  response:  {       thoughts : Walk to the living room, turn to the sofa. Sit on the sofa and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']  }     Scene_Objects:['blender', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'bathroom_counter', 'table_cloth', 'stovefan', 'tvstand', 'stereo', 'faucet', 'window', 'mousepad', 'dining_room', 'broom', 'nightstand', 'wall_clock', 'wall', 'oven', 'bed', 'newspaper', 'food_food', 'video_game_controller', 'wine', 'after_shave', 'curtain', 'towel_rack', 'bathtub', 'light', 'table']  Task:Listen to music  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'jelly', 'bathroom', 'detergent', 'dough', 'orchid', 'floor', 'bedroom', 'mat', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'tray', 'kitchen_counter', 'headset', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I go to the dishwasher and put dish soap. I close the dishwasher and turn it on.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'table']  Task:Browse internet  response:

{  Browsing the internet for information. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'chair', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'phone', 'folder', 'man', 'keyboard', 'mop_bucket', 'tvstand', 'faucet', 'picture', 'plate', 'mousepad', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'check', 'food_onion', 'clothes_scarf', 'spoon', 'light', 'dishwasher']  Task:Greet guests  response:  {       thoughts : When someone knocks I n the door walk through the hallway and greet them.,       actions : ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'orchid', 'drawing', 'wallshelf', 'floor', 'phone', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'mousepad', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'bed', 'novel', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light', 'laser_pointer']  Task:Read book  response:

{  Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. 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:['juice', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'thread', 'computer', 'stovefan', 'mat', 'tvstand', 'toaster', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'doorjamb', 'laundry_detergent', 'conditioner', 'sink', 'door', 'bathroom_cabinet', 'table', 'dishwasher']  Task:Do homework  response:  {       thoughts : Sit on the couch in the Living room and pick u some papers,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <check>', '[GRAB] <check>', '[DROP] <check>']  }     Scene_Objects:['food_pizza', 'mop', 'chair', 'bathroom', 'drawing', 'wallshelf', 'character', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'shower', 'faucet', 'floor_lamp', 'mousepad', 'closetdrawer', 'nightstand', 'wall', 'oven', 'bench', 'photoframe', 'bed', 'coffe_maker', 'food_food', 'check', 'conditioner', 'light', 'table', 'tooth_paste']  Task:Turn on light  response:

{  walk to living room, find lamp, switch on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'toilet', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'drawing', 'floor', 'ceiling', 'food_cake', 'stovefan', 'toaster', 'plate', 'mat', 'shower', 'food_kiwi', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'tray', 'food_onion', 'doorjamb', 'kitchen_counter', 'sauce_pan', 'cupboard', 'door', 'food_steak', 'spoon', 'light', 'dishwasher']  Task:Cook some food  response:  {       thoughts : I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate.,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <spoon>', '[GRAB] <spoon>', '[FIND] <sauce_pan>', '[PUTBACK] <spoon> <sauce_pan>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <plate>', '[PUTBACK] <pot> <plate>']  }     Scene_Objects:['fork', 'toilet', 'freezer', 'detergent', 'drawing', 'knife', 'wallshelf', 'dvd_player', 'character', 'bookshelf', 'plate', 'shower', 'tvstand', 'dish_soap', 'closetdrawer', 'pillow', 'food_kiwi', 'nightstand', 'powersocket', 'cutting_board', 'photoframe', 'wooden_spoon', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'spoon', 'light', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'floor', 'ceiling', 'keyboard', 'stovefan', 'electric_shaver', 'clothes_socks', 'form', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'food_food', 'oven_mitts', 'food_donut', 'tray', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'laundry_detergent', 'home_office', 'table', 'bathroom_cabinet', 'instrument_guitar']  Task:Put groceries in Fridge  response:  {       thoughts : go to the kitchen and put the groceries in the fridge,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>']  }     Scene_Objects:['sheets', 'food_ice_cream', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'shower', 'faucet', 'wall', 'nightstand', 'oven', 'food_food', 'video_game_controller', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink']  Task:Cook some food  response:

{  Walk Into Kitchen. Open Refrigerator. Grab Food. Walk to Microwave. Insert food into microwave. Cook until warm. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Watch youtube  response:  {       thoughts : Go to youtube.Com watch videos,       actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['microwave', 'chair', 'jelly', 'walllamp', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'envelope', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'wall', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table']  Task:Work  response:

{  Go into the office and sit down at the desk in front of the computer. Turn on the computer and look at it while clicking with the mouse and typing with the keyboard. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt']  Task:Make coffee  response:  {       thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'foundation', 'mousepad', 'wall', 'powersocket', 'television', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'light']  Task:Work  response:

{  I go to my home office, sit on the chair and turn on the computer. I open my email account to look for all the information I need.I pull up my online task on the computer to look at what the assigned task is. }


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', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall_clock', 'oven', 'tape', 'photoframe', 'dresser', 'cupboard', 'bathtub', 'light', 'dirt']  Task:Listen to music  response:  {       thoughts : I reach out arm. I put hand on radio. I turn on radio. I pick a station.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>']  }     Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'tea_bag', 'food_bacon', 'mop_bucket', 'tvstand', 'electric_shaver', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'table', 'home_office', 'colander']  Task:Turn on light  response:

{  push any ligth button to turn it on, for example in the living room }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game']  Task:Brush teeth  response:  {       thoughts : EARLY MORNING AND BEFORE GOING TO BED,       actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']  }     Scene_Objects:['jelly', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office']  Task:Turn on light  response:

{  I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it. }