Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table']  Task:Watch TV  response:  {       thoughts : Watching TV,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['food_salt', 'tea', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'light', 'table']  Task:Browse internet  response:

{  I go to my desk. I turn on the computer. I open a web page and look at 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', 'food_pizza', 'tablelamp', 'freezer', 'blow_dryer', 'trashcan', 'orchid', 'hanger', 'floor', 'computer', 'button', 'stovefan', 'ceilinglamp', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'bed', 'novel', 'tray', 'curtain', 'after_shave', 'towel_rack', 'pencil', 'maindoor', 'sink', 'light', 'dishwasher']  Task:Go to sleep  response:  {       thoughts : Walk to bedroom. Walk to bed, lie in bed.,       actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[LIE] <bed>']  }     Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'needle', 'hanger', 'floor', 'ceiling', 'dvd_player', 'stamp', 'desk', 'toaster', 'mat', 'tvstand', 'stereo', 'stovefan', 'electric_shaver', 'ceilinglamp', 'clothes_hat', 'wall_clock', 'powersocket', 'toy', 'photoframe', 'oven_mitts', 'food_donut', 'tray', 'pencil', 'comb', 'door', 'home_office', 'light']  Task:Pick up phone  response:

{  Go to the living room.  Find the telephone.  Lift up the receiver. }


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', 'orchid', 'hanger', 'ceiling', 'keyboard', 'piano_bench', 'tvstand', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'wall', 'powersocket', 'bench', 'cutting_board', 'toy', 'photoframe', 'bed', 'razor', 'wooden_spoon', 'after_shave', 'coffee_pot', 'dresser', 'clothes_dress', 'bathtub', 'bathroom_cabinet', 'light', 'clothes_shirt', 'washing_machine', 'shoe_rack']  Task:Wash clothes  response:  {       thoughts : walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off washing machine.,       actions : ['[WALK] <dining_room>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[TURNTO] <washing_machine>', '[LOOKAT] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>', '[SWITCHOFF] <washing_machine>']  }     Scene_Objects:['fork', 'chair', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'shelf', 'novel', 'television', 'food_onion', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'dresser', 'clothes_dress', 'door', 'light', 'table']  Task:Browse internet  response:

{  turn on the computer and browse the internet }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'fax_machine', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Write report  response:  {       thoughts : Sit at a desk, turn on a computer.  Open an existing document and revise it.  Print a hard copy for mailing.  Email a copy to the client.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[PULL] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TYPE] <keyboard>', '[TOUCH] <mouse>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[SWITCHOFF] <fax_machine>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['pot', 'tablelamp', 'beer', 'chair', 'band-aids', 'freezer', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'towel', 'pillow', 'wall', 'powersocket', 'clothes_gloves', 'television', 'doorjamb', 'mouse', 'dresser', 'laundry_detergent', 'maindoor', 'bag', 'light', 'table']  Task:Browse internet  response:

