Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['food_salt', 'chair', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'phone', 'remote_control', 'food_bacon', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'powersocket', 'oven', 'cup', 'bed', 'coffe_maker', 'television', 'curtain', 'lighter', 'doorjamb', 'shaving_cream', 'headset', 'cupboard', 'table', 'clothes_shirt']  Task:Watch TV  response:  {       thoughts : We recently got a 43 inch TV and have enjoyed watching some of our favorite movies and TV shows. We use a remote to do so.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['crayon', 'chair', 'detergent', 'cat', 'toothbrush', 'phone', 'character', 'purse', 'thread', 'computer', 'ceilinglamp', 'stereo', 'couch', 'food_peanut_butter', 'towel', 'wall', 'cup', 'food_cheese', 'photoframe', 'light_bulb', 'coffe_maker', 'television', 'towel_rack', 'kitchen_counter', 'dishrack', 'comb', 'dresser', 'door', 'sink', 'instrument_violin']  Task:Keep cats out of room  response:

{  Stand in the doorway and create a loud noise so the cats will stay out. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer']  Task:Take shower  response:  {       thoughts : Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>']  }     Scene_Objects:['sheets', 'cpuscreen', 'phone', 'desk', 'cleaning_solution', 'keyboard', 'purse', 'table_cloth', 'stovefan', 'tvstand', 'shower', 'stereo', 'food_noodles', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'basket_for_clothes', 'photoframe', 'novel', 'food_rice', 'rag', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'napkin', 'table']  Task:Clean  mirror  response:

{  GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['jelly', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall_clock', 'newspaper', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'sink', 'clothes_scarf', 'light']  Task:Watch fly  response:  {       thoughts : Look around for a fly, often on a wall or ceiling.  Follow it's movements.,       actions : ['[WALK] <bedroom>', '[WALK] <fly>', '[FIND] <fly>', '[TURNTO] <fly>', '[LOOKAT] <fly>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'table']  Task:Straighten paintings on wall  response:

{  Go up to the painting and tilt it which ever way it is uneven until it looks straight. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'microwave', 'toilet', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'ceiling', 'desk', 'stovefan', 'faucet', 'mousepad', 'wall', 'nightstand', 'oven', 'check', 'food_food', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cd', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer']  Task:Drink  response:  {       thoughts : I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,       actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['blender', 'tea', 'microwave', 'jelly', 'band-aids', 'freezer', 'bathroom', 'needle', 'ceiling', 'character', 'keyboard', 'mop_bucket', 'ceilinglamp', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'check', 'television', 'cards', 'laundry_detergent', 'clothes_dress', 'home_office', 'table']  Task:Put umbrella away  response:

{  Place the umbrella in the umbrella bucket point first. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', '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:  {       thoughts : you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and work.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['fork', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'mat', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'check', 'mouthwash', 'food_food', 'food_donut', 'wine', 'curtain', 'doorjamb', 'console', 'dresser', 'door', 'light']  Task:Pick up toys  response:

{  Bend down and pick up the toys off of the floor. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['freezer', 'toothbrush', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'computer', 'button', 'pillow', 'dining_room', 'bench', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'dresser', 'cupboard', 'pajamas', 'clothes_dress', 'sink', 'home_office', 'laser_pointer']  Task:Browse internet  response:  {       thoughts : Walk to home office. Walk to computer. Switch on Computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['spectacles', 'filing_cabinet', 'walllamp', 'drawing', 'floor', 'desk', 'tea_bag', 'computer', 'clothes_jacket', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'towel', 'tape', 'basket_for_clothes', 'bed', 'curtain', 'shaving_cream', 'towel_rack', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'hair', 'laundry_detergent', 'bathroom_cabinet', 'light', 'board_game', 'dirt']  Task:Open front door  response:

{  Walk over to the front door, turn the knob, and open the door. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table']  Task:Work  response:  {       thoughts : I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[PUSH] <mouse>', '[FIND] <button>', '[PUSH] <button>']  }     Scene_Objects:['spectacles', 'walllamp', 'nail_polish', 'milk', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'food_bacon', 'piano_bench', 'mat', 'tvstand', 'stereo', 'couch', 'clothes_hat', 'form', 'pillow', 'dining_room', 'wall', 'wall_clock', 'cup', 'photoframe', 'novel', 'coffe_maker', 'television', 'ice', 'doorjamb', 'mouse', 'scrabble']  Task:Read book  response:

{  Sit on a couch, grab a book, open it, and scan the pages }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'walllamp', 'food_butter', 'toothbrush', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'microphone', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'razor', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'door', 'light']  Task:Turn off light  response:  {       thoughts : Hit the switch.,       actions : ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>']  }     Scene_Objects:['beer', 'measuring_cup', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'keyboard', 'purse', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'novel', 'food_food', 'television', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'dresser', 'hairbrush', 'door', 'napkin', 'home_office', 'board_game']  Task:Sweep hallway please  response:

{  Vacuum all the way up and down the hallway.  Get all the dirt and crumbs out of carpet please. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toilet', 'dog', 'band-aids', 'walllamp', 'ground_coffee', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'phone', 'food_cake', 'computer', 'toaster', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'table', 'light', 'scrabble']  Task:Relax on sofa  response:  {       thoughts : I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']  }     Scene_Objects:['dry_pasta', 'sponge', 'filing_cabinet', 'measuring_cup', 'bathroom', 'trashcan', 'food_carrot', 'cpuscreen', 'character', 'computer', 'floor_lamp', 'closetdrawer', 'couch', 'food_peanut_butter', 'food_kiwi', 'oven', 'cup', 'bed', 'video_game_controller', 'doorjamb', 'coffee_pot', 'paper_towel', 'dishrack', 'headset', 'hair', 'cupboard', 'spoon', 'bathroom_cabinet', 'table', 'tooth_paste']  Task:Clean  response:

{  Clean lamp shades in the living room }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'jelly', 'freezer', 'chair', 'blow_dryer', 'bathroom', 'walllamp', 'knife', 'phone', 'keyboard', 'stovefan', 'homework', 'couch', 'food_jam', 'bench', 'oven', 'toy', 'box', 'food_cheese', 'oven_mitts', 'food_rice', 'tray', 'curtain', 'after_shave', 'dresser', 'clothes_dress', 'conditioner', 'hairdryer', 'vase', 'board_game']  Task:Pet cat  response:  {       thoughts : I walk to my living room, find my cat, scrub it using my hand.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']  }     Scene_Objects:['spectacles', 'walllamp', 'bathroom', 'blow_dryer', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'computer', 'mat', 'mousepad', 'closetdrawer', 'food_orange', 'dining_room', 'wall', 'nightstand', 'basket_for_clothes', 'coffe_maker', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'clothes_skirt', 'laser_pointer']  Task:Vacuum  response:

{  Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['walllamp', 'nail_polish', 'trashcan', 'milk', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'computer', 'faucet', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'check', 'coffe_maker', 'wine', 'after_shave', 'towel_rack', 'comb', 'controller', 'sink', 'bathroom_cabinet', 'light', 'table', 'instrument_violin', 'teeth']  Task:Get toilet paper  response:  {       thoughts : There are extra toilet papers in the bottom cabinet.,       actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'bathroom', 'drawing', 'orchid', 'floor', 'bookshelf', 'mat', 'tvstand', 'shower', 'oil', 'closetdrawer', 'candle', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'cup', 'bed', 'photoframe', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'home_office', 'light', 'soap']  Task:Read book  response:

{  Climb into bed, then read the novel }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'stereo', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'wall', 'oven', 'tape', 'check', 'television', 'doorjamb', 'mouse', 'pencil', 'cd', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light', 'table', 'instrument_violin']  Task:Relax on sofa  response:  {       thoughts : I want to relax on the sofa to some relaxing music in the living room.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light']  Task:Research  response:

{  I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'tablelamp', 'food_ice_cream', 'walllamp', 'bathroom', 'ceilingfan', 'trashcan', 'woman', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'bedroom', 'man', 'ceilinglamp', 'window', 'couch', 'wall', 'bench', 'cup', 'newspaper', 'novel', 'check', 'television', 'towel_rack', 'clothes_dress', 'table', 'clothes_skirt', 'creditcard']  Task:Hang with friends  response:  {       thoughts : Sit with friends. Talk,       actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', 'printing_paper']  Task:Print out papers  response:

{  Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'dog', 'freezer', 'knife', 'orchid', 'bathroom_counter', 'character', 'bedroom', 'faucet', 'couch', 'food_orange', 'towel', 'nightstand', 'oven', 'powersocket', 'photoframe', 'check', 'video_game_controller', 'food_donut', 'food_rice', 'food_onion', 'diary', 'dresser', 'hairbrush', 'clothes_scarf', 'napkin', 'bathroom_cabinet', 'colander']  Task:Pet cat  response:  {       thoughts : Walk into the living room. Walk up to the cat. Pet the cat with your hand.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf']  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:['fork', 'tablelamp', 'crayon', 'microwave', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bookshelf', 'computer', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'window', 'oil', 'couch', 'food_jam', 'food_orange', 'wall', 'bench', 'mouthwash', 'television', 'cupboard', 'table', 'clothes_skirt', 'light', 'tooth_paste']  Task:Relax on sofa  response:  {       thoughts : walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']  }     Scene_Objects:['filing_cabinet', 'blender', 'food_ice_cream', 'toilet', 'walllamp', 'detergent', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'tvstand', 'laptop', 'ceilinglamp', 'brush', 'couch', 'pillow', 'dining_room', 'wall', 'child', 'oven', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'dishwasher']  Task:Let baby learn how to walk  response:

{  The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'food_pizza', 'filing_cabinet', 'tablelamp', 'freezer', 'nail_polish', 'cpuscreen', 'desk', 'bookshelf', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'wall', 'wall_clock', 'bed', 'coffe_maker', 'mouthwash', 'video_game_controller', 'television', 'razor', 'check', 'tray', 'curtain', 'cd', 'spoon', 'vase']  Task:Pet cat  response:  {       thoughts : Walk to living room. Find the cat. Walk over to the cat. Touch the cat.,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'detergent', 'food_butter', 'toothbrush', 'drawing', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'dish_soap', 'wall', 'nightstand', 'cup', 'coffe_maker', 'coffee_filter', 'drinking_glass', 'tray', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'dishwasher', 'shoe_rack']  Task:Clean dishes  response:

{  Wash dishes in the sink then place them in the dishwasher. Put detergent in the dishwasher and turn it on when full. }


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

{  A person brings a book into the living room and sits down in a comfortable chair.  If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read.  The person begins reading the book until they need to stop for some reason. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'tea', 'chair', 'freezer', 'ground_coffee', 'drawing', 'orchid', 'floor', 'purse', 'faucet', 'balanceball', 'food_noodles', 'food_peanut_butter', 'wall', 'powersocket', 'toy', 'bed', 'food_food', 'check', 'food_donut', 'doorjamb', 'pencil', 'laundry_detergent', 'door', 'bag', 'napkin', 'light', 'table']  Task:Pick up toys  response:  {       thoughts : Grab toys off floor.  Put it in a container.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'nightstand', 'feet_both', 'photoframe', 'bed', 'television', 'coin', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'shoes', 'hairbrush', 'door']  Task:Put on your shoes  response:

{  Sit on a chair with your shoes in front of you.  Put them on one at a time. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'toilet', 'jelly', 'freezer', 'bathroom', 'drawing', 'orchid', 'character', 'folder', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'food_noodles', 'couch', 'clothes_hat', 'towel', 'nightstand', 'powersocket', 'rag', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'pajamas', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']  Task:Wash hands  response:  {       thoughts : I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel.,       actions : ['[WALK] <dining_room>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[FIND] <towel>', '[RINSE] <towel>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'coffee_cup']  Task:Type up document  response:

{  A person at a computer desk with coffee on the side by the keyboard typing up a document. The person looks relaxed and is typing while looking at the screen which shows a text editor and the content the person was typing. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'tablelamp', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'brush', 'mousepad', 'wall', 'nightstand', 'bed', 'photoframe', 'check', 'food_food', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'door', 'table', 'light', 'shoe_rack']  Task:Listen to music  response:  {       thoughts : I'll walk to my bedroom, where I have my computer. I'll walk to my computer and sit down in front of it. I'll put on my headphones and unlock my computer. I'll then navigate to music stored locally or streamed through the web.,       actions : ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']  }     Scene_Objects:['dry_pasta', 'pot', 'tablelamp', 'microwave', 'chair', 'freezer', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'shower', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table', 'dishwasher', 'light']  Task:Wipe down counter  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'food_bread', 'filing_cabinet', 'tablelamp', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'character', 'food_cake', 'piano_bench', 'brush', 'ceilinglamp', 'mousepad', 'towel', 'wall', 'bed', 'food_food', 'food_donut', 'ice', 'curtain', 'kettle', 'dresser', 'light', 'soap', 'coffee']  Task:Put groceries in Fridge  response:  {       thoughts : Open the fridge, put the groceries in the fridge and close it.,       actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['pot', 'tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'deck_of_cards', 'mousepad', 'couch', 'wall', 'nightstand', 'newspaper', 'television', 'mouse', 'door', 'sink', 'home_office']  Task:Read newspaper  response:

{  Sit in my chair at my desk. Open up newspaper. Read about current events. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['freezer', 'toothbrush', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'computer', 'button', 'pillow', 'dining_room', 'bench', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'dresser', 'cupboard', 'pajamas', 'clothes_dress', 'sink', 'home_office', 'laser_pointer']  Task:Browse internet  response:  {       thoughts : Walk to home office. Walk to computer. Switch on Computer.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['tablelamp', 'chair', 'bathroom', 'milk', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'pillow', 'wall', 'nightstand', 'pasta', 'newspaper', 'television', 'towel_rack', 'mouse', 'headset', 'chessboard', 'door', 'sink']  Task:Read news  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'mop', 'microwave', 'toilet', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'piano_bench', 'ceilinglamp', 'plate', 'deck_of_cards', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'bed', 'novel', 'television', 'doorjamb', 'door', '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:['jelly', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'envelope', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'photoframe', 'check', 'television', 'doorjamb', 'hairbrush', 'pajamas', 'table', 'clothes_shirt', 'dirt']  Task:Read newspaper  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'tablelamp', 'toilet', 'freezer', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'food_cake', 'toaster', 'ceilinglamp', 'couch', 'pillow', 'powersocket', 'basket_for_clothes', 'cup', 'newspaper', 'food_food', 'check', 'oven_mitts', 'wooden_spoon', 'centerpiece', 'kitchen_counter', 'door', 'light']  Task:Pick up phone  response:  {       thoughts : I walk to the home office, find where the phone is and lift the reciever.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['glue', 'filing_cabinet', 'tea', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'food_egg', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'couch', 'pillow', 'wall', 'cup', 'photoframe', 'bed', 'toilet_paper', 'television', 'doorjamb', 'dresser', 'light', 'creditcard']  Task:Read book  response:

{  Pick up a book and open to the last page you were on. Read the book. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'door', 'light']  Task:Browse internet  response:  {       thoughts : I want to surf the internet and look around at funny pictures.,       actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'conditioner', 'door', 'table']  Task:Check email  response:

{  I log onto my computer and then go to the e-mail app, I click on each new email and read them }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack']  Task:Wash hands  response:  {       thoughts : I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']  }     Scene_Objects:['chair', 'walllamp', 'woman', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'stamp', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'box', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'cd', 'dresser', 'table']  Task:Watch movie  response:

{  Sitting and watching  a movie with family }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'dustpan', 'dining_room', 'wall', 'nightstand', 'pasta', 'tape', 'photoframe', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'light']  Task:Turn on computer  response:  {       thoughts : Press the power button on the computer to turn it on,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['filing_cabinet', 'tablelamp', 'freezer', 'orchid', 'floor', 'bedroom', 'keyboard', 'stovefan', 'stereo', 'shower', 'closetdrawer', 'couch', 'dining_room', 'tape', 'cup', 'bed', 'novel', 'television', 'toothbrush_holder', 'doorjamb', 'mouse', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'spoon', 'instrument_guitar', 'table', 'clothes_shirt', 'shoe_rack']  Task:Look out window  response:

{  I head into my child's room and look out the window to view the neighborhood from a different area in the house. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'food_bread', 'crayon', 'measuring_cup', 'chair', 'walllamp', 'trashcan', 'bedroom', 'bookshelf', 'purse', 'table_cloth', 'faucet', 'clothes_socks', 'pillow', 'wall', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'headset', 'dishrack', 'comb', 'dresser', 'spoon', 'instrument_guitar']  Task:Turn on light  response:  {       thoughts : walk to living room, find lamp, switch on.,       actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>']  }     Scene_Objects:['scissors', 'tablelamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'mat', 'tvstand', 'stereo', 'closetdrawer', 'couch', 'clothes_pants', 'food_jam', 'pillow', 'microphone', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'hairdryer', 'light', 'instrument_violin', 'clothes_shirt']  Task:Getting  dresses  response:

{  Putting on undergarments  and 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:['juice', 'food_ice_cream', 'blow_dryer', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shoe-shine_kit', 'couch', 'food_orange', 'wall', 'tape', 'television', 'curtain', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'table']  Task:Relax on sofa  response:  {       thoughts : For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <conditioner>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[LIE] <couch>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'dishwasher']  Task:Work  response:

{  Sit at my computer desk, Turn on Computer. Get online. Work. }


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

{  I sit at my desk and 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:['chair', 'band-aids', 'trashcan', 'dough', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'mousepad', 'food_orange', 'wall', 'oven', 'keys', 'mouse', 'shoes', 'hair', 'dishwasher', 'vase', 'coffee']  Task:Read book  response:  {       thoughts : find a book to read. sit down. read the book.,       actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Pay bills  response:

{  Check my bills, on the computer, open the appropriate sites, pay my due bills }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'ground_coffee', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'stovefan', 'mousepad', 'oil', 'wall', 'bed', 'mouse', 'cupboard', 'door', 'hairdryer', 'table']  Task:Work  response:  {       thoughts : Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>']  }     Scene_Objects:['sheets', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet']  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:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'coffee_table', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'centerpiece', 'door', 'bathroom_cabinet', 'table', 'light', 'board_game']  Task:Watch TV  response:  {       thoughts : I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']  }     Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'computer', 'bookmark', 'stovefan', 'mat', 'tvstand', 'faucet', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'doorjamb', 'coffee_pot', 'dresser', 'bathroom_cabinet', 'dishwasher', 'laser_pointer', 'shoe_rack']  Task:Read book  response:

{  Bring book, lie on the sofa, 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:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'detergent', 'drawing', 'floor', 'ceiling', 'stamp', 'bedroom', 'thread', 'computer', 'toaster', 'faucet', 'mousepad', 'food_peanut_butter', 'wall', 'powersocket', 'toy', 'cup', 'newspaper', 'doorjamb', 'chessboard', 'comb', 'door', 'sink', 'bag', 'light', 'board_game']  Task:Clean  response:  {       thoughts : Enter inside kid's room, begin picking up toys from the floor and putting them in a toy box, leave once once.,       actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']  }     Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'thread', 'computer', 'laptop', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'pasta', 'television', 'tray', 'doorjamb', 'mouse', 'headset', 'chessboard', 'cupboard', 'door']  Task:Watch movie  response:

{  Sit in my deck chair with my laptop, find a good movie on You Tube to watch, plug in earphones and listen to movie quietly so I don't disturb my upstairs neighbor. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'food_bread', 'filing_cabinet', 'tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'mousepad', 'food_noodles', 'pillow', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'doorjamb', 'towel_rack', 'mouse', 'light']  Task:Work  response:  {       thoughts : walk to home office ,find computer ,switch on computer and work,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'crayon', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'door', 'clothes_scarf', 'light']  Task:Re arrange office  response:

{  Walk in.Turn on light.Move furniture. Change the room }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'tablelamp', 'tea', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'desk', 'bedroom', 'computer', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'food_donut', 'curtain', 'food_onion', 'mouse', 'pajamas', 'controller', 'table', 'dishwasher', 'light', 'board_game']  Task:Relax on sofa  response:  {       thoughts : lie in the sofa, relax,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']  }     Scene_Objects:['sheets', 'pot', 'microwave', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'stovefan', 'deck_of_cards', 'shower', 'pillow', 'wall', 'powersocket', 'cup', 'coffe_maker', 'check', 'wine', 'food_onion', 'curtain', 'lighter', 'kitchen_counter', 'cupboard', 'hair', 'controller', 'table', 'dishwasher', 'colander']  Task:Take dishes out of dishwasher  response:

{  Take clean dishes out of the dishwasher and put away }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Write an email  response:  {       thoughts : Find the computer.  Turn on the computer.  Open the e-mail program.  Create a new message.  Write the message.,       actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']  }     Scene_Objects:['sheets', 'filing_cabinet', 'measuring_cup', 'toilet', 'chair', 'cat', 'milk', 'orchid', 'phone', 'video_game_console', 'bookshelf', 'keyboard', 'purse', 'table_cloth', 'brush', 'mat', 'iron', 'couch', 'cup', 'basket_for_clothes', 'video_game_controller', 'oven_mitts', 'food_donut', 'doorjamb', 'console', 'dresser', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office']  Task:Playing video game  response:

{  Playing  video games  on various video game  systems such as wii u  and  xbox }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light']  Task:Put groceries in Fridge  response:  {       thoughts : Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.,       actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_vegetable> <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTIN] <food_carrot> <freezer>', '[FIND] <food_cereal>', '[GRAB] <food_cereal>', '[PUTIN] <food_cereal> <freezer>', '[FIND] <food_oatmeal>', '[GRAB] <food_oatmeal>', '[PUTIN] <food_oatmeal> <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[FIND] <freezer>', '[CLOSE] <freezer>']  }     Scene_Objects:['tablelamp', 'mop', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office']  Task:Social media  checks  response:

{  Logging on to  things like  facebook  and  twitter }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['spectacles', 'tablelamp', 'juice', 'microwave', 'toilet', 'chair', 'walllamp', 'dough', 'drawing', 'cpuscreen', 'floor', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'mail', 'shower', 'picture', 'mousepad', 'wall', 'nightstand', 'bench', 'oven', 'photoframe', 'novel', 'check', 'food_food', 'centerpiece', 'mouse']  Task:Arrange folders  response:  {       thoughts : Go through all my folders and re-arrange in alfabetaical order and put on computer desk,       actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[OPEN] <desk>', '[PUTBACK] <folder> <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[PUTBACK] <folder> <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[PUTBACK] <folder> <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[PUTBACK] <folder> <desk>', '[FIND] <folder>', '[GRAB] <folder>', '[PUTBACK] <folder> <desk>']  }     Scene_Objects:['tablelamp', 'chair', 'cloth_napkin', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'pencil', 'headset', 'dresser', 'door', 'sink']  Task:Clean  response:

{  Use a cloth to wipe away any marks on the computer screen. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'beer', 'mop', 'chair', 'freezer', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'shower', 'window', 'food_orange', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'spoon', 'table', 'light', 'coffee']  Task:Put groceries in Fridge  response:  {       thoughts : I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing 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:['tablelamp', 'walllamp', 'food_butter', 'toothbrush', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'microphone', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'razor', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'door', 'light']  Task:Turn off 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:['pot', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'coffee']  Task:Watch TV  response:  {       thoughts : walk to living room ,find television , switch on remote control,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[SWITCHON] <remote_control>']  }     Scene_Objects:['tablelamp', 'scissors', 'microwave', 'chair', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'brush', 'mat', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'curtain', 'lighter', 'mouse', 'door', 'clothes_scarf']  Task:Enjoy view out window  response:

{  Sitting in teak deck chair, gaze out window at the view. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'ground_coffee', 'trashcan', 'desk', 'bedroom', 'purse', 'mop_bucket', 'shower', 'picture', 'homework', 'mousepad', 'form', 'wall', 'oven', 'bed', 'keys', 'video_game_controller', 'wine', 'food_onion', 'after_shave', 'console', 'mouse', 'cd', 'comb', 'dresser', 'door', 'clothes_skirt', 'dirt']  Task:Pet cat  response:  {       thoughts : Find the cat; pet the cat by touching it,       actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['fork', 'pot', 'food_pizza', 'juice', 'microwave', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'toaster', 'mat', 'stovefan', 'shower', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'coffe_maker', 'television', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'food_snack', 'dishwasher']  Task:Have snack  response:

{  Pour soda into a glass. Get pretzels out of bag. Eat 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:['dry_pasta', 'pot', 'measuring_cup', 'jelly', 'chair', 'freezer', 'hanger', 'ceiling', 'thread', 'computer', 'mail', 'bookmark', 'deck_of_cards', 'faucet', 'mousepad', 'dining_room', 'broom', 'wall', 'wall_clock', 'box', 'razor', 'doorjamb', 'mouse', 'pencil', 'hairbrush', 'door', 'napkin', 'table', 'light', 'dirt']  Task:Pick up phone  response:  {       thoughts : Enter the Home office, then walk to the phone, pickup the phone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'toilet', 'bathroom', 'drawing', 'hanger', 'floor', 'bedroom', 'stovefan', 'mat', 'tvstand', 'stereo', 'faucet', 'couch', 'wall', 'nightstand', 'powersocket', 'oven', 'bed', 'photoframe', 'coffe_maker', 'check', 'kettle', 'kitchen_counter', 'dresser', 'home_office', 'light', 'dishwasher', 'teeth']  Task:Listen to music  response:

{  Put iPhone into speaker holder, open up the Pandora app, 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:['sheets', 'dry_pasta', 'ceilingfan', 'trashcan', 'drawing', 'longboard', 'floor', 'ceiling', 'bedroom', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'shower', 'deck_of_cards', 'couch', 'food_kiwi', 'wall', 'tape', 'basket_for_clothes', 'keys', 'coffe_maker', 'toilet_paper', 'television', 'curtain', 'cd', 'controller', 'table']  Task:Watch TV  response:  {       thoughts : Sit on the couch. Get comfortable. Switch on the television. Stare at the television.,       actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']  }     Scene_Objects:['pot', 'filing_cabinet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'doorjamb', 'towel_rack', 'dresser', 'pajamas', 'sink', 'dishwasher']  Task:Watch TV  response:

{  We sit on the couch facing the tv turn on the television with the remote and watch programs }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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_ice_cream', 'chair', 'food_carrot', 'hanger', 'bathroom_counter', 'floor', 'keyboard', 'mat', 'plate', 'ceilinglamp', 'window', 'mousepad', 'couch', 'food_orange', 'pillow', 'broom', 'wall', 'toy', 'bed', 'toilet_paper', 'television', 'wine', 'curtain', 'food_onion', 'doorjamb', 'dresser', 'spoon', 'home_office', 'table']  Task:Relax on sofa  response:  {       thoughts : Walk to living room. Sit on sofa. Lie down on sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']  }     Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'food_pizza', 'chair', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'floor', 'desk', 'alcohol', 'computer', 'brush', 'mat', 'stovefan', 'toaster', 'tvstand', 'foundation', 'pillow', 'wall', 'toy', 'tape', 'bed', 'keys', 'food_rice', 'curtain', 'pencil', 'comb', 'dresser']  Task:Pick up toys  response:

{  Grab toys off floor.  Put it in a container. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'trashcan', 'dough', 'orchid', 'knife', 'clothes_underwear', 'phone', 'tea_bag', 'envelope', 'mat', 'faucet', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bench', 'powersocket', 'basket_for_clothes', 'food_food', 'food_rice', 'tray', 'curtain', 'after_shave', 'doorjamb', 'pencil', 'laundry_detergent', 'bathroom_cabinet', 'table', 'light', '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:['scissors', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'television', 'doorjamb', 'dresser', 'soap', 'instrument_violin']  Task:Watch TV  response:

{  I sit on my couch and watch TV in my living room }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'blender', 'milk', 'orchid', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'thread', 'stovefan', 'mat', 'toaster', 'faucet', 'plate', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'wall_clock', 'oven', 'tray', 'curtain', 'mouse', 'sink', 'napkin', 'bathroom_cabinet', 'soap']  Task:Wash hands  response:  {       thoughts : walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,,       actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <soap>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'fax_machine', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Write report  response:

{  Sit at a desk, turn on a computer.  Open an existing document and revise it.  Print a hard copy for mailing.  Email a copy to the client. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['pot', 'filing_cabinet', 'chair', 'jelly', 'trashcan', 'toothbrush', 'orchid', 'cpuscreen', 'character', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'faucet', 'shower', 'pillow', 'powersocket', 'bench', 'photoframe', 'bed', 'novel', 'coin', 'kitchen_counter', 'headset', 'chessboard', 'comb', 'dresser', 'table', 'coffee', 'creditcard']  Task:Pick up phone  response:  {       thoughts : Walk to the entrance hall. Find the telephone. Grab the telephone.,       actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[GRAB] <phone>']  }     Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bills', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'mouse', 'shoes', 'comb', 'door', 'light']  Task:Check email  response:

{  Turn on laptop.  Connect to Internet.  Type in the url.  Check for new email messages. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'faucet', 'couch', 'dustpan', 'pillow', 'towel', 'wall', 'nightstand', 'oven', 'box', 'bed', 'keys', 'check', 'toilet_paper', 'television', 'kitchen_counter', 'dresser', 'instrument_guitar', 'soap', 'tooth_paste']  Task:Relax on sofa  response:  {       thoughts : Go to living room.  Find sofa.  Sit on sofa.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']  }     Scene_Objects:['sheets', 'chair', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'brush', 'mat', 'stereo', 'clothes_socks', 'closetdrawer', 'couch', 'mousepad', 'pillow', 'bowl', 'wall', 'powersocket', 'photoframe', 'tray', 'doorjamb', 'pencil', 'shoes', 'cd', 'dresser', 'door', 'bathroom_cabinet', 'light']  Task:Take off shoes  response:

{  Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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:['tablelamp', 'beer', 'chair', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'television', 'food_donut', 'wine', 'tray', 'mouse', 'kitchen_counter', 'door', 'hairdryer']  Task:Read book  response:

{  Sitting and  reading a hardcover book in a recliner }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'bathroom', 'nail_polish', 'detergent', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'table_cloth', 'stereo', 'mousepad', 'broom', 'wall', 'nightstand', 'powersocket', 'oven', 'television', 'rag', 'mouse', 'headset', 'door', 'shoe_rack']  Task:Listen to music  response:  {       thoughts : I walk to my bedroom.  I locate my stereo and turn it on.  I put on my headphones and sit to listen.,       actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[WALK] <stereo>', '[SWITCHON] <stereo>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[FIND] <chair>', '[SIT] <chair>']  }     Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'box', 'cup', 'photoframe', 'television', 'doorjamb', 'coffee_pot', 'dresser', 'light']  Task:Watch TV  response:

{  Sit on the couch. Get comfortable. Switch on the television. Stare at 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:['water_glass', 'scissors', 'blender', 'chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'character', 'desk', 'computer', 'food_bacon', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'cup', 'photoframe', 'newspaper', 'television', 'ice', 'doorjamb', 'diary', 'console', 'towel_rack']  Task:Relax on sofa  response:  {       thoughts : Drink a glass of water in the sofa,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']  }     Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'stamp', 'bookshelf', 'clothes_jacket', 'mop_bucket', 'toaster', 'mat', 'brush', 'shoe-shine_kit', 'laptop', 'couch', 'pillow', 'wall', 'oven', 'cup', 'food_cheese', 'photoframe', 'check', 'television', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'bathroom_cabinet']  Task:Eat cheese  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   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', 'filing_cabinet', 'tablelamp', 'crayon', 'woman', 'wallshelf', 'shampoo', 'floor', 'phone', 'desk', 'man', 'bookshelf', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'child', 'bed', 'photoframe', 'standingmirror', 'toilet_paper', 'oven_mitts', 'towel_rack', 'kitchen_counter', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'vase']  Task:Say goodbye to guests leaving  response:  {       thoughts : Tell them bye,       actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[FIND] <man>', '[TOUCH] <man>', '[FIND] <woman>', '[TOUCH] <woman>']  }     Scene_Objects:['food_pizza', 'chair', 'walllamp', 'dough', 'woman', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'man', 'keyboard', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'television', 'coin', 'wooden_spoon', 'doorjamb', 'clothes_dress', 'clothes_scarf', 'table', 'coffee']  Task:Hang with friends  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['tablelamp', 'toilet', 'freezer', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'table_cloth', 'ceilinglamp', 'faucet', 'couch', 'clothes_hat', 'pillow', 'wall', 'oven', 'bed', 'photoframe', 'television', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light']  Task:Pet cat  response:  {       thoughts : I would walk into the living room. Then sit on the couch and pet the cat.,       actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']  }     Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']  Task:Do homework  response:

{  I do my online homework on the computer.  I use Pearson My Math Lab for math class and excel for my engineering class. }


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['microwave', 'chair', 'walllamp', 'orchid', 'bills', 'cpuscreen', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'microphone', 'form', 'towel', 'wall', 'oven', 'food_food', 'television', 'ice', 'cards', 'mouse', 'pencil', 'cupboard', 'door', 'clothes_scarf', 'table']  Task:Clean  response:  {       thoughts : Wipe down computer desk and monitor,       actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <desk>', '[FIND] <computer>', '[WIPE] <computer>', '[WIPE] <desk>', '[PUTOBJBACK] <rag>']  }     Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'laptop', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']  Task:Write  school paper  response:

{  Writing  and drafting a paper for  class 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:['sheets', 'fork', 'filing_cabinet', 'tablelamp', 'blender', 'mop', 'bathroom', 'detergent', 'toothbrush', 'bills', 'hanger', 'floor', 'bedroom', 'envelope', 'toaster', 'stovefan', 'clothes_socks', 'mousepad', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'toilet_paper', 'towel_rack', 'clothes_dress', 'bag', 'home_office', 'light', 'vase', 'soap', 'washing_machine']  Task:Wash clothes  response:  {       thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,       actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']  }     Scene_Objects:['microwave', 'walllamp', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'computer', 'food_bacon', 'mat', 'tvstand', 'stereo', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'video_game_controller', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'hairdryer', 'bag', 'home_office', 'dishwasher']  Task:Relax  response:


Input: You serve as an AI task planner.   1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format  [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.  2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.   Ensure that you response can be parsed by Python json.loads.      Here is an example plan to achieve a goal for reference:   Scene_Objects:['fork', 'chair', 'freezer', 'knife', 'drawing', 'needle', 'wallshelf', 'floor', 'phone', 'ceiling', 'dvd_player', 'food_bacon', 'ceilinglamp', 'laptop', 'plate', 'shower', 'tvstand', 'tooth_paste', 'wall', 'tape', 'cup', 'novel', 'food_food', 'television', 'coffee_filter', 'hair', 'cupboard', 'table', 'board_game', 'clothes_shirt']  Task:Eat  response:  {       thoughts : I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food,       actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <food_food> <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <plate>', '[EAT] <plate>']  }     Scene_Objects:['microwave', 'toilet', 'bathroom', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'purse', 'computer', 'food_bacon', 'toaster', 'mat', 'closetdrawer', 'candle', 'wall', 'nightstand', 'television', 'curtain', 'doorjamb', 'centerpiece', 'cards', 'shoes', 'dresser', 'hairbrush', 'bathroom_cabinet', 'clothes_shirt', 'shoe_rack']  Task:Put on coat  response:

{  Open closet and grab coat.  Put on coat and fasten the front closed.  Close closet. }