Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'food_egg', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'bench', 'box', 'television', 'curtain', 'towel_rack', 'table', 'light']  Task:Change TV channel  response:  {       thoughts : Changing channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[DROP] <remote_control>']  }     Scene_Objects:['glue', 'microwave', 'toilet', 'wallshelf', 'cpuscreen', 'hanger', 'bookshelf', 'computer', 'bookmark', 'mat', 'tvstand', 'shower', 'faucet', 'foundation', 'oil', 'closetdrawer', 'towel', 'powersocket', 'bed', 'novel', 'coin', 'after_shave', 'pencil', 'dresser', 'cupboard', 'clothes_dress', 'napkin', 'table', 'laser_pointer', 'creditcard']  Task:Pick up phone  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:['sponge', 'glue', 'tablelamp', 'crayon', 'freezer', 'cat', 'milk', 'wallshelf', 'bathroom_counter', 'bedroom', 'desk', 'bookshelf', 'thread', 'stovefan', 'stereo', 'faucet', 'pillow', 'pasta', 'oven', 'powersocket', 'cup', 'bed', 'coffe_maker', 'after_shave', 'mouse', 'dresser', 'door', 'hairdryer', 'dishwasher', 'creditcard']  Task:Pet cat  response:

{  Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'dough', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'homework', 'mousepad', 'towel', 'wall', 'nightstand', 'bed', 'novel', 'coffe_maker', 'toothbrush_holder', 'ice', 'diary', 'kettle', 'mouse', 'door', 'spoon', 'instrument_violin']  Task:Study  response:  {       thoughts : Do homework or read books while sitting on the chair.,       actions : ['[WALK] <bedroom>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[PUTOBJBACK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[PUTOBJBACK] <novel>']  }     Scene_Objects:['sheets', 'food_bread', 'filing_cabinet', 'tablelamp', 'blender', 'crayon', 'measuring_cup', 'microwave', 'freezer', 'bathroom', 'milk', 'needle', 'cpuscreen', 'wallshelf', 'hanger', 'phone', 'computer', 'toaster', 'ceilinglamp', 'newspaper', 'food_food', 'coffe_maker', 'ice', 'curtain', 'after_shave', 'dishrack', 'hairbrush', 'spoon', 'table', 'colander']  Task:Pick up phone  response:

{  I walk into the living room and walk over to the table with the phone. I pick up the phone and put it to my ear. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_bread', 'blender', 'freezer', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'plate', 'iron', 'wall', 'nightstand', 'bed', 'food_food', 'check', 'drinking_glass', 'curtain', 'centerpiece', 'coffee_pot', 'cupboard', 'laundry_detergent', 'door', 'dishwasher', 'vase']  Task:Drink  response:  {       thoughts : Robot Drinks the water,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>', '[PUTOBJBACK] <drinking_glass>', '[CLOSE] <freezer>']  }     Scene_Objects:['pot', 'water_glass', 'microwave', 'toilet', 'drawing', 'wallshelf', 'ceiling', 'desk', 'bookmark', 'toaster', 'stovefan', 'mat', 'shower', 'couch', 'wall', 'oven', 'coffe_maker', 'coin', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'cupboard', 'controller', 'hairdryer', 'spoon', 'dishwasher', 'creditcard']  Task:Drink  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light']  Task:Compute  response:  {       thoughts : Use computer.,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'tablelamp', 'freezer', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bedroom', 'alcohol', 'computer', 'table_cloth', 'stovefan', 'mat', 'shower', 'oil', 'couch', 'pillow', 'wall', 'cutting_board', 'newspaper', 'food_food', 'television', 'kettle', 'kitchen_counter', 'cupboard', 'clothes_dress', 'shoe_rack']  Task:Put groceries in Fridge  response:

