diff --git a/examples/build_customized_agent.py b/examples/build_customized_agent.py
index c7069b768..ed00e8320 100644
--- a/examples/build_customized_agent.py
+++ b/examples/build_customized_agent.py
@@ -19,15 +19,6 @@ class SimpleWriteCode(Action):
     PROMPT_TEMPLATE = """
     Write a python function that can {instruction} and provide two runnnable test cases.
     Return ```python your_code_here ``` with NO other texts,
-    example: 
-    ```python
-    # function
-    def add(a, b):
-        return a + b
-    # test cases
-    print(add(1, 2))
-    print(add(3, 4))
-    ```
     your code:
     """
 
@@ -73,12 +64,12 @@ class SimpleCoder(Role):
 
     async def _act(self) -> Message:
         logger.info(f"{self._setting}: ready to {self._rc.todo}")
-        todo = self._rc.todo
+        todo = self._rc.todo # todo will be SimpleWriteCode()
 
         msg = self.get_memories(k=1)[0] # find the most recent messages
 
-        code_text = await SimpleWriteCode().run(msg.content)
-        msg = Message(content=code_text, role=self.profile, cause_by=todo)
+        code_text = await todo.run(msg.content)
+        msg = Message(content=code_text, role=self.profile, cause_by=type(todo))
 
         return msg
 
@@ -95,6 +86,8 @@ class RunnableCoder(Role):
 
     async def _act(self) -> Message:
         logger.info(f"{self._setting}: ready to {self._rc.todo}")
+        # By choosing the Action by order under the hood
+        # todo will be first SimpleWriteCode() then SimpleRunCode()
         todo = self._rc.todo
 
         msg = self.get_memories(k=1)[0] # find the most k recent messages
diff --git a/examples/build_customized_multi_agents.py b/examples/build_customized_multi_agents.py
new file mode 100644
index 000000000..02221e8e9
--- /dev/null
+++ b/examples/build_customized_multi_agents.py
@@ -0,0 +1,150 @@
+'''
+Filename: MetaGPT/examples/build_customized_multi_agents.py
+Created Date: Wednesday, November 15th 2023, 7:12:39 pm
+Author: garylin2099
+'''
+import re
+import asyncio
+import fire
+from metagpt.actions import Action, BossRequirement
+from metagpt.roles import Role
+from metagpt.team import Team
+from metagpt.schema import Message
+from metagpt.logs import logger
+
+def parse_code(rsp):
+    pattern = r'```python(.*)```'
+    match = re.search(pattern, rsp, re.DOTALL)
+    code_text = match.group(1) if match else rsp
+    return code_text
+
+class SimpleWriteCode(Action):
+
+    PROMPT_TEMPLATE = """
+    Write a python function that can {instruction}.
+    Return ```python your_code_here ``` with NO other texts,
+    your code:
+    """
+
+    def __init__(self, name="SimpleWriteCode", context=None, llm=None):
+        super().__init__(name, context, llm)
+
+    async def run(self, instruction: str):
+
+        prompt = self.PROMPT_TEMPLATE.format(instruction=instruction)
+
+        rsp = await self._aask(prompt)
+
+        code_text = parse_code(rsp)
+
+        return code_text
+
+class SimpleCoder(Role):
+    def __init__(
+        self,
+        name: str = "Alice",
+        profile: str = "SimpleCoder",
+        **kwargs,
+    ):
+        super().__init__(name, profile, **kwargs)
+        self._watch([BossRequirement])
+        self._init_actions([SimpleWriteCode])
+
+class SimpleWriteTest(Action):
+
+    PROMPT_TEMPLATE = """
+    Context: {context}
+    Write {k} unit tests using pytest for the given function, assuming you have imported it.
+    Return ```python your_code_here ``` with NO other texts,
+    your code:
+    """
+
+    def __init__(self, name="SimpleWriteTest", context=None, llm=None):
+        super().__init__(name, context, llm)
+
+    async def run(self, context: str, k: int = 3):
+
+        prompt = self.PROMPT_TEMPLATE.format(context=context, k=k)
+
+        rsp = await self._aask(prompt)
+
+        code_text = parse_code(rsp)
+
+        return code_text
+
+class SimpleTester(Role):
+    def __init__(
+        self,
+        name: str = "Bob",
+        profile: str = "SimpleTester",
+        **kwargs,
+    ):
+        super().__init__(name, profile, **kwargs)
+        self._init_actions([SimpleWriteTest])
+        # self._watch([SimpleWriteCode])
+        self._watch([SimpleWriteCode, SimpleWriteReview]) # feel free to try this too
+
+    async def _act(self) -> Message:
+        logger.info(f"{self._setting}: ready to {self._rc.todo}")
+        todo = self._rc.todo
+
+        # context = self.get_memories(k=1)[0].content # use the most recent memory as context
+        context = self.get_memories() # use all memories as context
+
+        code_text = await todo.run(context, k=5) # specify arguments
+        msg = Message(content=code_text, role=self.profile, cause_by=type(todo))
+
+        return msg
+
+class SimpleWriteReview(Action):
+
+    PROMPT_TEMPLATE = """
+    Context: {context}
+    Review the test cases and provide one critical comments:
+    """
+
+    def __init__(self, name="SimpleWriteReview", context=None, llm=None):
+        super().__init__(name, context, llm)
+
+    async def run(self, context: str):
+
+        prompt = self.PROMPT_TEMPLATE.format(context=context)
+
+        rsp = await self._aask(prompt)
+
+        return rsp
+
+class SimpleReviewer(Role):
+    def __init__(
+        self,
+        name: str = "Charlie",
+        profile: str = "SimpleReviewer",
+        **kwargs,
+    ):
+        super().__init__(name, profile, **kwargs)
+        self._init_actions([SimpleWriteReview])
+        self._watch([SimpleWriteTest])
+
+async def main(
+    idea: str = "write a function that calculates the product of a list",
+    investment: float = 3.0,
+    n_round: int = 5,
+    add_human: bool = False,
+):
+    logger.info(idea)
+
+    team = Team()
+    team.hire(
+        [
+            SimpleCoder(),
+            SimpleTester(),
+            SimpleReviewer(is_human=add_human),
+        ]
+    )
+
+    team.invest(investment=investment)
+    team.start_project(idea)
+    await team.run(n_round=n_round)
+
+if __name__ == '__main__':
+    fire.Fire(main)
diff --git a/examples/debate.py b/examples/debate.py
index 4db7567f0..a37e60848 100644
--- a/examples/debate.py
+++ b/examples/debate.py
@@ -77,6 +77,8 @@ class Debator(Role):
             send_to=self.opponent_name,
         )
 