{  Walk to the Home Office.  Find the computer.  Turn on the 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:['mop', 'bathroom', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'bedroom', 'thread', 'computer', 'brush', 'plate', 'picture', 'window', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'box', 'bed', 'television', 'curtain', 'food_onion', 'kitchen_counter', 'maindoor', 'table', 'light', 'clothes_shirt', 'dirt', 'teeth']  Task:Read book  response:  {       thoughts : Climb into bed, then read the novel,       actions : ['[WALK] <bedroom>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <bed>', '[LIE] <bed>', '[READ] <novel>']  }     Scene_Objects:['spectacles', 'food_salt', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'nightstand', 'powersocket', 'toy', 'bed', 'coffe_maker', 'television', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'hair', 'light', 'table']  Task:Work  response:

{  Go to office, sit at desk, turn on computer, enter password, open application and begin work }


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', 'food_carrot', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'window', 'oil', 'couch', 'clothes_pants', 'pillow', 'wall', 'tape', 'cup', 'novel', 'tray', 'curtain', 'mouse', 'chessboard', 'controller', 'table']  Task:Read book  response:  {       thoughts : Sit on a couch, grab a book, open it, and scan the pages,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']  }     Scene_Objects:['sheets', 'microwave', 'cpuscreen', 'hanger', 'floor', 'bookshelf', 'bookmark', 'stovefan', 'mat', 'faucet', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'cutting_board', 'cup', 'newspaper', 'novel', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:

{  Go to the living room and relax on the sofa with a 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:['microwave', 'toilet', 'freezer', 'ground_coffee', 'walllamp', 'dough', 'food_carrot', 'floor', 'ceiling', 'stovefan', 'toaster', 'stereo', 'clothes_hat', 'wall', 'oven', 'bench', 'cutting_board', 'food_cheese', 'coffe_maker', 'food_food', 'check', 'toothbrush_holder', 'food_donut', 'tray', 'kitchen_counter', 'dishrack', 'hairbrush', 'bag', 'bathroom_cabinet', 'creditcard']  Task:Put groceries in Fridge  response:  {       thoughts : Open the fridge, put the groceries in the fridge and close it.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table', 'clothes_skirt']  Task:Write an email  response:

{  enter office, find computer, turn it on, }


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

{  I walk to wall. I put my hand on the switch. I push the button. I turn on the lights. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'computer', 'food_bacon', 'mat', 'tvstand', 'ceilinglamp', 'plate', 'window', 'shower', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'wine', 'curtain', 'home_office', 'table']  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:['fork', 'filing_cabinet', 'beer', 'tea', 'freezer', 'shampoo', 'character', 'desk', 'piano_bench', 'ceilinglamp', 'iron', 'picture', 'mousepad', 'couch', 'bowl', 'nightstand', 'wall_clock', 'toy', 'bed', 'coffe_maker', 'television', 'coin', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'shoes', 'bathroom_cabinet']  Task:Change TV channel  response:

{  take remote control, push \ change channel\  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:['tea', 'walllamp', 'ground_coffee', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'bathroom_cabinet', 'table', 'scrabble', 'coffee', 'creditcard']  Task:Relax on sofa  response:  {       thoughts : Relax on the sofa in the living room.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sheets', 'tablelamp', 'blender', 'toilet', 'detergent', 'knife', 'hanger', 'floor', 'character', 'food_cake', 'brush', 'mat', 'plate', 'faucet', 'dish_soap', 'oil', 'closetdrawer', 'food_jam', 'dining_room', 'food_kiwi', 'oven', 'powersocket', 'cup', 'after_shave', 'kitchen_counter', 'dishrack', 'pajamas', 'spoon', 'dishwasher', 'vase']  Task:Wash dishes with dishwasher  response:

{  Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on dishwasher. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'band-aids', 'walllamp', 'drawing', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'plate', 'oil', 'mousepad', 'wall', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'doorjamb', 'door', 'napkin', 'table', 'teeth']  Task:Watch TV  response:  {       thoughts : Watch TV in the living room.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['glue', 'tablelamp', 'measuring_cup', 'microwave', 'chair', 'freezer', 'detergent', 'orchid', 'knife', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'desk', 'mop_bucket', 'ceilinglamp', 'floor_lamp', 'food_jam', 'pillow', 'dining_room', 'photoframe', 'keys', 'toothbrush_holder', 'oven_mitts', 'wine', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'dirt']  Task:Turn on light  response:

{  I walk into my bedroom, go to the lamp and use the switch to turn it on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'bills', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']  Task:Watch  TV  response:  {       thoughts : Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch,       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:['microwave', 'freezer', 'walllamp', 'bathroom', 'dough', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookmark', 'stovefan', 'brush', 'deck_of_cards', 'faucet', 'window', 'closetdrawer', 'dining_room', 'wall', 'oven', 'cutting_board', 'cup', 'bed', 'coffe_maker', 'food_food', 'tray', 'shaving_cream', 'kitchen_counter', 'chessboard', 'clothes_dress', 'conditioner']  Task:Drink  response:

{  Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup }


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', 'food_pizza', 'mop', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mop_bucket', 'brush', 'toaster', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'powersocket', 'cup', 'photoframe', 'bed', 'mouse', 'dresser', 'sink', 'bathroom_cabinet', 'soap', 'tooth_paste']  Task:Wash teeth  response:  {       thoughts : 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.,       actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[SCRUB] <tooth_paste>', '[FIND] <toothbrush>', '[WASH] <toothbrush>', '[FIND] <sink>', '[RINSE] <sink>']  }     Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'faucet', 'oil', 'bowl', 'wall', 'wall_clock', 'oven', 'cutting_board', 'clothes_gloves', 'food_food', 'television', 'tray', 'food_onion', 'lighter', 'kitchen_counter', 'dishrack', 'sink', 'bathroom_cabinet', 'teeth']  Task:Cook some food  response:

{  I switch on the stove and cook my groceries there. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dry_pasta', 'toilet', 'nail_polish', 'detergent', 'cat', 'trashcan', 'milk', 'knifeblock', 'phone', 'ceiling', 'desk', 'keyboard', 'mousepad', 'couch', 'pillow', 'bench', 'oven', 'cup', 'bed', 'light_bulb', 'food_food', 'lighter', 'kitchen_counter', 'hairbrush', 'dresser', 'laundry_detergent', 'table', 'clothes_skirt', 'tooth_paste', 'dirt']  Task:Pet cat  response:  {       thoughts : 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.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <milk>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[TURNTO] <cat>', '[POINTAT] <cat>']  }     Scene_Objects:['fork', 'toilet', 'toothbrush', 'drawing', 'floor', 'desk', 'tea_bag', 'toaster', 'mat', 'deck_of_cards', 'window', 'oil', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'bench', 'cutting_board', 'standingmirror', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'lighter', 'maindoor', 'napkin', 'instrument_guitar', 'table', 'bathroom_cabinet']  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:['spectacles', 'pot', 'filing_cabinet', 'food_ice_cream', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'faucet', 'ceilinglamp', 'wall', 'powersocket', 'photoframe', 'clothes_gloves', 'bed', 'food_food', 'check', 'ice', 'doorjamb', 'pencil', 'kitchen_counter', 'laundry_detergent', 'door', 'napkin', 'home_office', 'light', 'dishwasher']  Task:Turn on light  response:  {       thoughts : switching on the light,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['fork', 'juice', 'chair', 'walllamp', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'powersocket', 'oven', 'television', 'coin', 'food_donut', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'bathtub', 'light', 'table']  Task:Write an email  response:

{  Turn on PC and log onto email account. Type email and send it. 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:['pot', 'filing_cabinet', 'tablelamp', 'tea', 'knifeblock', 'cpuscreen', 'folder', 'bedroom', 'table_cloth', 'toaster', 'plate', 'homework', 'oil', 'closetdrawer', 'powersocket', 'tape', 'bed', 'novel', 'coffe_maker', 'television', 'razor', 'wine', 'doorjamb', 'shoes', 'dishrack', 'headset', 'cupboard', 'hairdryer', 'light', 'shoe_rack']  Task:Listen to music  response:  {       thoughts : walk into living room, walk to stereo, turn on stereo, listen to music,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['tablelamp', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'oven', 'novel', 'colander', 'tray', 'lighter', 'dresser', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both']  Task:Wash hands  response:

{  I go to bathroom, go to sink, turn the water on via faucet, grab soap, use the soap to scrub my hands, put the soap back and wash my hands. Then I stop the water with faucet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'freezer', 'ground_coffee', 'detergent', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'stovefan', 'toaster', 'faucet', 'shower', 'closetdrawer', 'candle', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'coffe_maker', 'coffee_filter', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table']  Task:Make coffee  response:  {       thoughts : Make coffee in the kitchen.,       actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[PLUGIN] <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>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']  }     Scene_Objects:['pot', 'filing_cabinet', 'beer', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'character', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'clothes_pants', 'towel', 'bench', 'basket_for_clothes', 'bed', 'coin', 'food_donut', 'curtain', 'towel_rack', 'mouse', 'cd', 'comb', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:

{  Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'jelly', 'bathroom', 'detergent', 'food_butter', 'drawing', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'stovefan', 'plate', 'window', 'bowl', 'wall', 'bench', 'cup', 'bed', 'coffe_maker', 'check', 'tray', 'towel_rack', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'sink', 'light', 'dishwasher', 'teeth']  Task:Listen to music  response:  {       thoughts : Walk into living room. Turn on radio.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']  }     Scene_Objects:['glue', 'pot', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'alcohol', 'stovefan', 'toaster', 'tvstand', 'couch', 'wall', 'oven', 'cutting_board', 'toy', 'food_cheese', 'novel', 'coffe_maker', 'food_food', 'television', 'tray', 'shaving_cream', 'cards', 'kitchen_counter', 'shoes', 'light']  Task:Put groceries in Fridge  response:

{  put away groceries in fridge. open the door, put on shelf, close the door. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'detergent', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'toaster', 'mat', 'faucet', 'iron', 'mousepad', 'wall', 'powersocket', 'cup', 'coffe_maker', 'water', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'clothes_scarf', 'colander']  Task:Drink  response:  {       thoughts : I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']  }     Scene_Objects:['blender', 'chair', 'walllamp', 'dough', 'orchid', 'cpuscreen', 'hanger', 'floor', 'keyboard', 'remote_control', 'food_cake', 'envelope', 'computer', 'button', 'food_bacon', 'ceilinglamp', 'stereo', 'homework', 'oven', 'tape', 'photoframe', 'coffee_table', 'keys', 'check', 'novel', 'light_bulb', 'wooden_spoon', 'curtain', 'cd', 'home_office']  Task:Change TV channel  response:

{  walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the remote. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'crayon', 'chair', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cup', 'bed', 'keys', 'food_food', 'television', 'food_onion', 'doorjamb', 'mouse', 'home_office']  Task:Lock door  response:  {       thoughts : Turn the lock.,       actions : ['[WALK] <bedroom>']  }     Scene_Objects:['pot', 'beer', 'microwave', 'toilet', 'freezer', 'food_butter', 'knife', 'floor', 'table_cloth', 'toaster', 'plate', 'faucet', 'stereo', 'dish_soap', 'oil', 'wall', 'wall_clock', 'oven', 'powersocket', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'coffee_filter', 'wooden_spoon', 'tray', 'kitchen_counter', 'sink', 'dishwasher', 'laser_pointer']  Task:Wash dishes with dishwasher  response:

{  I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on. }


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', 'floor', 'dvd_player', 'bedroom', 'bookshelf', 'food_cake', 'shower', 'picture', 'foundation', 'mousepad', 'closetdrawer', 'tooth_paste', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'shelf', 'food_food', 'doorjamb', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'towel_rack', 'door', 'napkin', 'bathroom_cabinet', 'board_game']  Task:Go to toilet  response:  {       thoughts : I go to the bathroom. I locate the toilet. I walk to the toilet.,       actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[WALK] <toilet>']  }     Scene_Objects:['tablelamp', 'blender', 'food_salt', 'freezer', 'detergent', 'ceiling', 'stamp', 'desk', 'bedroom', 'mat', 'deck_of_cards', 'faucet', 'shower', 'window', 'homework', 'food_peanut_butter', 'microphone', 'bowl', 'oven', 'toy', 'bed', 'light_bulb', 'standingmirror', 'check', 'doorjamb', 'kitchen_counter', 'hairbrush', 'hairdryer', 'bathroom_cabinet', 'table']  Task:Read book  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : I walk to the sofa, and lie down on the sofa.,       actions : ['[WALK] <couch>', '[LIE] <couch>']  }     Scene_Objects:['food_ice_cream', 'mop', 'ground_coffee', 'cat', 'floor', 'ceiling', 'envelope', 'stovefan', 'mat', 'tvstand', 'stereo', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'cutting_board', 'check', 'coffe_maker', 'television', 'video_game_controller', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'door', 'table', 'colander']  Task:Pet cat  response:

{  walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'ceiling', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'child', 'bench', 'coffe_maker', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'home_office', 'table', 'bathroom_cabinet']  Task:Watch TV  response:  {       thoughts : Turn on tv.  Sit with kids.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'mop', 'measuring_cup', 'microwave', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'iron', 'wall', 'wall_clock', 'cutting_board', 'shelf', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'food_rice', 'curtain', 'kitchen_counter', 'controller', 'sink', 'clothes_shirt']  Task:Make coffee  response:

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


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', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'ceiling', 'phone', 'bedroom', 'stovefan', 'mat', 'tvstand', 'shower', 'faucet', 'iron', 'food_noodles', 'couch', 'towel', 'pillow', 'dining_room', 'wall_clock', 'bench', 'bed', 'television', 'after_shave', 'doorjamb', 'door', 'bathtub', 'spoon', 'bathroom_cabinet']  Task:Pick up phone  response:  {       thoughts : Walk to home office 1. Walk over to phone 1 on table 1.  Grab phone 1.  lift phone 1.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['dry_pasta', 'pot', 'microwave', 'freezer', 'walllamp', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'phone', 'food_chicken', 'stovefan', 'mat', 'faucet', 'wall', 'wall_clock', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'food_steak', 'sink', 'bathroom_cabinet']  Task:Cook some food  response:

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


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', 'water_glass', 'pot', 'spectacles', 'walllamp', 'food_carrot', 'kitchen_cabinet', 'shampoo', 'longboard', 'computer', 'bookmark', 'mat', 'stereo', 'shower', 'homework', 'oil', 'clothes_socks', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'water', 'food_onion', 'headset', 'cd', 'dresser', 'controller', 'sink', 'napkin', 'clothes_skirt']  Task:Drink  response:  {       thoughts : Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water.,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[CLOSE] <kitchen_cabinet>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['pot', 'chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'stovefan', 'mat', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'dresser', 'napkin', 'bathroom_cabinet', 'light', 'table']  Task:Relax on sofa  response:

{  I want to relax on the sofa to some relaxing music 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:['beer', 'bathroom', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'button', 'brush', 'mat', 'toaster', 'faucet', 'picture', 'iron', 'pillow', 'broom', 'wall', 'oven', 'keys', 'novel', 'coin', 'tray', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'soap', 'clothes_shirt', 'scrabble', 'hands_both']  Task:Wash hands  response:  {       thoughts : Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[PUSH] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['fork', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'stamp', 'envelope', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'bag', 'home_office', 'table', 'soap']  Task:Relax on sofa  response:

{  I walk to my living room and switch on the television, and lay 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', '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:['pot', 'filing_cabinet', 'scissors', 'microwave', 'milk', 'knife', 'bathroom_counter', 'ceiling', 'bedroom', 'toaster', 'mat', 'plate', 'tvstand', 'dish_soap', 'bowl', 'food_kiwi', 'toy', 'cup', 'standingmirror', 'bed', 'food_food', 'food_donut', 'cards', 'dresser', 'clothes_dress', 'napkin', 'bathroom_cabinet', 'dishwasher', 'vase', 'board_game']  Task:Wash dishes with dishwasher  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'filing_cabinet', 'chair', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'keyboard', 'mat', 'ceilinglamp', 'plate', 'tvstand', 'shower', 'faucet', 'mousepad', 'couch', 'wall', 'bench', 'powersocket', 'newspaper', 'bed', 'television', 'mouse', 'controller', 'table', 'light', 'instrument_violin', 'creditcard']  Task:Set up table  response:  {       thoughts : I walk to the table. I put down the dish. I put down the silverware. I put down the napkin.,       actions : ['[WALK] <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>']  }     Scene_Objects:['crayon', 'needle', 'clothes_underwear', 'phone', 'desk', 'stamp', 'clothes_jacket', 'stovefan', 'mat', 'tvstand', 'window', 'towel', 'pillow', 'cutting_board', 'basket_for_clothes', 'cup', 'bed', 'photoframe', 'newspaper', 'food_food', 'mouthwash', 'television', 'wine', 'kettle', 'dresser', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'washing_machine']  Task:Wash clothes  response:

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


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', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'stamp', 'bookshelf', 'clothes_jacket', 'mop_bucket', 'toaster', 'mat', 'brush', 'shoe-shine_kit', 'laptop', 'couch', 'pillow', 'wall', 'oven', 'cup', 'food_cheese', 'photoframe', 'check', 'television', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'bathroom_cabinet']  Task:Eat cheese  response:  {       thoughts : Open fridge.  Get cheese.  Eat it.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[EAT] <food_cheese>']  }     Scene_Objects:['chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'tvstand', 'faucet', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'wall', 'powersocket', 'shelf', 'food_food', 'oven_mitts', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'vacuum_cleaner', 'dresser', 'light', 'table']  Task:Turn on light  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'floor', 'folder', 'mop_bucket', 'ceilinglamp', 'stereo', 'picture', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'novel', 'coffe_maker', 'toilet_paper', 'toothbrush_holder', 'tray', 'curtain', 'lighter', 'headset', 'cupboard', 'table']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room and find the sofa. I sit on the sofa and get comfortable.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['tablelamp', 'beer', 'measuring_cup', 'drawing', 'floor', 'bookshelf', 'mat', 'faucet', 'stereo', 'window', 'closetdrawer', 'microphone', 'food_orange', 'pillow', 'wall', 'nightstand', 'bed', 'food_food', 'curtain', 'towel_rack', 'headset', 'dresser', 'hairbrush', 'laundry_detergent', 'home_office', 'table', 'light', 'vase', 'board_game', 'scrabble']  Task:Go to sleep  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'bathroom', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'ceiling', 'folder', 'character', 'keyboard', 'bookshelf', 'envelope', 'computer', 'dining_room', 'wall', 'nightstand', 'cup', 'clothes_gloves', 'light_bulb', 'check', 'curtain', 'pencil', 'kitchen_counter', 'controller', 'sink', 'napkin', 'clothes_skirt', 'tooth_paste']  Task:Browse internet  response:  {       thoughts : I turn on computer. I use keyboard to type. I open browser. I search.,       actions : ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['freezer', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'thread', 'computer', 'stovefan', 'mat', 'faucet', 'clothes_socks', 'clothes_hat', 'towel', 'wall', 'wall_clock', 'oven', 'shelf', 'bed', 'standingmirror', 'water', 'tray', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap', 'scrabble', 'hands_both']  Task:Wash hands  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'brush', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'bag', 'light', 'dishwasher', 'table']  Task:Relax on sofa  response:  {       thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sheets', 'microwave', 'toilet', 'ground_coffee', 'blow_dryer', 'orchid', 'wallshelf', 'bathroom_counter', 'character', 'desk', 'bookshelf', 'alcohol', 'computer', 'ceilinglamp', 'laptop', 'faucet', 'pillow', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'cup', 'television', 'oven_mitts', 'after_shave', 'doorjamb', 'diary', 'towel_rack', 'cards', 'maindoor']  Task:Pet cat  response:

{  Walk to living room. Find cat. Walk to cat. Pull 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:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'napkin', 'spoon', 'table', 'light']  Task:Watch TV  response:  {       thoughts : Sit on the couch and use the remote control to change channels,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[WATCH] <television>']  }     Scene_Objects:['food_bread', 'chair', 'bathroom', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'character', 'computer', 'mail', 'table_cloth', 'toaster', 'foundation', 'window', 'mousepad', 'bench', 'shelf', 'photoframe', 'bed', 'coffe_maker', 'cards', 'chessboard', 'controller', 'door', 'maindoor', 'bathtub', 'light', 'vase', 'laser_pointer']  Task:Pick up phone  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'chair', 'band-aids', 'bathroom', 'trashcan', 'phone', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'picture', 'window', 'couch', 'bowl', 'broom', 'wall', 'oven', 'bench', 'cup', 'food_food', 'oven_mitts', 'colander', 'curtain', 'pencil', 'kitchen_counter', 'clothes_dress', 'sink', 'dishwasher', 'soap', 'instrument_violin']  Task:Pet cat  response:  {       thoughts : Find Cat in living room.  Walk to cat.  Pet cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['food_pizza', 'food_ice_cream', 'microwave', 'freezer', 'ground_coffee', 'nail_polish', 'milk', 'hanger', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'faucet', 'clothes_hat', 'wall', 'wall_clock', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'check', 'television', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'maindoor', 'sink', 'vase', 'soap']  Task:Make coffee  response:

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


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', 'toilet', 'chair', 'walllamp', 'bathroom', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'stovefan', 'ceilinglamp', 'plate', 'shower', 'tvstand', 'food_noodles', 'bowl', 'wall', 'tape', 'shelf', 'bed', 'check', 'doorjamb', 'kitchen_counter', 'shoes', 'sink', 'light', 'laser_pointer']  Task:Take shower  response:  {       thoughts : walk to bathroom , find shower , take a shower,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>']  }     Scene_Objects:['pot', 'tablelamp', 'freezer', 'walllamp', 'food_carrot', 'desk', 'food_cake', 'remote_control', 'button', 'ceilinglamp', 'faucet', 'stereo', 'window', 'mousepad', 'couch', 'wall_clock', 'bench', 'box', 'cup', 'bed', 'keys', 'newspaper', 'food_food', 'ice', 'after_shave', 'maindoor', 'bathroom_cabinet', 'light', 'vase', 'soap']  Task:Watch TV  response:

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


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', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap']  Task:Change TV channels  response:  {       thoughts : Take remote. Change to desired channel by you.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']  }     Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'cat', 'cpuscreen', 'bathroom_counter', 'bedroom', 'food_cake', 'computer', 'alcohol', 'toaster', 'stovefan', 'ceilinglamp', 'mousepad', 'closetdrawer', 'clothes_hat', 'nightstand', 'wall_clock', 'newspaper', 'coffee_filter', 'oven_mitts', 'kettle', 'kitchen_counter', 'dresser', 'hair', 'sink', 'napkin', 'bag', 'light']  Task:Pet cat  response:

{  find the cat, go near the cat 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:['pot', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'mop_bucket', 'table_cloth', 'toaster', 'stovefan', 'plate', 'microphone', 'clothes_pants', 'dining_room', 'wall', 'pasta', 'cup', 'coffe_maker', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'home_office', 'light', 'dishwasher', 'colander', 'tooth_paste']  Task:Wash dishes with dishwasher  response:  {       thoughts : Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['filing_cabinet', 'walllamp', 'detergent', 'cat', 'milk', 'phone', 'ceiling', 'desk', 'mop_bucket', 'brush', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'mat', 'closetdrawer', 'microphone', 'nightstand', 'wall_clock', 'toy', 'cup', 'food_food', 'after_shave', 'lighter', 'towel_rack', 'mouse', 'pajamas', 'controller', 'laundry_detergent', 'soap']  Task:Pet cat  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'beer', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mousepad', 'food_jam', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'food_onion', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'dresser', 'door', 'table', 'light', 'dishwasher']  Task:Work  response:  {       thoughts : I walk to the bedroom, then find the computer and sit in the chair ,next switch on the computer and finally type in the keyboard to start to work on it,       actions : ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'floor', 'ceiling', 'stovefan', 'faucet', 'dustpan', 'food_jam', 'wall', 'oven', 'cutting_board', 'newspaper', 'coffe_maker', 'water', 'drinking_glass', 'tray', 'doorjamb', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'home_office', 'bathroom_cabinet', 'clothes_skirt', 'vase', 'scrabble']  Task:Drink  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste']  Task:Turn on light  response:  {       thoughts : Twist the lamp switch until the light goes on.,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['pot', 'beer', 'microwave', 'chair', 'freezer', 'ground_coffee', 'floor', 'ceiling', 'mail', 'food_bacon', 'toaster', 'deck_of_cards', 'faucet', 'window', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'light_bulb', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'after_shave', 'pencil', 'kitchen_counter', 'pajamas', 'sink', 'light']  Task:Make coffee  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer']  Task:Write an email  response:  {       thoughts : I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email,       actions : ['[WALK] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['glue', 'blender', 'microwave', 'toilet', 'bathroom', 'food_carrot', 'milk', 'wallshelf', 'cpuscreen', 'toaster', 'window', 'clothes_socks', 'pillow', 'wall', 'standingmirror', 'food_food', 'mouthwash', 'razor', 'ice', 'rag', 'lighter', 'cards', 'mouse', 'cd', 'hairbrush', 'pajamas', 'dresser', 'laundry_detergent', 'sink', 'light']  Task:Read book  response:

{  walk to living room ,find a book ,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:['tablelamp', 'food_ice_cream', 'jelly', 'chair', 'blow_dryer', 'bathroom', 'wallshelf', 'shampoo', 'phone', 'desk', 'clothes_jacket', 'stovefan', 'faucet', 'oil', 'closetdrawer', 'food_noodles', 'mousepad', 'microphone', 'towel', 'broom', 'bed', 'newspaper', 'after_shave', 'centerpiece', 'console', 'dresser', 'bathroom_cabinet', 'soap', 'tooth_paste', 'scrabble']  Task:Read book  response:  {       thoughts : Walk to living room. Find book. Grab book. Open book. Read book.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['food_pizza', 'microwave', 'chair', 'food_butter', 'drawing', 'bathroom_counter', 'floor', 'stamp', 'desk', 'bookmark', 'stovefan', 'tvstand', 'shower', 'microphone', 'towel', 'dining_room', 'bowl', 'nightstand', 'oven', 'bench', 'shelf', 'food_cheese', 'photoframe', 'light_bulb', 'tray', 'kitchen_counter', 'dresser', 'hair', 'door', 'bathtub']  Task:Pet cat  response:

{  Go into the living room 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:['sheets', 'pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'band-aids', 'drawing', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'button', 'toaster', 'mat', 'clothes_hat', 'wall', 'powersocket', 'oven', 'toy', 'novel', 'toothbrush_holder', 'after_shave', 'doorjamb', 'pencil', 'door', 'light', 'table', 'dishwasher', 'colander']  Task:Put toys away  response:  {       thoughts : Pick up all the toys on the floor and put them in their correct storage bin or shelf.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['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:

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


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

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'hair', 'door', 'coffee']  Task:Browse internet  response:  {       thoughts : walk to living room. look at computer. switch on computer. sit in chair. watch computer. switch off computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[WATCH] <computer>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'button', 'food_bacon', 'stovefan', 'mat', 'shower', 'faucet', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'keys', 'tray', 'doorjamb', 'lighter', 'sink', 'bathtub', 'bathroom_cabinet', 'soap']  Task:Take shower  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stovefan', 'mat', 'tvstand', 'faucet', 'toaster', 'teeth', 'towel', 'wall', 'wall_clock', 'oven', 'powersocket', 'food_food', 'tray', 'headset', 'comb', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'instrument_guitar', 'soap', 'hands_both', 'creditcard']  Task:Wash hands  response:  {       thoughts : Go to bathroom, turn on faucet, wet hands, apply soap, rub hands, rinse hands, turn off faucet, dry hands,       actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']  }     Scene_Objects:['dry_pasta', 'filing_cabinet', 'toilet', 'walllamp', 'bathroom', 'bathroom_counter', 'phone', 'tea_bag', 'keyboard', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'brush', 'foundation', 'window', 'closetdrawer', 'couch', 'broom', 'wall_clock', 'toy', 'food_cheese', 'novel', 'food_donut', 'tray', 'kitchen_counter', 'dresser', 'bathtub', 'light', 'shoe_rack']  Task:Pick up phone  response:

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


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', 'chair', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'towel', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bag', 'napkin', 'soap']  Task:Put groceries in Fridge  response:  {       thoughts : Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['tablelamp', 'food_ice_cream', 'bathroom', 'bathroom_counter', 'floor', 'clothes_jacket', 'toaster', 'mat', 'tvstand', 'window', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'pasta', 'tape', 'newspaper', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'diary', 'pencil', 'hairbrush', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'food_bread', 'mop', 'freezer', 'trashcan', 'knifeblock', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'stovefan', 'mat', 'faucet', 'pillow', 'wall', 'powersocket', 'bed', 'food_food', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'chessboard', 'dresser', 'cupboard', 'hair', 'door', 'instrument_guitar', 'light', 'creditcard']  Task:Turn on light  response:  {       thoughts : Walk into living room. Find wall. Find light button. Switch on light button.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']  }     Scene_Objects:['toilet', 'chair', 'freezer', 'detergent', 'hanger', 'bathroom_counter', 'shampoo', 'ceiling', 'desk', 'bedroom', 'computer', 'stovefan', 'toaster', 'tvstand', 'shower', 'homework', 'closetdrawer', 'bench', 'oven', 'toy', 'cup', 'bed', 'photoframe', 'toilet_paper', 'coffe_maker', 'oven_mitts', 'pencil', 'dresser', 'bag', 'bathroom_cabinet']  Task:Pet cat  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'scissors', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'food_jam', 'wall', 'novel', 'television', 'curtain', 'doorjamb', 'comb', 'clothes_dress', 'sink', 'home_office', 'table']  Task:Change TV channel  response:  {       thoughts : first i will go to living room and then take the remote and swtitch on television after that il change the channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['mop', 'chair', 'bathroom', 'cpuscreen', 'hanger', 'computer', 'brush', 'toaster', 'mat', 'faucet', 'shower', 'dish_soap', 'food_noodles', 'mousepad', 'bowl', 'photoframe', 'standingmirror', 'novel', 'coffe_maker', 'check', 'television', 'bed', 'coffee_filter', 'curtain', 'clothes_dress', 'food_steak', 'door', 'spoon', 'dishwasher', 'instrument_violin']  Task:Wash dishes with dishwasher  response:

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


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_pizza', 'tablelamp', 'blender', 'beer', 'wallshelf', 'floor', 'phone', 'stamp', 'desk', 'stovefan', 'mat', 'laptop', 'stereo', 'window', 'food_noodles', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'cup', 'photoframe', 'clothes_gloves', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'controller', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:  {       thoughts : walk to living room, walk to sofa, sit on sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sponge', 'food_ice_cream', 'chair', 'freezer', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'thread', 'computer', 'alcohol', 'mat', 'window', 'foundation', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'light', 'table']  Task:Relax on sofa  response:

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


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', 'fork', 'blender', 'food_ice_cream', 'food_butter', 'phone', 'character', 'bookshelf', 'brush', 'ceilinglamp', 'plate', 'shower', 'iron', 'stereo', 'toaster', 'oil', 'food_orange', 'pillow', 'cup', 'food_food', 'check', 'oven_mitts', 'food_donut', 'food_onion', 'after_shave', 'mouse', 'hairdryer', 'bag', 'bathroom_cabinet', 'home_office']  Task:Set up table  response:  {       thoughts : Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>']  }     Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'bookshelf', 'brush', 'mat', 'stereo', 'picture', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'shelf', 'cup', 'television', 'wine', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'home_office', 'table']  Task:Listen to music  response:

{  Walk to living room. Walk to radio. Switch on the radio. Walk to sofa and sit on 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:['filing_cabinet', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'food_bacon', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'toilet_paper', 'check', 'razor', 'curtain', 'doorjamb', 'towel_rack', 'chessboard', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet']  Task:Get toilet paper  response:  {       thoughts : There are extra toilet papers in the bottom cabinet.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']  }     Scene_Objects:['sheets', 'juice', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'floor', 'ceiling', 'dvd_player', 'desk', 'table_cloth', 'closetdrawer', 'dining_room', 'wall', 'bench', 'cutting_board', 'light_bulb', 'check', 'mouthwash', 'video_game_controller', 'ice', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'dishrack', 'hair', 'door', 'sink', 'light']  Task:Turn on light  response:

{  flip the switch and turn on the lights }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'mat', 'plate', 'couch', 'candle', 'microphone', 'dining_room', 'wall', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'television', 'curtain', 'table', 'dishwasher']  Task:Watch TV  response:  {       thoughts : Turn on the TV, sit on the couch, find a show, and watch it.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['tablelamp', 'measuring_cup', 'cd_player', 'knife', 'character', 'tea_bag', 'remote_control', 'button', 'table_cloth', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'food_peanut_butter', 'candle', 'nightstand', 'bench', 'cutting_board', 'shelf', 'bed', 'photoframe', 'oven_mitts', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'dresser', 'controller', 'sink', 'table', 'clothes_skirt']  Task:Listen to music  response:

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


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', 'tablelamp', 'toilet', 'chair', 'walllamp', 'detergent', 'cat', 'knife', 'cpuscreen', 'floor', 'ceiling', 'mail', 'toaster', 'ceilinglamp', 'stovefan', 'stereo', 'homework', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'tape', 'newspaper', 'photoframe', 'food_food', 'television', 'water', 'tray', 'bathroom_cabinet']  Task:Drink  response:  {       thoughts : GOING TO DRINK WATER IN KITCHEN,       actions : ['[WALK] <dining_room>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['food_pizza', 'tablelamp', 'measuring_cup', 'freezer', 'bathroom', 'drawing', 'wallshelf', 'character', 'purse', 'envelope', 'ceilinglamp', 'nightstand', 'wall_clock', 'bench', 'cutting_board', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'diary', 'cards', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'light', 'table', 'tooth_paste', 'clothes_shirt', 'coffee']  Task:Drink  response:

{  I go to the kitchen. I get a glass. I fill it with water. I take a drink from the 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:['tablelamp', 'food_salt', 'crayon', 'freezer', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'shampoo', 'desk', 'mail', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mat', 'electric_shaver', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'basket_for_clothes', 'food_food', 'diary', 'towel_rack', 'dresser', 'clothes_dress']  Task:Put groceries in Fridge  response:  {       thoughts : in my home i walk to the kitchen with some groceries and locate the fridge,then open the fridge put the groceries into the fridge and closed.,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['pot', 'chair', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'table_cloth', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'oven', 'standingmirror', 'bed', 'food_food', 'water', 'tray', 'curtain', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'hands_both']  Task:Wash hands  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'button', 'food_bacon', 'stovefan', 'mat', 'shower', 'faucet', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'keys', 'tray', 'doorjamb', 'lighter', 'sink', 'bathtub', 'bathroom_cabinet', 'soap']  Task:Take shower  response:  {       thoughts : I want to take a shower so I go to the bathroom, turn on the shower, get the soap, lather and wash, then I rinse, turn off shower, get a towel and dry off.,       actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <shower>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>']  }     Scene_Objects:['spectacles', 'pot', 'food_bread', 'microwave', 'toilet', 'freezer', 'food_carrot', 'dough', 'bathroom_counter', 'floor', 'phone', 'thread', 'stereo', 'shower', 'mousepad', 'food_jam', 'food_orange', 'form', 'bowl', 'food_kiwi', 'oven', 'shelf', 'coffe_maker', 'television', 'razor', 'towel_rack', 'coffee_pot', 'headset', 'chessboard', 'light']  Task:Listen to music  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Work  response:  {       thoughts : I go to my home office. I find the computer along with mechanical keyboard on the desk. I sit on chair. I switch on the computer. I type on keyboard and work on the computer.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'jelly', 'bills', 'food_egg', 'hanger', 'floor', 'phone', 'ceiling', 'dvd_player', 'mat', 'window', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'cutting_board', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'hair', 'table', 'soap', 'clothes_shirt']  Task:Relax on sofa  response:

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