{  Walk to kitchen. Find groceries. Grab groceries. Find fridge. Walk to fridge. Put groceries in fridge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'measuring_cup', 'walllamp', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'broom', 'wall', 'newspaper', 'light_bulb', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'cupboard', 'table', 'light']  Task:Change TV channel  response:  {       thoughts : Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['glue', 'pot', 'filing_cabinet', 'food_bread', 'tablelamp', 'mop', 'toilet', 'freezer', 'walllamp', 'desk', 'keyboard', 'toaster', 'ceilinglamp', 'laptop', 'mousepad', 'dining_room', 'nightstand', 'cup', 'photoframe', 'clothes_gloves', 'novel', 'coffe_maker', 'curtain', 'dresser', 'controller', 'clothes_dress', 'door', 'sink', 'light', 'laser_pointer']  Task:Pet cat  response:

{  Find a cat in the kitchen and touch it }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'toaster', 'tvstand', 'floor_lamp', 'window', 'closetdrawer', 'couch', 'towel', 'wall', 'wall_clock', 'food_food', 'doorjamb', 'mouse', 'headset', 'shoes', 'dresser', 'controller', 'bathtub', 'sink', 'home_office', 'light']  Task:Turn night light on  response:  {       thoughts : I walk to the dresser and in the middle Io to small battery operated lamp and switch it on,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <floor_lamp>', '[TURNTO] <floor_lamp>', '[SWITCHON] <floor_lamp>']  }     Scene_Objects:['fork', 'microwave', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'tvstand', 'brush', 'stovefan', 'couch', 'candle', 'pillow', 'wall', 'powersocket', 'toy', 'cup', 'photoframe', 'television', 'food_donut', 'tray', 'doorjamb', 'console', 'pencil', 'kitchen_counter', 'cupboard']  Task:Relax on sofa  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'freezer', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'alcohol', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'television', 'coffe_maker', 'ice', 'kitchen_counter', 'cupboard', 'hair', 'table', 'scrabble']  Task:Put groceries in Fridge  response:  {       thoughts : I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'stamp', 'computer', 'brush', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'television', 'doorjamb', 'vacuum_cleaner', 'hairbrush', 'cupboard', 'table']  Task:Read book  response:

{  I pick up a book off the self that I want to read. Then, I sit down on the couch, open the book, and begin reading 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', 'chair', 'cat', 'drawing', 'floor', 'tea_bag', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'food_food', 'television', 'oven_mitts', 'food_onion', 'curtain', 'after_shave', 'comb', 'napkin', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet', 'laser_pointer', 'scrabble']  Task:Relax on sofa  response:  {       thoughts : go to the living room,find the sofa,sat down in the sofa,take some relaxation.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['pot', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'toy', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'pencil', 'dresser', 'sink', 'board_game']  Task:Watch TV  response:

{  Walk to living room, walk to TV, grab TV remote, turn on TV, put down the remote, walk to sofa, sit in soft, watch TV }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'juice', 'microwave', 'toilet', 'freezer', 'ceiling', 'clothes_jacket', 'table_cloth', 'toaster', 'stovefan', 'plate', 'faucet', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'table']  Task:Get out dish  response:  {       thoughts : Open cupboard.  Get out the dish.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[OPEN] <cupboard>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <cupboard>']  }     Scene_Objects:['glue', 'toilet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'mail', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cutting_board', 'photoframe', 'bed', 'television', 'doorjamb', 'dishrack', 'dresser', 'door', 'dishwasher']  Task:Watch TV  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['toilet', 'cat', 'ceilingfan', 'food_butter', 'drawing', 'longboard', 'floor', 'ceiling', 'shampoo', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'clothes_pants', 'wall', 'wall_clock', 'bench', 'television', 'curtain', 'kettle', 'towel_rack', 'hair', 'pajamas', 'maindoor', 'home_office', 'table', 'vase']  Task:Change TV channel  response:  {       thoughts : Changing channel,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[DROP] <remote_control>']  }     Scene_Objects:['fork', 'tablelamp', 'tea', 'drawing', 'wallshelf', 'hanger', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'toaster', 'mat', 'faucet', 'floor_lamp', 'mousepad', 'nightstand', 'box', 'bed', 'photoframe', 'novel', 'food_food', 'coffee_filter', 'food_donut', 'wine', 'after_shave', 'curtain', 'doorjamb', 'clothes_dress', 'conditioner', 'sink']  Task:Read book  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'bathroom', 'detergent', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'video_game_console', 'keyboard', 'stovefan', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall_clock', 'oven', 'bed', 'coffe_maker', 'video_game_controller', 'television', 'doorjamb', 'cd', 'cupboard', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'home_office', 'table']  Task:Playing video game  response:  {       thoughts : Playing  video games  on various video game  systems such as wii u  and  xbox,       actions : ['[WALK] <home_office>', '[WALK] <video_game_console>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[PUTOBJBACK] <video_game_controller>', '[SWITCHOFF] <video_game_console>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>']  }     Scene_Objects:['sheets', 'tablelamp', 'microwave', 'walllamp', 'milk', 'clothes_underwear', 'character', 'bedroom', 'keyboard', 'clothes_socks', 'candle', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'curtain', 'diary', 'shoes', 'headset', 'laundry_detergent', 'sink', 'home_office', 'table', 'colander', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:

{  I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table']  Task:Browse internet  response:  {       thoughts : go to the office, turn computer on, open an browser or any application to open any website.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>']  }     Scene_Objects:['pot', 'food_salt', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'tape', 'photoframe', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser']  Task:Watch TV  response:

{  walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'scissors', 'crayon', 'chair', 'walllamp', 'knifeblock', 'bills', 'wallshelf', 'bathroom_counter', 'phone', 'ceiling', 'bedroom', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'television', 'tray', 'curtain', 'towel_rack', 'door', 'bathtub', 'napkin', 'bag']  Task:Read book  response:  {       thoughts : walk to living room ,find a book ,open the book ,read the book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['pot', 'microwave', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'character', 'stovefan', 'mat', 'tvstand', 'faucet', 'shower', 'clothes_pants', 'towel', 'wall', 'nightstand', 'powersocket', 'oven', 'light_bulb', 'tray', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher']  Task:Take shower  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'floor', 'shampoo', 'mop_bucket', 'toaster', 'mat', 'plate', 'shower', 'dish_soap', 'closetdrawer', 'dining_room', 'wall', 'photoframe', 'coffe_maker', 'colander', 'pencil', 'kitchen_counter', 'cupboard', 'clothes_dress', 'food_steak', 'home_office', 'dishwasher', 'soap', 'tooth_paste']  Task:Wash dishes with dishwasher  response:  {       thoughts : Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the soap into the dishwasher.  Close the dishwasher.  Turn on the dishwasher.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'mat', 'ceilinglamp', 'tvstand', 'homework', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Work  response:

{  I walk to the office. I push the on button on the computer. I sit down in the chair. I work 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:['filing_cabinet', 'tea', 'chair', 'freezer', 'bathroom', 'trashcan', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'bedroom', 'computer', 'plate', 'stereo', 'window', 'food_kiwi', 'wall', 'nightstand', 'box', 'bed', 'clothes_gloves', 'coffe_maker', 'wooden_spoon', 'curtain', 'shoes', 'dishwasher', 'creditcard']  Task:Listen to music  response:  {       thoughts : I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[SIT] <bed>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'light']  Task:Work  response:

{  you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and 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:['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:['dry_pasta', 'tablelamp', 'measuring_cup', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'character', 'desk', 'bedroom', 'table_cloth', 'mat', 'shower', 'stereo', 'microphone', 'clothes_hat', 'pillow', 'nightstand', 'wall_clock', 'oven', 'keys', 'light_bulb', 'check', 'razor', 'tray', 'doorjamb', 'dresser', 'clothes_dress', 'bag', 'dishwasher']  Task:Listen to music  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['cd_player', 'freezer', 'ground_coffee', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'hanger', 'dvd_player', 'character', 'ceilinglamp', 'stereo', 'faucet', 'dustpan', 'clothes_hat', 'nightstand', 'wall', 'newspaper', 'check', 'mouthwash', 'video_game_controller', 'food_food', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'sink', 'home_office', 'dishwasher']  Task:Listen to music  response:  {       thoughts : I walk in the living room, then I go the the stereo and the cd player and turn them on.,       actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']  }     Scene_Objects:['sponge', 'fork', 'pot', 'sheets', 'food_salt', 'detergent', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'shampoo', 'desk', 'food_cake', 'mat', 'faucet', 'food_kiwi', 'wall', 'powersocket', 'toy', 'novel', 'food_food', 'curtain', 'dresser', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both']  Task:Wash hands  response:

{  Going to the sink and scrubbing hands }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'bathroom', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'bookshelf', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'closetdrawer', 'couch', 'pillow', 'cup', 'coffe_maker', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'home_office', 'light', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['chair', 'freezer', 'dough', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'bookmark', 'mat', 'faucet', 'shower', 'closetdrawer', 'couch', 'food_peanut_butter', 'microphone', 'pillow', 'towel', 'wall', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'controller', 'door', 'bag', 'light', 'table']  Task:Put groceries in Fridge  response:

{  walk to kitchen and seprate the groceries and arrange in fridge. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'pencil', 'bathtub', 'home_office', 'table']  Task:Browse internet  response:  {       thoughts : For browsing internet walk to home office. Find Computer. Walk to Computer. Find Chair. Sit in a chair and switch on computer. Connect with internet and browse the net.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>']  }     Scene_Objects:['pot', 'juice', 'microwave', 'chair', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'stovefan', 'pillow', 'wall', 'oven', 'clothes_gloves', 'coffe_maker', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'dishwasher', 'soap']  Task:Wash dishes by hand  response:

{  Walk into Kitchen, walk to sink, grab a plate,put soap on sponge,wash plate with sponge, rinse with water, put away plate in cupboard. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'mat', 'plate', 'faucet', 'ceilinglamp', 'dish_soap', 'mousepad', 'couch', 'dining_room', 'wall', 'oven', 'bench', 'basket_for_clothes', 'towel_rack', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light']  Task:Wash dirty dishes  response:  {       thoughts : Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']  }     Scene_Objects:['filing_cabinet', 'chair', 'band-aids', 'walllamp', 'nail_polish', 'drawing', 'bills', 'wallshelf', 'orchid', 'hanger', 'knife', 'floor', 'ceiling', 'desk', 'alcohol', 'mat', 'foundation', 'closetdrawer', 'couch', 'pillow', 'wall', 'bed', 'novel', 'check', 'oven_mitts', 'rag', 'kitchen_counter', 'dresser', 'bag', 'napkin']  Task:Read book  response:

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


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

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'chair', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'door', 'light']  Task:Turn on light  response:  {       thoughts : turn on the light for room,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[FIND] <chair>', '[SIT] <chair>']  }     Scene_Objects:['spectacles', 'filing_cabinet', 'food_salt', 'chair', 'freezer', 'cat', 'orchid', 'knife', 'bathroom_counter', 'ceiling', 'folder', 'purse', 'bookmark', 'ceilinglamp', 'stereo', 'closetdrawer', 'clothes_pants', 'dirt', 'wall', 'food_food', 'wine', 'rag', 'console', 'shaving_cream', 'pencil', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'home_office', 'washing_machine']  Task:Wash clothes  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['water_glass', 'pot', 'freezer', 'milk', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'alcohol', 'computer', 'toaster', 'shoe-shine_kit', 'faucet', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'check', 'toilet_paper', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'clothes_dress', 'food_steak', 'sink', 'bathroom_cabinet']  Task:Drink  response:  {       thoughts : I walk into the kitchen. I reach into the cabinet and pick up a water glass. Turn on the faucet and place the glass under the water stream. Bring the glass of water to lips and drink.,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[DRINK] <water_glass>']  }     Scene_Objects:['measuring_cup', 'tea', 'microwave', 'freezer', 'ground_coffee', 'hanger', 'floor', 'ceiling', 'dvd_player', 'bedroom', 'computer', 'toaster', 'shoe-shine_kit', 'shower', 'picture', 'wall', 'keys', 'coffe_maker', 'check', 'video_game_controller', 'coffee_filter', 'oven_mitts', 'water', 'television', 'after_shave', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher']  Task:Make coffee  response:

{  Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch 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:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt']  Task:Get dressed  response:  {       thoughts : Get some clothes together that make an appropriate outfit.  Put them on,       actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']  }     Scene_Objects:['pot', 'tablelamp', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'stereo', 'tvstand', 'towel', 'pillow', 'wall', 'pasta', 'powersocket', 'coffe_maker', 'oven_mitts', 'tray', 'curtain', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap', 'hands_both']  Task:Wash hands  response:

{  I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'beer', 'trashcan', 'dough', 'cpuscreen', 'desk', 'keyboard', 'toaster', 'stovefan', 'tvstand', 'shower', 'faucet', 'window', 'oil', 'couch', 'dining_room', 'cutting_board', 'bed', 'food_food', 'television', 'ice', 'doorjamb', 'towel_rack', 'cd', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office']  Task:Pick up phone  response:  {       thoughts : I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>', '[SWITCHON] <phone>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'comb', 'door', 'light']  Task:Read book  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'bookmark', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'oil', 'food_peanut_butter', 'broom', 'wall', 'novel', 'diary', 'mouse', 'cupboard', 'clothes_dress', 'door', 'table', 'light', 'dirt']  Task:Browse internet  response:  {       thoughts : Go to office. Turn on computer. Pull out chair. Sit in chair. Use keyboard and mouse.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>']  }     Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'cards', 'dresser', 'door', 'colander']  Task:Change TV channel  response:

{  I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'sheets', 'filing_cabinet', 'food_bread', 'food_salt', 'microwave', 'chair', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'cup', 'check', 'mouthwash', 'food_donut', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'table', 'teeth']  Task:Play games  response:  {       thoughts : I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours.,       actions : ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mop_bucket', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Change TV channel  response:

{  its time for my favorite show and im going change with the help of remote control and watch }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'detergent', 'ceilingfan', 'drawing', 'needle', 'knifeblock', 'floor', 'ceiling', 'phone', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'bench', 'check', 'television', 'oven_mitts', 'curtain', 'conditioner', 'food_steak', 'home_office', 'table', 'vase', 'clothes_shirt']  Task:Watch TV  response:  {       thoughts : I walk into the living room and sit on the sofa to watch tv,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'measuring_cup', 'toilet', 'drawing', 'needle', 'hanger', 'floor', 'computer', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'bed', 'novel', 'food_food', 'video_game_controller', 'coffe_maker', 'tray', 'food_onion', 'doorjamb', 'lighter', 'cd', 'clothes_dress', 'bathroom_cabinet', 'light', 'soap']  Task:Read book  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['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:  {       thoughts : go to the kitchen,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'tea_bag', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'hair', 'door']  Task:Write an email  response:

{  I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'photoframe', 'coffe_maker', 'food_rice', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'home_office']  Task:Set up table  response:  {       thoughts : Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'blender', 'toilet', 'jelly', 'chair', 'drawing', 'bathroom_counter', 'floor', 'character', 'food_bacon', 'mat', 'shoe-shine_kit', 'shower', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'pasta', 'oven', 'newspaper', 'check', 'television', 'ice', 'tray', 'doorjamb', 'pencil', 'comb', 'dresser', 'bathroom_cabinet']  Task:Go to toilet  response:

{  Walk to the bathroom. Pull down pants. Use the toilet. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'toy', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'dresser', 'dishwasher', 'shoe_rack']  Task:Watch movie  response:  {       thoughts : Sit down on couch in front of TV.  Use remote to turn on the TV,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'scissors', 'juice', 'toilet', 'freezer', 'bathroom', 'bills', 'orchid', 'shampoo', 'ceiling', 'stamp', 'desk', 'keyboard', 'tvstand', 'couch', 'dustpan', 'dining_room', 'powersocket', 'newspaper', 'check', 'video_game_controller', 'television', 'coffe_maker', 'ice', 'tray', 'doorjamb', 'shoes', 'controller', 'door', 'napkin']  Task:Listen to music  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'scissors', 'chair', 'drawing', 'needle', 'hanger', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'laptop', 'iron', 'mat', 'deck_of_cards', 'mousepad', 'oil', 'wall', 'basket_for_clothes', 'food_donut', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light']  Task:Put on coat  response:  {       thoughts : I remove my scarf from a coat peg in the entrance hall.  I wrap the scarf around my neck,       actions : ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>']  }     Scene_Objects:['sponge', 'filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'detergent', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'mat', 'microphone', 'pillow', 'nightstand', 'wall', 'powersocket', 'bed', 'novel', 'television', 'doorjamb', 'headset', 'shoes', 'controller', 'door', 'light', 'table']  Task:Read book  response:

{  Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dog', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'food_egg', 'hanger', 'floor', 'phone', 'stovefan', 'mat', 'plate', 'stereo', 'dish_soap', 'food_noodles', 'closetdrawer', 'mousepad', 'dustpan', 'cup', 'food_food', 'coffe_maker', 'check', 'oven_mitts', 'water', 'food_rice', 'curtain', 'mouse', 'hairbrush', 'sink', 'home_office']  Task:Wash dishes by hand  response:  {       thoughts : walk to kitchen, fins soap, arrange dishes, wash dishes,       actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[FIND] <dish_soap>', '[FIND] <water>', '[GRAB] <plate>', '[GRAB] <dish_soap>', '[WASH] <plate>', '[RINSE] <plate>', '[DROP] <plate>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'chair', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'door', 'light']  Task:Turn on light  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste']  Task:Pet dog  response:  {       thoughts : Pet my dog in hall,       actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'check', 'mouthwash', 'television', 'doorjamb', 'dresser', 'dishwasher']  Task:Watch TV  response:

{  walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sponge', 'fork', 'filing_cabinet', 'tablelamp', 'chair', 'band-aids', 'floor', 'ceiling', 'stamp', 'alcohol', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'towel', 'wall', 'toy', 'bed', 'keys', 'photoframe', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'table']  Task:Wash dishes  response:  {       thoughts : Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.,       actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>']  }     Scene_Objects:['sheets', 'pot', 'microwave', 'chair', 'freezer', 'food_carrot', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'clothes_jacket', 'table_cloth', 'mat', 'tvstand', 'shower', 'stereo', 'couch', 'pillow', 'wall', 'oven', 'cup', 'food_food', 'television', 'coffee_filter', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'dishwasher']  Task:Cook some food  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'coin', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light']  Task:Watch TV  response:  {       thoughts : I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']  }     Scene_Objects:['chair', 'walllamp', 'drawing', 'knife', 'wallshelf', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'box', 'photoframe', 'television', 'coffee_filter', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dresser']  Task:Change TV channel  response:

{  Walk to livingroom, grab remote and change the channel on television. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['scissors', 'freezer', 'walllamp', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'bookshelf', 'keyboard', 'ceilinglamp', 'plate', 'stereo', 'clothes_socks', 'clothes_pants', 'pillow', 'bowl', 'powersocket', 'cutting_board', 'basket_for_clothes', 'razor', 'coin', 'wine', 'curtain', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'laundry_detergent', 'clothes_shirt', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,       actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'creditcard']  Task:Browse internet  response:

{  Walk to the Home office. Sit on the chair. Switch on the computer. Type with keyboard for 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', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table']  Task:Change TV channel  response:  {       thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button.,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'soap']  Task:Work  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'beer', 'microwave', 'freezer', 'walllamp', 'dough', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'kitchen_counter', 'maindoor', 'bathtub', 'table']  Task:Drink  response:  {       thoughts : Get a can of beer, open it, sit on couch, relax,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <beer>', '[GRAB] <beer>', '[CLOSE] <freezer>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[DRINK] <beer>']  }     Scene_Objects:['tablelamp', 'freezer', 'walllamp', 'detergent', 'drawing', 'knife', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mop_bucket', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'couch', 'clothes_hat', 'pillow', 'wall', 'box', 'photoframe', 'bed', 'coffe_maker', 'television', 'coin', 'doorjamb', 'door', 'sink']  Task:Relax on sofa  response:

{  walk to living room ,find sofa ,sit on sofa }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['blender', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'foundation', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'napkin', 'light', 'table', 'dirt']  Task:Work  response:  {       thoughts : go to home office. turn the computer on. begin working,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'chair', 'cpuscreen', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'toaster', 'mat', 'stovefan', 'faucet', 'shower', 'mousepad', 'broom', 'wall', 'powersocket', 'cup', 'novel', 'coffe_maker', 'mouthwash', 'tray', 'kitchen_counter', 'cupboard', 'conditioner', 'sink', 'napkin', 'soap']  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:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light']  Task:Drink  response:  {       thoughts : im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'homework', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'keys', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Work  response:

{  walk to Office,Walk to desk ,sit down in chair, turn on computer, start homework. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'trashcan', 'bills', 'knife', 'floor', 'desk', 'mail', 'button', 'toaster', 'plate', 'faucet', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'nightstand', 'oven', 'bed', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'tray', 'sink', 'table', 'dishwasher', 'shoe_rack']  Task:Wash dishes with dishwasher  response:  {       thoughts : In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['cd_player', 'freezer', 'ground_coffee', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'hanger', 'dvd_player', 'character', 'ceilinglamp', 'stereo', 'faucet', 'dustpan', 'clothes_hat', 'nightstand', 'wall', 'newspaper', 'check', 'mouthwash', 'video_game_controller', 'food_food', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'sink', 'home_office', 'dishwasher']  Task:Listen to music  response:

{  I walk in the living room, then I go the the stereo and the cd player and turn them 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:['ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'powersocket', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'food_rice', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dirt']  Task:Watch TV  response:  {       thoughts : I like to set on my sofa.Turn on the tv. And watch Perry Mason. Monday's through Friday's.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>']  }     Scene_Objects:['tablelamp', 'chair', 'dog', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'wall', 'nightstand', 'oven', 'photoframe', 'novel', 'television', 'lighter', 'towel_rack', 'mouse', 'dresser', 'door']  Task:Read book  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'food_salt', 'microwave', 'drawing', 'orchid', 'wallshelf', 'floor', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'faucet', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'novel', 'coffe_maker', 'food_rice', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : 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.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'button', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'iron', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'newspaper', 'food_food', 'television', 'doorjamb', 'dresser', 'conditioner']  Task:Change TV channel  response:

{  Walk into the Living room.  Find the television remote.  Use it to turn on the television.  Point the remote at the television. Press the channel button 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:['fork', 'chair', 'walllamp', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'bathroom_cabinet', 'teeth']  Task:Watch TV  response:  {       thoughts : SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['sheets', 'water_glass', 'food_salt', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'stovefan', 'mat', 'iron', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'keys', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'tooth_paste']  Task:Drink  response:

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


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'dresser', 'bathtub', 'sink', 'bathroom_cabinet', 'coffee_cup', 'table', 'light']  Task:Relax on sofa  response:  {       thoughts : you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']  }     Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'conditioner', 'door', 'table', 'shoe_rack']  Task:Relax on sofa  response:

{  For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light']  Task:Read book  response:  {       thoughts : Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']  }     Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'food_butter', 'drawing', 'knife', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'bedroom', 'clothes_jacket', 'faucet', 'shower', 'mousepad', 'couch', 'clothes_pants', 'wall', 'powersocket', 'food_donut', 'tray', 'curtain', 'after_shave', 'pencil', 'vacuum_cleaner', 'clothes_dress', 'sink', 'napkin', 'bathroom_cabinet', 'washing_machine']  Task:Wash clothes  response:

{  Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['trashcan', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'folder', 'keyboard', 'remote_control', 'alcohol', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'curtain', 'food_steak', 'napkin', 'table', 'clothes_shirt', 'creditcard']  Task:Change TV channel  response:  {       thoughts : Take TV remote to change TV Channel. Press channel/program +/- button on TV remote.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>']  }     Scene_Objects:['sponge', 'pot', 'tablelamp', 'microwave', 'hanger', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'mousepad', 'couch', 'candle', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'drinking_glass', 'wooden_spoon', 'curtain', 'tray', 'doorjamb', 'kitchen_counter', 'paper_towel', 'cupboard', 'sink', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:

{  wipe loose dirt, place in the dishwasher, turn on the dishwasher }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', '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:  {       thoughts : walk to living room ,find a book ,open the book ,read the book,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']  }     Scene_Objects:['microwave', 'toilet', 'milk', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'character', 'bedroom', 'stovefan', 'toaster', 'mousepad', 'clothes_pants', 'food_kiwi', 'wall_clock', 'bed', 'television', 'toothbrush_holder', 'water', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'dirt']  Task:Brush teeth  response:

{  today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'pot', 'filing_cabinet', 'microwave', 'chair', 'jelly', 'bathroom', 'detergent', 'knife', 'floor', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'bowl', 'wall', 'cup', 'coffe_maker', 'food_food', 'after_shave', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'spoon', 'home_office', 'table', 'dishwasher']  Task:Wash dishes with dishwasher  response:  {       thoughts : I walk to the kitchen and find the dishwasher. I open it. I find the sink and grab the dirty plates, cups, bowls, and utensils. I rinse off the dirty dishes under the faucet. I then place the dirty dishes into the dishwasher. I add soap to the dishwasher and close the lid. I turn it on and wait.,       actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <sink>', '[FIND] <bowl>', '[GRAB] <bowl>', '[RINSE] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[RINSE] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[RINSE] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[RINSE] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[RINSE] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[TURNTO] <dishwasher>']  }     Scene_Objects:['fork', 'filing_cabinet', 'crayon', 'microwave', 'chair', 'orchid', 'drawing', 'wallshelf', 'floor', 'character', 'table_cloth', 'ceilinglamp', 'plate', 'stereo', 'mat', 'tvstand', 'wall', 'oven', 'cup', 'bed', 'food_food', 'razor', 'oven_mitts', 'tray', 'kitchen_counter', 'spoon', 'table', 'dishwasher', 'teeth', 'creditcard']  Task:Set up table  response:

{  Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above the plate. }


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

{  \ walk to entrance\  \ walk to living room\  \ look for book\  \ find book\  \ pick up book\  \ look for chair\  \ find chair\  \ sit in chair\  \ read book\  }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'mop', 'walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'remote_control', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'box', 'love_seat', 'photoframe', 'television', 'curtain', 'doorjamb', 'dresser', 'clothes_dress', 'bathtub', 'light']  Task:Watch TV  response:  {       thoughts : I'll watch TV,       actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['measuring_cup', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']  Task:Pet cat  response:

{  Find Cat in living room.  Walk to cat.  Pet 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:['fork', 'filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'table', 'clothes_skirt', 'scrabble']  Task:Watch TV  response:  {       thoughts : Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['spectacles', 'mop', 'dog', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'mat', 'closetdrawer', 'couch', 'food_jam', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'food_cheese', 'keys', 'food_food', 'video_game_controller', 'television', 'ice', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher']  Task:Put groceries in Fridge  response:

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