+        self._rc.memory.add(msg)
+
         return msg
 
 async def debate(idea: str, investment: float = 3.0, n_round: int = 5):
diff --git a/metagpt/llm.py b/metagpt/llm.py
index 8b4a13838..9324da126 100644
--- a/metagpt/llm.py
+++ b/metagpt/llm.py
@@ -8,7 +8,7 @@
 
 from metagpt.provider.anthropic_api import Claude2 as Claude
 from metagpt.provider.openai_api import OpenAIGPTAPI as LLM
-from metagpt.provider.human_gpt import HumanGPT
+from metagpt.provider.human_provider import HumanProvider
 
 DEFAULT_LLM = LLM()
 CLAUDE_LLM = Claude()
diff --git a/metagpt/provider/human_gpt.py b/metagpt/provider/human_provider.py
similarity index 85%
rename from metagpt/provider/human_gpt.py
rename to metagpt/provider/human_provider.py
index bc4d6dc6e..1d12f972f 100644
--- a/metagpt/provider/human_gpt.py
+++ b/metagpt/provider/human_provider.py
@@ -1,5 +1,5 @@
 '''
-Filename: MetaGPT/metagpt/provider/human_speaker.py
+Filename: MetaGPT/metagpt/provider/human_provider.py
 Created Date: Wednesday, November 8th 2023, 11:55:46 pm
 Author: garylin2099
 '''
@@ -7,8 +7,8 @@ from typing import Optional
 from metagpt.provider.base_gpt_api import BaseGPTAPI
 from metagpt.logs import logger
 
-class HumanGPT(BaseGPTAPI):
-    """A dummy GPT that actually takes in human input as its response.
+class HumanProvider(BaseGPTAPI):
+    """Humans provide themselves as a 'model', which actually takes in human input as its response.
     This enables replacing LLM anywhere in the framework with a human, thus introducing human interaction
     """
 
diff --git a/metagpt/roles/role.py b/metagpt/roles/role.py
index fecca0beb..b96c361c0 100644
--- a/metagpt/roles/role.py
+++ b/metagpt/roles/role.py
@@ -15,7 +15,7 @@ from pydantic import BaseModel, Field
 # from metagpt.environment import Environment
 from metagpt.config import CONFIG
 from metagpt.actions import Action, ActionOutput
-from metagpt.llm import LLM, HumanGPT
+from metagpt.llm import LLM, HumanProvider
 from metagpt.logs import logger
 from metagpt.memory import Memory, LongTermMemory
 from metagpt.schema import Message
@@ -108,7 +108,7 @@ class Role:
     """Role/Agent"""
 
     def __init__(self, name="", profile="", goal="", constraints="", desc="", is_human=False):
-        self._llm = LLM() if not is_human else HumanGPT()
+        self._llm = LLM() if not is_human else HumanProvider()
         self._setting = RoleSetting(name=name, profile=profile, goal=goal,
                                     constraints=constraints, desc=desc, is_human=is_human)
         self._states = []
@@ -126,7 +126,7 @@ class Role:
             if not isinstance(action, Action):
                 i = action("", llm=self._llm)
             else:
-                if self._setting.is_human and not isinstance(action.llm, HumanGPT):
+                if self._setting.is_human and not isinstance(action.llm, HumanProvider):
                     logger.warning(f"is_human attribute does not take effect,"
                         f"as Role's {str(action)} was initialized using LLM, try passing in Action classes instead of initialized instances")
                 i = action