diff --git a/.idea/AgentVerse.iml b/.idea/AgentVerse.iml
new file mode 100644
index 000000000..342c394dc
--- /dev/null
+++ b/.idea/AgentVerse.iml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="3.9 @ Ubuntu-20.04" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+  <component name="TemplatesService">
+    <option name="TEMPLATE_FOLDERS">
+      <list>
+        <option value="$MODULE_DIR$/ui/src/phaser3-rex-plugins/templates" />
+      </list>
+    </option>
+  </component>
+</module>
\ No newline at end of file
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 000000000..f72f5a0dc
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,2 @@
+include agentverse/tasks/*/*
+include agentverse/tasks/*/*/*
diff --git a/README.md b/README.md
index cec72fe9f..6318dc5bd 100644
--- a/README.md
+++ b/README.md
@@ -119,6 +119,16 @@ https://github.com/OpenBMB/AgentVerse/assets/11704492/4d07da68-f942-4205-b558-f1
 
 ## Contents
 
+- [✨ Features](#-features)
+- [📰 What's New](#-whats-new)
+- [🗓 Coming Soon](#-coming-soon)
+- [👾 Simple Demo Video](#-simple-demo-video)
+    - [NLP Classroom](#nlp-classroom)
+    - [Prisoner Dilemma](#prisoner-dilemma)
+    - [Software Design](#software-design)
+    - [Database Administrator (DBA)](#database-administrator-dba)
+    - [Pokemon](#pokemon)
+- [Contents](#contents)
 - [🚀 Getting Started](#-getting-started)
   - [Installation](#installation)
   - [CLI Example](#cli-example)
@@ -141,21 +151,30 @@ https://github.com/OpenBMB/AgentVerse/assets/11704492/4d07da68-f942-4205-b558-f1
 ### Installation
 
 ```bash
-# Install the dependencies
+pip install -U agentverse
+```
+Or you can install the package by manually cloning the latest repository
+```bash
 git clone https://github.com/OpenBMB/AgentVerse.git --depth 1
+cd AgentVerse
 pip install -r requirements.txt
+```
+Some users have reported problems installing the `orjson` required by `gradio`. One simple workaround is to install it with Anaconda `conda install -c conda-forge orjson`.
 
-cd ../
+You also need to export your OpenAI API key as follows
+```bash
+# Export your OpenAI API key
+export OPENAI_API_KEY="your_api_key_here"
+```
+
+If you want to use the tools provided by BMTools, you need to install BMTools as follows:
+```bash
 git clone git+https://github.com/OpenBMB/BMTools.git
 cd BMTools
 pip install -r requirements.txt
 python setup.py develop
-
-# Export your OpenAI API key
-export OPENAI_API_KEY="your_api_key_here"
 ```
 
-Some users have reported problems installing the `orjson` required by `gradio`. One simple workaround is to install it with Anaconda `conda install -c conda-forge orjson`.
 
 <!--
 # Install BMTools
diff --git a/agentverse/agents/__init__.py b/agentverse/agents/__init__.py
index 2a9884af1..1ec070eb5 100644
--- a/agentverse/agents/__init__.py
+++ b/agentverse/agents/__init__.py
@@ -6,4 +6,6 @@
 from .base import BaseAgent
 from .conversation_agent import ConversationAgent
 from .tool_agent import ToolAgent
+
 from .prisoner_dilemma_agent import PoliceAgent, PrisonerAgent
+from .reflection_agent import ReflectionAgent
diff --git a/agentverse/agents/base.py b/agentverse/agents/base.py
index 13db010b7..d604e15fc 100644
--- a/agentverse/agents/base.py
+++ b/agentverse/agents/base.py
@@ -8,7 +8,7 @@
 from agentverse.memory import BaseMemory, ChatHistoryMemory
 from agentverse.message import Message
 from agentverse.parser import OutputParser
-
+from agentverse.memory_manipulator import BaseMemoryManipulator
 
 class BaseAgent(BaseModel):
     name: str
@@ -17,6 +17,7 @@ class BaseAgent(BaseModel):
     prompt_template: str
     role_description: str = Field(default="")
     memory: BaseMemory = Field(default_factory=ChatHistoryMemory)
+    memory_manipulator: BaseMemoryManipulator = Field(default_factory=BaseMemoryManipulator)
     max_retry: int = Field(default=3)
     receiver: Set[str] = Field(default=set({"all"}))
     async_mode: bool = Field(default=True)
diff --git a/agentverse/agents/reflection_agent.py b/agentverse/agents/reflection_agent.py
new file mode 100644
index 000000000..d9b77f78c
--- /dev/null
+++ b/agentverse/agents/reflection_agent.py
@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+"""
+An agent based upon Observation-Planning-Reflection architecture.
+"""
+
+from logging import getLogger
+
+from abc import abstractmethod
+from typing import List, Set, Union, NamedTuple, TYPE_CHECKING
+
+from pydantic import BaseModel, Field, validator
+
+from agentverse.llms import BaseLLM
+from agentverse.memory import BaseMemory, ChatHistoryMemory
+from agentverse.message import Message
+from agentverse.parser import OutputParser
+
+from agentverse.message import Message
+from agentverse.agents.base import BaseAgent
+
+from datetime import datetime as dt
+import datetime
+
+from . import agent_registry
+from string import Template
+
+
+logger = getLogger(__file__)
+
+if TYPE_CHECKING:
+    from agentverse.environments.base import BaseEnvironment
+
+
+@agent_registry.register("reflection")
+class ReflectionAgent(BaseAgent):
+    async_mode: bool = True,
+    current_time: str = None,
+    environment: BaseEnvironment = None
+    step_cnt: int = 0
+
+    manipulated_memory: str = Field(default="", description="one fragment used in prompt construction")
+
+    @validator('current_time')
+    def convert_str_to_dt(cls, current_time):
+        if not isinstance(current_time, str):
+            raise ValueError('current_time should be str')
+        return dt.strptime(current_time, "%Y-%m-%d %H:%M:%S")
+
+    def step(self, current_time: dt, env_description: str = "") -> Message:
+        """
+        Call this method at each time frame
+        """
+        self.current_time = current_time
+
+        self.manipulated_memory = self.memory_manipulator.manipulate_memory()
+
+        prompt = self._fill_prompt_template(env_description)
+
+        parsed_response, reaction, target = None, None, None
+        for i in range(self.max_retry):
+            try:
+                response = self.llm.agenerate_response(prompt)
+                parsed_response = self.output_parser.parse(response)
+
+                if 'say(' in parsed_response.return_values["output"]:
+                    reaction, target = eval("self._" + parsed_response.return_values["output"].strip())
+                elif 'act(' in parsed_response.return_values["output"]:
+                    reaction, target = eval("self._" + parsed_response.return_values["output"].strip())
+                elif 'do_nothing(' in parsed_response.return_values["output"]:
+                    reaction, target = None, None
+                else:
+                    raise Exception(f"no valid parsed_response detected, "
+                                    f"cur response {parsed_response.return_values['output']}")
+                break
+
+            except Exception as e:
+                logger.error(e)
+                logger.warning("Retrying...")
+                continue
+
+        if parsed_response is None:
+            logger.error(f"{self.name} failed to generate valid response.")
+
+        if reaction is None:
+            reaction = "Keep doing last action ..."
+
+        message = Message(
+            content=""
+            if reaction is None
+            else reaction,
+            sender=self.name,
+            receiver=self.get_receiver() if target is None else self.get_valid_receiver(target),
+        )
+
+        self.step_cnt += 1
+
+        return message
+
+    async def astep(self, current_time: dt, env_description: str = "") -> Message:
+        """Asynchronous version of step"""
+        #use environment's time to update agent's time
+        self.current_time = current_time
+        # Before the agent step, we check current status,
+        # TODO add this func after
+        # self.check_status_passive()
+
+        self.manipulated_memory = self.memory_manipulator.manipulate_memory()
+
+        prompt = self._fill_prompt_template(env_description)
+
+        parsed_response, reaction, target = None, None, None
+        for i in range(self.max_retry):
+            try:
+                response = await self.llm.agenerate_response(prompt)
+                parsed_response = self.output_parser.parse(response)
+
+                if 'say(' in parsed_response.return_values["output"]:
+                    reaction, target = eval("self._" + parsed_response.return_values["output"].strip())
+                elif 'act(' in parsed_response.return_values["output"]:
+                    reaction, target = eval("self._" + parsed_response.return_values["output"].strip())
+                elif 'do_nothing(' in parsed_response.return_values["output"]:
+                    reaction, target = None, None
+                else:
+                    raise Exception(f"no valid parsed_response detected, "
+                                    f"cur response {parsed_response.return_values['output']}")
+
+                break
+
+            except Exception as e:
+                logger.error(e)
+                logger.warning("Retrying...")
+                continue
+
+        if parsed_response is None:
+            logger.error(f"{self.name} failed to generate valid response.")
+
+        if reaction is None:
+            reaction = "Keep doing last action ..."
+
+        message = Message(
+            content=""
+            if reaction is None
+            else reaction,
+            sender=self.name,
+            receiver=self.get_receiver() if target is None else self.get_valid_receiver(target),
+        )
+
+        self.step_cnt += 1
+
+        return message
+
+    def _act(self, description=None, target=None):
+        if description is None:
+            return ""
+        if target is None:
+            reaction_content = f"{self.name} performs action: '{description}'."
+        else:
+            reaction_content = f"{self.name} performs action to {target}: '{description}'."
+        # self.environment.broadcast_observations(self, target, reaction_content)
+        return reaction_content, target
+
+    def _say(self, description, target=None):
+        if description is None:
+            return ""
+        if target is None:
+            reaction_content = f"{self.name} says: '{description}'."
+        else:
+            reaction_content = f"{self.name} says to {target}: '{description}'."
+        # self.environment.broadcast_observations(self, target, reaction_content)
+        return reaction_content, target
+
+    def get_valid_receiver(self, target: str) -> set():
+
+        all_agents_name = []
+        for agent in self.environment.agents:
+            all_agents_name.append(agent.name)
+
+        if not (target in all_agents_name):
+            return {"all"}
+        else:
+            return {target}
+
+    def _fill_prompt_template(self, env_description: str = "") -> str:
+        """Fill the placeholders in the prompt template
+
+        In the conversation agent, three placeholders are supported:
+        - ${agent_name}: the name of the agent
+        - ${env_description}: the description of the environment
+        - ${role_description}: the description of the role of the agent
+        - ${chat_history}: the chat history of the agent
+        """
+        input_arguments = {
+            "agent_name": self.name,
+            "role_description": self.role_description,
+            "chat_history": self.memory.to_string(add_sender_prefix=True),
+            "current_time": self.current_time,
+            "env_description": env_description,
+        }
+        return Template(self.prompt_template).safe_substitute(input_arguments)
+
+    def add_message_to_memory(self, messages: List[Message]) -> None:
+        self.memory.add_message(messages)
+
+    def reset(self, environment: BaseEnvironment) -> None:
+        """Reset the agent"""
+        self.environment = environment
+        self.memory.reset()
+        self.memory_manipulator.agent = self
+        self.memory_manipulator.memory = self.memory
+
+
diff --git a/agentverse/environments/__init__.py b/agentverse/environments/__init__.py
index 2167837ed..10b5df128 100644
--- a/agentverse/environments/__init__.py
+++ b/agentverse/environments/__init__.py
@@ -6,6 +6,11 @@
 from .base import BaseEnvironment
 from .basic import BasicEnvironment
 from .pokemon import PokemonEnvironment
+
 from .prisoner_dilemma import PrisonerDilemmaEnvironment
+
 from .sde_team import SdeTeamEnvironment
 from .sde_team_given_tests import SdeTeamGivenTestsEnvironment
+
+from .reflection import ReflectionEnvironment
+
diff --git a/agentverse/environments/reflection.py b/agentverse/environments/reflection.py
new file mode 100644
index 000000000..e511c31a1
--- /dev/null
+++ b/agentverse/environments/reflection.py
@@ -0,0 +1,120 @@
+import asyncio
+import logging
+from typing import Any, Dict, List
+
+from datetime import datetime as dt
+import datetime
+
+from pydantic import Field
+
+from agentverse.agents.conversation_agent import BaseAgent
+from agentverse.environments.rules.base import Rule
+from agentverse.message import Message
+
+from . import env_registry as EnvironmentRegistry
+from .base import BaseEnvironment
+
+from pydantic import validator
+
+@EnvironmentRegistry.register("reflection")
+class ReflectionEnvironment(BaseEnvironment):
+    """
+    Environment used in Observation-Planning-Reflection agent architecture.
+
+    Args:
+        agents: List of agents
+        rule: Rule for the environment
+        max_turns: Maximum number of turns
+        cnt_turn: Current turn number
+        last_messages: Messages from last turn
+        rule_params: Variables set by the rule
+        current_time
+        time_delta: time difference between steps
+    """
+
+    agents: List[BaseAgent]
+    rule: Rule
+    max_turns: int = 10
+    cnt_turn: int = 0
+    last_messages: List[Message] = []
+    rule_params: Dict = {}
+    current_time: dt = dt.now()
+    time_delta: int = 120
+    #
+
+    # @validator("time_delta")
+    # def convert_str_to_timedelta(cls, string):
+    #
+    #     return datetime.timedelta(seconds=int(string))
+
+    def __init__(self, rule, **kwargs):
+        rule_config = rule
+        order_config = rule_config.get("order", {"type": "sequential"})
+        visibility_config = rule_config.get("visibility", {"type": "all"})
+        selector_config = rule_config.get("selector", {"type": "basic"})
+        updater_config = rule_config.get("updater", {"type": "basic"})
+        describer_config = rule_config.get("describer", {"type": "basic"})
+        rule = Rule(
+            order_config,
+            visibility_config,
+            selector_config,
+            updater_config,
+            describer_config,
+        )
+
+        super().__init__(rule=rule, **kwargs)
+
+    async def step(self) -> List[Message]:
+        """Run one step of the environment"""
+
+        logging.log(logging.INFO, f"Tick tock. Current time: {self.current_time}")
+
+        # Get the next agent index
+        agent_ids = self.rule.get_next_agent_idx(self)
+
+        # Generate current environment description
+        env_descriptions = self.rule.get_env_description(self)
+
+        # Generate the next message
+        messages = await asyncio.gather(
+            *[self.agents[i].astep(self.current_time, env_descriptions[i]) for i in agent_ids]
+        )
+
+        # Some rules will select certain messages from all the messages
+        selected_messages = self.rule.select_message(self, messages)
+        self.last_messages = selected_messages
+        self.print_messages(selected_messages)
+
+        # Update the memory of the agents
+        self.rule.update_memory(self)
+
+        # Update the set of visible agents for each agent
+        self.rule.update_visible_agents(self)
+
+        self.cnt_turn += 1
+
+        # update current_time
+        self.tick_tock()
+
+        return selected_messages
+
+    def print_messages(self, messages: List[Message]) -> None:
+        for message in messages:
+            if message is not None:
+                logging.info(f"{message.sender}: {message.content}")
+
+    def reset(self) -> None:
+        """Reset the environment"""
+        self.cnt_turn = 0
+        self.rule.reset()
+        BaseAgent.update_forward_refs()
+        for agent in self.agents:
+            agent.reset(environment=self)
+
+    def is_done(self) -> bool:
+        """Check if the environment is done"""
+        return self.cnt_turn >= self.max_turns
+
+    def tick_tock(self) -> None:
+        """Increment the time"""
+        self.current_time = self.current_time + datetime.timedelta(seconds=self.time_delta)
diff --git a/agentverse/environments/rules/updater/__init__.py b/agentverse/environments/rules/updater/__init__.py
index 34f672f8c..5ede50936 100644
--- a/agentverse/environments/rules/updater/__init__.py
+++ b/agentverse/environments/rules/updater/__init__.py
@@ -6,4 +6,5 @@
 from .basic import BasicUpdater
 from .classroom import ClassroomUpdater
 from .sde_team import SdeTeamUpdater
+
 from .pokemon import PokemonUpdater
diff --git a/agentverse/initialization.py b/agentverse/initialization.py
index 89104d770..c60172796 100644
--- a/agentverse/initialization.py
+++ b/agentverse/initialization.py
@@ -4,13 +4,18 @@
 from typing import Dict, List, TYPE_CHECKING
 
 import yaml
-from bmtools.agent.singletool import import_all_apis, load_single_tools
+try:
+    from bmtools.agent.singletool import import_all_apis, load_single_tools
+except:
+    print("BMTools is not installed, tools cannot be used. To install BMTools, \
+         please follow the instruction in the README.md file.")
 
 from agentverse.llms import llm_registry
 
 from agentverse.agents import agent_registry
 from agentverse.environments import BaseEnvironment, env_registry
 from agentverse.memory import memory_registry
+from agentverse.memory_manipulator import memory_manipulator_registry
 
 from agentverse.parser import output_parser_registry
 
@@ -28,6 +33,10 @@ def load_memory(memory_config: Dict):
     memory_type = memory_config.pop("memory_type", "chat_history")
     return memory_registry.build(memory_type, **memory_config)
 
+def load_memory_manipulator(memory_manipulator_config: Dict):
+    memory_manipulator_type = memory_manipulator_config.pop("memory_manipulator_type", "basic")
+    return memory_manipulator_registry.build(memory_manipulator_type, **memory_manipulator_config)
+
 
 def load_tools(tool_config: List[Dict]):
     if len(tool_config) == 0:
@@ -86,6 +95,10 @@ def prepare_task_config(task):
             agent_configs["tool_memory"] = load_memory(agent_configs["tool_memory"])
         llm = load_llm(agent_configs.get("llm", "text-davinci-003"))
         agent_configs["llm"] = llm
+
+        memory_manipulator = load_memory_manipulator(agent_configs.get("memory_manipulator", {}))
+        agent_configs["memory_manipulator"] = memory_manipulator
+
         agent_configs["tools"] = load_tools(agent_configs.get("tools", []))
 
         agent_configs["output_parser"] = task_config["output_parser"]
diff --git a/agentverse/llms/openai.py b/agentverse/llms/openai.py
index 10495f8bb..9b9332f01 100644
--- a/agentverse/llms/openai.py
+++ b/agentverse/llms/openai.py
@@ -1,4 +1,6 @@
 import logging
+import numpy as np
+import time
 import os
 from typing import Dict, List, Optional, Union
 
@@ -9,6 +11,8 @@
 from . import llm_registry
 from .base import BaseChatModel, BaseCompletionModel, BaseModelArgs
 
+logger = logging.getLogger(__name__)
+
 try:
     import openai
     from openai.error import OpenAIError
@@ -125,3 +129,21 @@ async def agenerate_response(self, prompt: str) -> LLMResult:
             recv_tokens=response["usage"]["completion_tokens"],
             total_tokens=response["usage"]["total_tokens"],
         )
+
+
+def get_embedding(text: str, attempts=3) -> np.array:
+    attempt = 0
+    while attempt < attempts:
+        try:
+            text = text.replace("\n", " ")
+            embedding = openai.Embedding.create(
+                input=[text], model="text-embedding-ada-002"
+            )["data"][0]["embedding"]
+            return tuple(embedding)
+        except Exception as e:
+            attempt += 1
+            logger.error(f"Error {e} when requesting openai models. Retrying")
+            time.sleep(10)
+    logger.warning(
+        f"get_embedding() failed after {attempts} attempts. returning empty response"
+    )
\ No newline at end of file
diff --git a/agentverse/memory/__init__.py b/agentverse/memory/__init__.py
index 9d053b86e..fe6ffc2e8 100644
--- a/agentverse/memory/__init__.py
+++ b/agentverse/memory/__init__.py
@@ -6,3 +6,4 @@
 from .chat_history import ChatHistoryMemory
 from .summary import SummaryMemory
 from .sde_team import SdeTeamMemory
+from .vectorstore import VectorStoreMemory
diff --git a/agentverse/memory/vectorstore.py b/agentverse/memory/vectorstore.py
new file mode 100644
index 000000000..4f8de5cb5
--- /dev/null
+++ b/agentverse/memory/vectorstore.py
@@ -0,0 +1,63 @@
+from typing import List, Union
+
+from pydantic import Field
+
+from agentverse.message import Message
+from agentverse.llms import BaseLLM
+from agentverse.llms.openai import get_embedding, OpenAIChat
+
+
+from . import memory_registry
+from .base import BaseMemory
+
+
+
+@memory_registry.register("vectorstore")
+class VectorStoreMemory(BaseMemory):
+
+    """
+
+    The main difference of this class with chat_history is that this class treat memory as a dict
+
+    treat message.content as memory
+
+    Attributes:
+        messages (List[Message]) : used to store messages, message.content is the key of embeddings.
+        embedding2memory (dict) : `key` is the embedding and `value` is the message
+        memory2embedding (dict) : `key` is the message and `value` is the embedding
+        llm (BaseLLM) : llm used to get embeddings
+
+
+    Methods:
+        add_message : Additionally, add the embedding to embeddings
+
+    """
+
+    messages: List[Message] = Field(default=[])
+    embedding2memory: dict = {}
+    memory2embedding: dict = {}
+    llm: BaseLLM = OpenAIChat(model="gpt-4")
+
+    def add_message(self, messages: List[Message]) -> None:
+        for message in messages:
+            self.messages.append(message)
+            memory_embedding = get_embedding(message.content)
+            self.embedding2memory[memory_embedding] = message.content
+            self.memory2embedding[message.content] = memory_embedding
+
+    def to_string(self, add_sender_prefix: bool = False) -> str:
+        if add_sender_prefix:
+            return "\n".join(
+                [
+                    f"[{message.sender}]: {message.content}"
+                    if message.sender != ""
+                    else message.content
+                    for message in self.messages
+                ]
+            )
+        else:
+            return "\n".join([message.content for message in self.messages])
+
+    def reset(self) -> None:
+        self.messages = []
+
diff --git a/agentverse/memory_manipulator/__init__.py b/agentverse/memory_manipulator/__init__.py
new file mode 100644
index 000000000..6ae836614
--- /dev/null
+++ b/agentverse/memory_manipulator/__init__.py
@@ -0,0 +1,7 @@
+from agentverse.registry import Registry
+
+memory_manipulator_registry = Registry(name="Memory_Manipulator_Registry")
+
+from .base import BaseMemoryManipulator
+from .reflection import Reflection
+
diff --git a/agentverse/memory_manipulator/base.py b/agentverse/memory_manipulator/base.py
new file mode 100644
index 000000000..81e7c58d2
--- /dev/null
+++ b/agentverse/memory_manipulator/base.py
@@ -0,0 +1,17 @@
+from abc import abstractmethod
+from typing import Dict, List
+
+from pydantic import BaseModel, Field
+
+from agentverse.message import Message
+
+
+class BaseMemoryManipulator(BaseModel):
+
+    @abstractmethod
+    def manipulate_memory(self) -> None:
+        pass
+
+    @abstractmethod
+    def reset(self) -> None:
+        pass
diff --git a/agentverse/memory_manipulator/basic.py b/agentverse/memory_manipulator/basic.py
new file mode 100644
index 000000000..a36a604bb
--- /dev/null
+++ b/agentverse/memory_manipulator/basic.py
@@ -0,0 +1,16 @@
+from abc import abstractmethod
+from typing import Dict, List
+
+from pydantic import BaseModel, Field
+
+from agentverse.message import Message
+from agentverse.memory_manipulator import BaseMemoryManipulator
+
+@memory_manipulator_registry.register("basic")
+class BasicMemoryManipulator(BaseMemoryManipulator):
+
+    def manipulate_memory(self) -> None:
+        pass
+
+    def reset(self) -> None:
+        pass
diff --git a/agentverse/memory_manipulator/reflection.py b/agentverse/memory_manipulator/reflection.py
new file mode 100644
index 000000000..b57e2f366
--- /dev/null
+++ b/agentverse/memory_manipulator/reflection.py
@@ -0,0 +1,305 @@
+from __future__ import annotations
+from typing import List, Union, Optional, Any, TYPE_CHECKING
+from collections import defaultdict
+
+from pydantic import Field
+import numpy as np
+from datetime import datetime as dt
+
+import re
+
+from agentverse.llms.openai import get_embedding
+from sklearn.metrics.pairwise import cosine_similarity
+
+from agentverse.message import Message
+from agentverse.memory import BaseMemory
+
+from logging import getLogger
+
+from . import memory_manipulator_registry
+from .base import BaseMemoryManipulator
+
+if TYPE_CHECKING:
+    from agentverse.memory import VectorStoreMemory
+    from agentverse.agents.base import BaseAgent
+
+
+logger = getLogger(__file__)
+
+IMPORTANCE_PROMPT = """On the scale of 1 to 10, where 1 is purely mundane \
+(e.g., brushing teeth, making bed) and 10 is \
+extremely poignant (e.g., a break up, college \
+acceptance), rate the likely poignancy of the \
+following piece of memory. \
+If you think it's too hard to rate it, you can give an inaccurate assessment. \
+The content or people mentioned is not real. You can hypothesis any reasonable context. \
+Please strictly only output one number. \
+Memory: {} \
+Rating: """
+IMMEDIACY_PROMPT = """On the scale of 1 to 10, where 1 is requiring no short time attention\
+(e.g., a bed is in the room) and 10 is \
+needing quick attention or immediate response(e.g., being required a reply by others), rate the likely immediacy of the \
+following statement. \
+If you think it's too hard to rate it, you can give an inaccurate assessment. \
+The content or people mentioned is not real. You can hypothesis any reasonable context. \
+Please strictly only output one number. \
+Memory: {} \
+Rating: """
+QUESTION_PROMPT = """Given only the information above, what are 3 most salient \
+high-level questions we can answer about the subjects in the statements?"""
+
+INSIGHT_PROMPT = """What at most 5 high-level insights can you infer from \
+the above statements? Only output insights with high confidence. 
+example format: insight (because of 1, 5, 3)"""
+
+
+@memory_manipulator_registry.register("reflection")
+class Reflection(BaseMemoryManipulator):
+
+    memory: VectorStoreMemory = None
+    agent: BaseAgent = None
+
+    reflection: str = ""
+
+    importance_threshold: int = 10
+    accumulated_importance: int = 0
+
+    memory2importance: dict = {}
+    memory2immediacy: dict = {}
+    memory2time: defaultdict = Field(default=defaultdict(dict))
+
+    # TODO newly added func from generative agents
+
+    def manipulate_memory(self) -> None:
+
+        # reflect here
+        if self.should_reflect():
+            logger.debug(
+                f"Agent {self.agent.name} is now doing reflection since accumulated_importance={self.accumulated_importance} < reflection_threshold={self.importance_threshold}"
+            )
+            self.reflection = self.reflect()
+            return self.reflection
+        else:
+            logger.debug(
+                f"Agent {self.agent.name} doesn't reflect since accumulated_importance={self.accumulated_importance} < reflection_threshold={self.importance_threshold}"
+            )
+
+            return ""
+
+    def get_accumulated_importance(self):
+
+        accumulated_importance = 0
+
+        for memory in self.memory.messages:
+
+            if memory.content not in self.memory2importance or memory.content not in self.memory2immediacy:
+                self.memory2importance[memory.content] = self.get_importance(memory.content)
+                self.memory2immediacy[memory.content] = self.get_immediacy(memory.content)
+
+        for score in self.memory2importance.values():
+            accumulated_importance += score
+
+        self.accumulated_importance = accumulated_importance
+
+        return accumulated_importance
+
+    def should_reflect(self):
+
+        if self.get_accumulated_importance() >= self.importance_threshold:
+            # double the importance_threshold
+            self.importance_threshold *= 2
+            return True
+        else:
+            return False
+
+    def get_questions(self, texts):
+        prompt = "\n".join(texts) + "\n" + QUESTION_PROMPT
+        result = self.agent.llm.generate_response(prompt)
+        result = result.content
+        questions = [q for q in result.split("\n") if len(q.strip()) > 0]
+        questions = questions[:3]
+        return questions
+
+    def get_insights(self, statements):
+        prompt = ""
+        for i, st in enumerate(statements):
+            prompt += str(i + 1) + ". " + st + "\n"
+        prompt += INSIGHT_PROMPT
+        result = self.agent.llm.generate_response(prompt)
+        result = result.content
+        insights = [isg for isg in result.split("\n") if len(isg.strip()) > 0][:5]
+        insights = [".".join(i.split(".")[1:]) for i in insights]
+        # remove insight pointers for now
+        insights = [i.split("(")[0].strip() for i in insights]
+        return insights
+
+    def get_importance(self, content: str):
+        """
+        Exploit GPT to evaluate the importance of this memory
+        """
+        prompt = IMPORTANCE_PROMPT.format(content)
+        result = self.memory.llm.generate_response(prompt)
+
+        try:
+            score = int(re.findall(r"\s*(\d+)\s*", result.content)[0])
+        except Exception as e:
+            logger.warning(
+                f"Found error {e} Abnormal result of importance rating '{result}'. Setting default value"
+            )
+            score = 0
+        return score
+
+    def get_immediacy(self, content: str):
+        """
+        Exploit GPT to evaluate the immediacy of this memory
+        """
+        prompt = IMMEDIACY_PROMPT.format(content)
+        result = self.memory.llm.generate_response(prompt)
+        try:
+            score = int(re.findall(r"\s*(\d+)\s*", result.content)[0])
+        except Exception as e:
+            logger.warning(
+                f"Found error {e} Abnormal result of importance rating '{result}'. Setting default value"
+            )
+            score = 0
+        return score
+
+    def query_similarity(
+            self, text: Union[str, List[str]], k: int, memory_bank: List, current_time=dt.now(), nms_threshold=0.99
+    ) -> List[str]:
+        """
+        get top-k entry based on recency, relevance, importance, immediacy
+        The query result can be Short-term or Long-term queried result.
+        formula is
+        `score= sim(q,v) *max(LTM_score, STM_score)`
+        `STM_score=time_score(createTime)*immediacy`
+        `LTM_score=time_score(accessTime)*importance`
+        time score is exponential decay weight. stm decays faster.
+
+        The query supports querying based on multiple texts and only gives non-overlapping results
+        If nms_threshold is not 1, nms mechanism if activated. By default,
+        use soft nms with modified iou base(score starts to decay iff cos sim is higher than this value,
+         and decay weight at this value if 0. rather than 1-threshold).
+
+        Args:
+            text: str
+            k: int
+            memory_bank: List
+            current_time: dt.now
+            nms_threshold: float = 0.99
+
+
+        Returns: List[str]
+        """
+        assert len(text) > 0
+        texts = [text] if isinstance(text, str) else text
+        maximum_score = None
+        for text in texts:
+            embedding = get_embedding(text)
+            score = []
+            for memory in memory_bank:
+
+                if memory.content not in self.memory2time:
+                    self.memory2time[memory.content]["last_access_time"] = dt.now()
+                    self.memory2time[memory.content]["create_time"] = dt.now()
+
+                last_access_time_diff = \
+                    (current_time - self.memory2time[memory.content]["last_access_time"]).total_seconds() // 3600
+                recency = np.power(
+                    0.99, last_access_time_diff
+                )  # TODO: review the metaparameter 0.99
+
+                create_time_diff = (current_time - self.memory2time[memory.content]["create_time"]).total_seconds() // 60
+                instancy = np.power(
+                    0.90, create_time_diff
+                )  # TODO: review the metaparameter 0.90
+
+                relevance = cosine_similarity(
+                    np.array(embedding).reshape(1, -1),
+                    np.array(self.memory.memory2embedding[memory.content]).reshape(1, -1),
+                )[0][0]
+
+                if memory.content not in self.memory2importance or memory.content not in self.memory2immediacy:
+                    self.memory2importance[memory.content] = self.get_importance(memory.content)
+                    self.memory2immediacy[memory.content] = self.get_immediacy(memory.content)
+
+                importance = self.memory2importance[memory.content] / 10
+                immediacy = self.memory2immediacy[memory.content] / 10
+
+                ltm_w = recency * importance
+                stm_w = instancy * immediacy
+
+                score.append(relevance * np.maximum(ltm_w, stm_w))
+
+            score = np.array(score)
+
+            if maximum_score is not None:
+                maximum_score = np.maximum(score, maximum_score)
+            else:
+                maximum_score = score
+
+        if nms_threshold == 1.0:
+            # no nms is triggered
+            top_k_indices = np.argsort(maximum_score)[-k:][::-1]
+        else:
+            # TODO: soft-nms
+            assert 0 <= nms_threshold < 1
+            top_k_indices = []
+            while len(top_k_indices) < min(k, len(memory_bank)):
+                top_index = np.argmax(maximum_score)
+                top_k_indices.append(top_index)
+                maximum_score[top_index] = -1  # anything to prevent being chosen again
+                top_embedding = self.memory.memory2embedding[memory_bank[top_index].content]
+                cos_sim = cosine_similarity(
+                    np.array(top_embedding).reshape(1, -1),
+                    np.array([self.memory.memory2embedding[memory.content] for memory in memory_bank]),
+                )[0]
+                score_weight = np.ones_like(maximum_score)
+                score_weight[cos_sim >= nms_threshold] -= \
+                    (cos_sim[cos_sim >= nms_threshold] - nms_threshold) / (1 - nms_threshold)
+                maximum_score = maximum_score * score_weight
+
+        # access them and refresh the access time
+        for i in top_k_indices:
+            self.memory2time[memory_bank[i].content]["last_access_time"] = current_time
+        # sort them in time periods. if the data tag is 'observation', ad time info output.
+        top_k_indices = sorted(
+            top_k_indices, key=lambda x: self.memory2time[memory_bank[x].content]["create_time"]
+        )
+        query_results = []
+        for i in top_k_indices:
+            query_result = memory_bank[i].content
+            query_results.append(query_result)
+
+        return query_results
+
+    def get_memories_of_interest_oneself(self):
+        memories_of_interest = []
+        for memory in self.memory.messages[-100:]:
+            if memory.sender == self.agent.name:
+                memories_of_interest.append(memory)
+        return memories_of_interest
+
+    def reflect(self):
+        """
+        initiate a reflection that inserts high level knowledge to memory
+        """
+        memories_of_interest = self.get_memories_of_interest_oneself()
+        questions = self.get_questions([m.content for m in memories_of_interest])
+        statements = self.query_similarity(questions, len(questions) * 10, memories_of_interest)
+        insights = self.get_insights(statements)
+        logger.info(self.agent.name + f" Insights: {insights}")
+        for insight in insights:
+            # convert insight to messages
+            # TODO currently only oneself can see its own reflection
+            insight_message = Message(
+                    content=insight,
+                    sender=self.agent.name,
+                    receiver={self.agent.name})
+            self.memory.add_message([insight_message])
+        reflection = "\n".join(insights)
+        return reflection
+
+    def reset(self) -> None:
+
+        self.reflection = ""
diff --git a/agentverse/tasks/__init__.py b/agentverse/tasks/__init__.py
index e0fb8a5c5..fbd2c8335 100644
--- a/agentverse/tasks/__init__.py
+++ b/agentverse/tasks/__init__.py
@@ -15,3 +15,5 @@
 from .pokemon.output_parser import PokemonParser
 from .sde_team.sde_team_3players.output_parser import SdeTeamParser
 from .sde_team.sde_team_2players.output_parser import SdeTeamGivenTestsParser
+
+from .alice_home.output_parser import AliceHomeParser
diff --git a/agentverse/tasks/alice_home/config.yaml b/agentverse/tasks/alice_home/config.yaml
new file mode 100644
index 000000000..afec6e036
--- /dev/null
+++ b/agentverse/tasks/alice_home/config.yaml
@@ -0,0 +1,125 @@
+prompts:
+  prompt: &prompt |-
+    Now you are act for as an agent named ${agent_name} in a virtual world. You might need to performing reaction to the observation. Your mission to take the agent as yourself and directly provide what the agent will do to the observations based on the following information:
+    (1) The agent's description: ${role_description}
+    (2) Current time is ${current_time}
+    (3) Your history memory is ${chat_history}
+
+    In terms of how you actually perform the action in the virtual world, you take action for the agent by calling functions. Currently, there are the following functions that can be called.
+    - do_nothing(): Do nothing. There is nothing that you like to respond to, this will make you stick to your original status and plan.
+    - act(description, target=None): do some action. `description` describes the action, set `description` to None for not act. `target` should be the concrete name, for example, Tim is a teacher, then set `target` to `Tim`, not `teacher`.
+    - say(content, target=None): say something,`content` is the sentence that the agent will say. **Do not say to yourself, neither to inanimate objects.**
+
+    Call one function at a time, please give a thought before calling these actions, i.e., use the following format strictly:
+
+    [OPTION 1]
+    Thought: None of the observation attract my attention, I need to:
+    Action: do_nothing()
+
+    [OPTION 2]
+    Thought: due to `xxx`, I need to:
+    Action: act("Wash the dishes", target=None)
+
+    [OPTION 3]
+    Thought: due to `xxx`, I need to:
+    Action: say("hello", target="Alice")
+
+    Now begin your actions as the agent. Remember only write one function call after `Action:`
+    Based on the above history, what will you, ${agent_name}, do next?
+
+name: alice_home
+
+environment:
+  env_type: reflection
+  max_turns: 30
+  current_time: "2023-04-01 07:00:00"
+  time_delta: 1800  # in seconds
+  rule:
+    order:
+      type: concurrent
+    visibility:
+      type: all
+    selector:
+      type: basic
+    updater:
+      type: basic
+    describer:
+      type: basic
+
+agents:
+  -
+    agent_type: reflection
+    name: Alice
+    role_description:  |-
+      Alice is traits: friendly, outgoing, hospitable.
+      Alice is a 10-year-old student at Town Elementary School.
+      Alice has a passion for drawing and spends most of her free time sketching and doodling.
+      Alice finds educational television programs to be dull and uninteresting.
+      Alice's father's name is Bob, and he works as a mechanic at the local car dealership.
+      Alice's mother's name is Carot, and she is a nurse at the nearby hospital.
+      Alice has a younger sister named Lily, who is 6 years old and also attends Town Elementary School.
+      Alice enjoys playing soccer with her friends during recess and after school.
+      Alice is a fan of science fiction books and loves reading about space exploration and aliens.
+      Alice is learning to play the piano and practices every day after school.
+      Alice's favorite food is pizza, and she loves trying out different toppings and combinations.
+      Alice will wake up and complete the morning routine at 7:00 am.
+      Alice will have breakfast with her family at 8:00 am.
+      Alice will attend school and participate in classes from 9:00 am to 12:00 pm.
+      Alice will have lunch at school with her friends at 12:30 pm.
+      Alice will return home at 1:00 pm and watch her favorite TV show.
+      Alice will practice playing the piano for 30 minutes at 2:00 pm.
+      Alice will work on her drawing skills for an hour at 3:00 pm.
+      Alice will go out for a 30-minute jog around the neighborhood at 4:00 pm.
+      Alice will help her mother prepare dinner at 5:00 pm.
+      Alice will have dinner with her family at 6:00 pm.
+      Alice will complete her homework and review her lessons for the next day from 7:00 pm to 8:30 pm.
+      Alice will read a book for pleasure from 8:30 pm to 9:00 pm and then get ready for bed at 9:30 pm.
+    memory: 
+      memory_type: vectorstore
+    memory_manipulator:
+      memory_manipulator_type: reflection
+    prompt_template: *prompt
+    llm:
+      model: "gpt-4"
+      llm_type: gpt-4
+      temperature: 0.3
+      max_tokens: 128
+    current_time: "2023-04-01 07:00:00"
+  -
+    agent_type: reflection
+    name: Bob
+    role_description: |-
+      Bob is hard-working, friendly, knowledgeable.
+      Bob is a 42-year-old mechanic who works at the local car dealership.
+      Bob is known for his expertise in engine repairs and his friendly demeanor with customers.
+      Bob is married to Carot, who works as a nurse at the nearby hospital.
+      Bob has two children: Alice, who is 13 years old and loves to draw, and Lily, who is 6 years old and enjoys playing with dolls.
+      Bob enjoys restoring old cars in his free time and has a collection of classic cars in his garage.
+      Bob is a fan of football and enjoys watching games with his friends at the local sports bar.
+      Bob is always willing to help out his neighbors with car trouble or home repairs.
+      Bob is planning a family vacation to the beach this summer and is excited to spend time with his family.
+      Bob's favorite food is barbecue ribs, and he loves to cook them on his smoker on the weekends.
+      Bob is proud of his daughter Alice's talent for drawing and encourages her to pursue her passion.
+      Bob will wake up and have breakfast with his family at 6:30 am.
+      Bob will drive to work and arrive at the car dealership at 8:00 am.
+      Bob will work on fixing cars and helping customers until lunchtime.
+      Bob will have lunch at the nearby diner at 12:00 pm.
+      Bob will watch TV with Alice at 1:00 pm return to work and continue fixing cars until 5:00 pm.
+      Bob will drive home and help his wife prepare dinner at 5:30 pm.
+      Bob will have dinner with his family at 6:00 pm.
+      Bob will relax and watch TV with his family until 8:00 pm.
+      Bob will work on his car restoration project in the garage until 10:00 pm.
+      Bob will and then get ready for bed at 10:30 pm.
+    memory: 
+      memory_type: vectorstore
+    memory_manipulator:
+      memory_manipulator_type: reflection
+    prompt_template: *prompt
+    llm:
+      model: "gpt-4"
+      llm_type: gpt-4
+      temperature: 0.3
+      max_tokens: 128
+    current_time: "2023-04-01 07:00:00"
+
+tools: ~
\ No newline at end of file
diff --git a/agentverse/tasks/alice_home/output_parser.py b/agentverse/tasks/alice_home/output_parser.py
new file mode 100644
index 000000000..32d6a5faa
--- /dev/null
+++ b/agentverse/tasks/alice_home/output_parser.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import re
+from typing import Union
+
+from agentverse.parser import OutputParser, LLMResult
+
+from agentverse.utils import AgentAction, AgentFinish
+
+from agentverse.parser import OutputParserError, output_parser_registry
+
+
+@output_parser_registry.register("alice_home")
+class AliceHomeParser(OutputParser):
+    def parse(self, output: LLMResult) -> Union[AgentAction, AgentFinish]:
+        text = output.content
+        cleaned_output = text.strip()
+        cleaned_output = re.sub(r"\n+", "\n", cleaned_output)
+        cleaned_output = cleaned_output.split("\n")
+        if not (
+            len(cleaned_output) == 2
+            and cleaned_output[0].startswith("Thought:")
+            and cleaned_output[1].startswith("Action:")
+        ):
+            raise OutputParserError(text)
+
+        action = cleaned_output[1][len("Action:"):].strip()
+
+        return AgentFinish({"output": action}, text)
diff --git a/agentverse/tasks/prisoner_dilemma/config.yaml b/agentverse/tasks/prisoner_dilemma/config.yaml
index 6b2b79005..ac3496eb2 100644
--- a/agentverse/tasks/prisoner_dilemma/config.yaml
+++ b/agentverse/tasks/prisoner_dilemma/config.yaml
@@ -19,8 +19,13 @@ prompts:
 name: prisoner_dilemma
 
 environment:
+<<<<<<< HEAD:agentverse/tasks/prisoner_dilema/config.yaml
+  env_type: prisoner_dilema
+  max_turns: 12
+=======
   env_type: prisoner_dilemma
   max_turns: 8
+>>>>>>> main:agentverse/tasks/prisoner_dilemma/config.yaml
   rule:
     order:
       type: prisoner
diff --git a/agentverse/tasks/prisoner_dilemma/output_parser.py b/agentverse/tasks/prisoner_dilemma/output_parser.py
index 05a41e0f8..6e2d86ceb 100644
--- a/agentverse/tasks/prisoner_dilemma/output_parser.py
+++ b/agentverse/tasks/prisoner_dilemma/output_parser.py
@@ -21,7 +21,7 @@ class PrisonerDilemmaParser(OutputParser):
     encounter_cur_round: bool = False
 
     def parse(
-        self, agent: "BaseAgent", environment: "BaseEnvironment", output: LLMResult
+        self, agent: BaseAgent, environment: BaseEnvironment, output: LLMResult
     ) -> Union[AgentAction, AgentFinish]:
         text = output.content
         cleaned_output = text.strip()
@@ -37,17 +37,7 @@ def parse(
         action_input = cleaned_output[1][len("Action Input:") :].strip()
 
         if action == "Speak":
-            # make sure the police count the round right
-            # if agent.name == "Police":
-            #     action_input = re.sub(r'Round (\d+)', f'Round {self.cur_round}', action_input)
-            #     self.cur_round += 1
-            #   if self.encounter_cur_round:
-            #       self.encounter_cur_round = False
-            #       self.cur_round += 1
-            #   else:
-            #       self.encounter_cur_round = True
-
-            # each time police speak is a new round
+            
             if agent.name == "Police":
                 if environment.cnt_turn == (environment.max_turns - 4):
                     action_input = (
diff --git a/agentverse/utils/prompts.py b/agentverse/utils/prompts.py
new file mode 100644
index 000000000..e9824ecbc
--- /dev/null
+++ b/agentverse/utils/prompts.py
@@ -0,0 +1,212 @@
+import json
+import os
+import logging
+
+
+base_prompt = {
+    "subject_parsing": """
+{sentence} The subject of the sentence above is "
+""",
+    "reaction_prompt": """Now you are act for as an agent named {name} in a virtual world. You might need to performing reaction to the observation. Your mission to take the agent as yourself and directly provide what the agent will do to the observations based on the following information:
+(1) The agent's description: {summary}
+(2) Current time is {time}
+(3) Your current status is {status}
+(4) Your memory is {context}
+
+Now the observation has two types, incomming observation is the ones that other does to you, you are more likely to react to them.  Background observation are the background, which does not need to be responded. For example, view an alarm clock does not imply turning it off. However, some background observation might trigger your attention, like an alarming clock or a firing book.
+
+So now:
+The incoming observation is {observation}
+The Some background observation is {background_observation}.
+
+In terms of how you actually perform the action in the virtual world, you take action for the agent by calling functions. Currently, there are the following functions that can be called.
+
+- act(description, target=None): do some action. `description` describes the action, set `description` to None for not act. `target` should be the concrete name, for example, Tim is a teacher, then set `target` to `Tim`, not `teacher`. 
+- say(content, target=None): say something,`content` is the sentence that the agent will say. **Do not say to yourself, neither to inanimate objects.**
+- move(description): move to somewhere. `description` describes the movement, set description to None for not move.
+- do_nothing(): Do nothing. There is nothing that you like to respond to, this will make you stick to your original status and plan.
+
+Some actions may not be needed in this situation. Call one function at a time, please give a thought before calling these actions, i.e., use the following format strictly:
+            
+Thought: None of the observation attract my attention, I need to:
+Action: do_nothing()
+Observation: [Observations omited]
+[or]
+Thought: due to observation `xxx`, I need to:
+Action: say("hello", target="Alice")
+Observation: [Observations omited]
+[or]
+Thought: due to observation `xxx`, I need to:
+Action: act(None)
+Observation: [Observations omited]
+[or]
+Thought: due to observation `xxx`, I need to:
+Action: move(None)
+Observation: [Observations omited]
+[or]
+Thought: I think I've finished my action as the agent. 
+Action: end()
+Observation:
+
+Now begin your actions as the agent. Remember only write one function call after `Action:` """,
+    "reaction_prompt_object": """Now you are act for as an object named {name} in a virtual world. You might need to performing reaction to the observation. Your mission to take the agent as yourself and directly provide what the agent will do to the observations based on the following information:
+(1) Current time is {time}
+(2) Your current status is {status}
+
+Now the observation has two types, incomming observation is the ones that other does to you, you are more likely to react to them.  Background observation are the background, which does not need to be responded. For example, view an alarm clock does not imply turning it off. However, some background observation might trigger your attention, like an alarming clock or a firing book.
+
+So now:
+The incoming observation is {observation}
+The Some background observation is {background_observation}.
+
+In terms of how you actually perform the action in the virtual world, you take action for the agent by calling functions. Currently, there are the following functions that can be called.
+
+- act(description, target=None): do some action. `description` describes the action, set `description` to None for not act. `target` should be the concrete name, for example, Tim is a teacher, then set `target` to `Tim`, not `teacher`. 
+- move(description): move to somewhere. `description` describes the movement, set description to None for not move.
+- do_nothing(): Do nothing. There is nothing that you like to respond to, this will make you stick to your original status and plan.
+
+Some actions may not be needed in this situation. Call one function at a time, please give a thought before calling these actions, i.e., use the following format strictly:
+            
+Thought: None of the observation attract my attention, I need to:
+Action: do_nothing()
+Observation: [Observations omited]
+[or]
+Thought: due to observation `xxx`, I need to:
+Action: act(None)
+Observation: [Observations omited]
+[or]
+Thought: due to observation `xxx`, I need to:
+Action: move(None)
+Observation: [Observations omited]
+[or]
+Thought: I think I've finished my action as the object. 
+Action: end()
+Observation:
+
+Now begin your actions as the agent. Remember only write one function call after `Action:` """,
+    "change_status": """Now you have act for as an agent named {name} in a virtual world. You have performed reaction to the observation for {name}. Currently you need to determine whether you need to change status. Here are some following information for:
+(1) The agent's description: {summary}
+(2) Current time is {time}
+(3) Your current status is {status}
+
+Your reaction to observation: {reaction}
+
+Directly tell me whether the status should be changed. Use the following function to change (or not change).
+
+- status_unchange()
+- change_status(new_status: str, duration: int) : new_status: A string describes the new_status. duration: the estimated duration of this status.
+
+Now give me the funcation call:
+""",
+    "broadcast_observations": """You are simulating an environment. When an action happens in your environment, you should paraphrase the action to (and only to) the potential receivers in your environment. Please judge whether you should broadcast the message when meets one of the following principles:
+1. The message is meaningful to the potential receiver. broadcast a `say` action to an object without life (like desk) is not meaningful, while broadcast a `push` action to the desk is meaningful.
+2. The message might be captured by the potential receiver because of physical distance althought the potential receiver is not the direct target. For example, A is saying some content to B, C is close to A and B, then C might also hear it. 
+3. The message is related to the potential receiver. For example, a `read book` action is not related to the bed in any way, so you shouldn't broadcast. 
+
+Also follow the following rules:
+1. Only broadcast to the listed potential receivers, do not imagine not existing ones. 
+
+You should broadcast using the following format (end with `Finish_Broadcast` ):
+Thought: I will look through the list and pick the ones that meets one of the following principles. I think ... are related, ... will get information, ... might capter.
+Broadcast:
+1. To A: some content
+2. To B: some content
+...
+N. To N: some content
+Finish_Broadcast
+
+Now, in your environment, there are the following potential receivers: {agents_and_objects}, please broadcast the following action: ```{name} -> {targets} : {content}``` to the potential receivers. )
+""",
+    "object_summary": """Give me rules and characteristics of a {name} \
+especially on what circumstances it can change or cannot change its status \
+and what kind of status changing can be done without human intervention. 
+The answer should be as concise and accurate as possible. 
+Output format:
+1. I grow very slowly.
+2. I cannot move
+3. I cannot shut down myself unless some one do so. 
+""",
+    "chunk_plan": """Now you are acting for as an agent named {name} in a virtual world. In order to make the agent's behavior consistent, you need to plan for it. Please write {name}'s coarse grained schedule to {time_granularity} \
+
+You generate plan by calling the `write_plan` function:
+- write_chunk_plan(start_time, plan_description)
+    Args: start_time : a time string of hours with similar format to 00:00. Use military time.
+          plan_description: a string that describe's the plan. 
+
+Now generate the plan one in a line, when you finish the plan, end with END.
+E.g., 
+write_chunk_plan("11:00", "wake up and complete the morning routine")
+write_chunk_plan("12:00", "go to Oak Hill College to take classes")
+write_chunk_plan("13:00", "participating algorithm competition in the lab room")
+END
+
+You can generate your plan based on the following information:
+(1) The agent's description: {summary}
+(2) Current time is {current_time}
+(3) Your current status is {status}
+Note that the first plan must be related to current status, if current status is not none.
+
+Now generate the plan during this coarse period, which the whole day plan is roughly: {whole_day_plan}
+
+Now begin:
+""",
+    "detailed_plan": """Now you are acting for as an agent named {name} in a virtual world. In order to make the agent's behavior consistent, you need to plan for it. Please write {name}'s schedule of finer-grained precise to {time_granularity}) \
+
+You generate plan by calling the `write_plan` function:
+- write_plan(start_time, end_time, plan_description)
+    Args: start_time : a time string with similar format to 00:00. Use military time.
+          end_time: a time string with similar format to 00:00. Use military time.
+          plan_description: a string that describe's the plan. 
+
+Now generate the plan one in a line, when you finish the plan, end with END.
+E.g., 
+write_plan("11:00", "12:15", "Wake up, take a shower and get ready for the day.")
+write_plan("12:15", "12:30", "Eat a healthy breakfast such as oatmeal, eggs, or yogurt.")
+write_plan("12:30", "12:45", "Take a short walk to the university campus.")
+END
+
+You can generate your plan based on the following information:
+(1) The agent's description: {summary}
+(2) Current time is {current_time}
+(3) Your current status is {status}
+Note that the first plan must be current status, if current status is not none.
+
+Now generate the plan during this coarse period, which the agent is roughly doing {hourplan}.
+
+Now begin:
+""",
+    "system_message_broadcast": """You are now simulating an environment, in which there are several agents and objects. Here is a comming message that comes from the system. Who or what should receive and execute this message? Please provide the executor of this command, and also paraphrase to the executor if necessary. Do not broadcast to agent or object that is not the target of this message.
+You should broadcast using function `send_system_message(id=id, message=message)`, write one call in a line. End with END.
+for example:
+send_system_message(id="o_001", "message": "turn off immediately")
+END
+
+Now: the agents and objects are {objectlist}. The system message is: {system_message}.  Begin to broadcast:
+""",
+    "movement_target": """You are now simulating an environment, an agent in you want to perform a movement. I will give you a list of 
+objects and agents that might be the target. Your job is to set the movement target for the agent by calling function:
+movement_target(id, name)
+
+Now here is the list and movment:
+List: {elems}
+Movement is : {target_description}
+Now call the function:
+""",
+}
+
+
+def load_prompt(file_dir, file_name="prompts.json", key=None):
+    prompt_path = os.path.join(file_dir, file_name)
+    if os.path.exists(prompt_path):
+        with open(os.path.join(file_dir, file_name), "r") as fin:
+            data = json.load(fin)
+            prompt = data.get(key, "")
+    else:
+        prompt = ""
+
+    if prompt == "":
+        prompt = base_prompt.get(key, "")
+
+    if prompt == "":
+        logging.warning(f"No prompt of {key} has been found")
+    return prompt
diff --git a/main.py b/main.py
index 6f245c249..cb7f948db 100644
--- a/main.py
+++ b/main.py
@@ -1,12 +1,17 @@
+import os
+
+
 from agentverse.agentverse import AgentVerse
 from argparse import ArgumentParser
 
 parser = ArgumentParser()
+
 #parser.add_argument("--task", type=str, default="nlp_classroom_3players")
-parser.add_argument("--task", type=str, default="prisoner_dilemma")
+parser.add_argument("--task", type=str, default="alice_home")
 # parser.add_argument("--task", type=str, default="sde_team")
 # parser.add_argument("--task", type=str, default="sde_team/sde_team_2players")
 
+
 args = parser.parse_args()
 agentverse = AgentVerse.from_task(args.task)
 agentverse.run()
diff --git a/main_demo.py b/main_demo.py
index 3ebdf6fe4..2947b86c3 100644
--- a/main_demo.py
+++ b/main_demo.py
@@ -1,3 +1,6 @@
+import os
+
+
 from agentverse.demo import UI
 from argparse import ArgumentParser
 
diff --git a/setup.py b/setup.py
new file mode 100644
index 000000000..f4e8f2128
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,41 @@
+import setuptools
+from setuptools.command.develop import develop
+import subprocess
+
+# with open("requirements.txt", "r") as f:
+#     requirements = f.read().splitlines()
+
+with open("README.md", "r", encoding='utf8') as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="agentverse",
+    version="0.1.3",
+    author="OpenBMB",
+    author_email="chenweize1998@gmail.com",
+    description="A versatile framework that streamlines the process of creating custom multi-agent environments for large language models (LLMs).",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/OpenBMB/AgentVerse",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        'License :: OSI Approved :: Apache Software License',
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.9",
+    install_requires=[
+        "PyYAML",
+        "fastapi",
+        "uvicorn",
+        "py3langid",
+        "iso-639",
+        "openai",
+        "opencv-python",
+        "gradio",
+        "httpx[socks]",
+        "astunparse",
+        "langchain",
+    ],
+    include_package_data = True,
+)