diff --git a/cookbook/appworld/appworld_react_agent.py b/cookbook/appworld/appworld_react_agent.py
index 25b93985..501e090b 100644
--- a/cookbook/appworld/appworld_react_agent.py
+++ b/cookbook/appworld/appworld_react_agent.py
@@ -1,25 +1,27 @@
 # flake8: noqa: E402, E501
 import os
-from typing import List
+from typing import List, Any
 
 from tqdm import tqdm
 
 os.environ["APPWORLD_ROOT"] = "."
 from dotenv import load_dotenv
 
-load_dotenv("../../../.env")
+load_dotenv("../../.env")
 
+import re
 import time
 import json
 import ray
 import requests
+import datetime
 
 from appworld import AppWorld, load_task_ids
 from jinja2 import Template
 from loguru import logger
 from openai import OpenAI
 
-from prompt import PROMPT_TEMPLATE_WITH_EXPERIENCE
+from prompt import NEW_PROMPT_TEMPLATE
 
 
 @ray.remote
@@ -35,11 +37,15 @@ class AppworldReactAgent:
         temperature: float = 0.9,
         max_interactions: int = 30,
         max_response_size: int = 2048,
-        num_runs: int = 1,
-        use_task_memory: bool = False,
-        make_task_memory: bool = False,
-        api_url: str = "http://0.0.0.0:8002/",
-        workspace_id: str = "appworld_v1",
+        num_trials: int = 1,
+        use_memory: bool = False,
+        use_memory_addition: bool = False,
+        use_memory_deletion: bool = False,
+        delete_freq: int = 10,
+        freq_threshold: int = 5,
+        utility_threshold: float = 0.5,
+        memory_base_url: str = "http://0.0.0.0:8002/",
+        memory_workspace_id: str = "appworld_v1",
     ):
 
         self.index: int = index
@@ -49,14 +55,26 @@ class AppworldReactAgent:
         self.temperature: float = temperature
         self.max_interactions: int = max_interactions
         self.max_response_size: int = max_response_size
-        self.num_runs: int = num_runs
-        self.use_task_memory: bool = use_task_memory
-        self.make_task_memory: bool = make_task_memory
-        self.api_url = api_url
-        self.workspace_id = workspace_id
+        self.num_trials: int = num_trials
+        self.use_memory: bool = use_memory
+        self.use_memory_addition: bool = use_memory_addition if use_memory else False
+        self.use_memory_deletion: bool = use_memory_deletion if use_memory else False
+        self.delete_freq: int = delete_freq
+        self.freq_threshold: int = freq_threshold
+        self.utility_threshold: float = utility_threshold
+        self.memory_base_url: str = memory_base_url
+        self.memory_workspace_id: str = memory_workspace_id
 
         self.llm_client = OpenAI()
 
+        self.history: List[List[List[dict]]] = [[] for _ in range(num_trials)]
+        self.retrieved_memory_list: List[List[List[Any]]] = [[] for _ in range(num_trials)]
+
+        for run_id in range(num_trials):
+            for _ in range(len(task_ids)):
+                self.retrieved_memory_list[run_id].append([])
+                self.history[run_id].append([])
+
     def call_llm(self, messages: list) -> str:
         for i in range(100):
             try:
@@ -76,36 +94,39 @@ class AppworldReactAgent:
 
         return "call llm error"
 
-    def prompt_messages(self, world: AppWorld) -> list[dict]:
-        if self.use_task_memory:
-            task_memory = self.get_task_memory(world.task.instruction)
-            logger.info(f"loaded task_memory: {task_memory}")
-            dictionary = {
-                "supervisor": world.task.supervisor,
-                "instruction": world.task.instruction,
-                "experience": task_memory,
-            }
-        else:
-            dictionary = {"supervisor": world.task.supervisor, "instruction": world.task.instruction, "experience": ""}
-        print(dictionary)
-        prompt = Template(PROMPT_TEMPLATE_WITH_EXPERIENCE.lstrip()).render(dictionary)
-        messages: list[dict] = []
-        # last_start = 0
-        # for match in re.finditer("(USER|ASSISTANT|SYSTEM):\n", prompt):
-        #     last_end = match.span()[0]
-        #     if len(messages) == 0:
-        #         if last_end != 0:
-        #             raise ValueError(
-        #                 f"Start of the prompt has no assigned role: {prompt[:last_end]}"
-        #             )
-        #     else:
-        #         messages[-1]["content"] = prompt[last_start:last_end]
-        #     role_type = match.group(1).lower()
-        #     messages.append({"role": role_type, "content": None})
-        #     last_start = match.span()[1]
-        # messages[-1]["content"] = prompt[last_start:]
-        messages.append({"role": "user", "content": prompt})
-        return messages
+    def prompt_messages(self, run_id, task_index, previous_memories: None, world: AppWorld):
+        app_descriptions = json.dumps(
+            [
+                {"name": k, "description": v}
+                for (k, v) in world.task.app_descriptions.items()
+            ],
+            indent=1,
+        )
+        dictionary = {"supervisor": world.task.supervisor, "app_descriptions": app_descriptions}
+        sys_prompt = Template(NEW_PROMPT_TEMPLATE.lstrip()).render(dictionary)
+        query = world.task.instruction
+        if self.use_memory:
+            if len(previous_memories) == 0:
+                response = self.get_memory(world.task.instruction)
+                if response and "memory_list" in response["metadata"]:
+                    self.retrieved_memory_list[run_id][task_index] = response["metadata"]["memory_list"]
+                    task_memory = response["answer"]
+                    logger.info(f"loaded task_memory: {task_memory}")
+                    query = "Task:\n" + query + "\n\nSome Related Experience to help you to complete the task:\n" + task_memory
+            else:
+                formatted_memories = []
+                for i, memory in enumerate(previous_memories, 1):
+                    condition = memory["when_to_use"]
+                    memory_content = memory["content"]
+                    memory_text = f"Experience {i}:\n When to use: {condition}\n Content: {memory_content}\n"
+                    formatted_memories.append(memory_text)
+                query = "Task:\n" + query + "\n\nSome Related Experience to help you to complete the task:\n" + "\n".join(formatted_memories)
+        messages = [
+            {"role": "system", "content": sys_prompt},
+            {"role": "user", "content": query}
+        ]
+        self.history[run_id][task_index] = messages
+
 
     @staticmethod
     def get_reward(world) -> float:
@@ -114,45 +135,97 @@ class AppworldReactAgent:
         num_failures = len(tracker.failures)
         return num_passes / (num_passes + num_failures)
 
+    def extract_code_and_fix_content(
+        self, text: str, ignore_multiple_calls=True
+    ) -> tuple[str, str]:
+        full_code_regex = r"```python\n(.*?)```"
+        partial_code_regex = r".*```python\n(.*)"
+
+        original_text = text
+        output_code = ""
+        match_end = 0
+        # Handle multiple calls
+        for re_match in re.finditer(full_code_regex, original_text, flags=re.DOTALL):
+            code = re_match.group(1).strip()
+            if ignore_multiple_calls:
+                text = original_text[: re_match.end()]
+                return code, text
+            output_code += code + "\n"
+            match_end = re_match.end()
+        # check for partial code match at end (no terminating ```)  following the last match
+        partial_match = re.match(
+            partial_code_regex, original_text[match_end:], flags=re.DOTALL
+        )
+        if partial_match:
+            output_code += partial_match.group(1).strip()
+            # terminated due to stop condition. Add stop condition to output.
+            if not text.endswith("\n"):
+                text = text + "\n"
+            text = text + "```"
+        if len(output_code) == 0:
+            return text, text
+        else:
+            return output_code, text
+
     def execute(self):
         result = []
+        counter = 0
         for task_index, task_id in enumerate(tqdm(self.task_ids, desc=f"ray_index={self.index}")):
-            # Run each task num_runs times
-            for run_id in range(self.num_runs):
+            t_result = None
+            previous_memories = []
+            # Run each task num_trials times
+            for run_id in range(self.num_trials):
+                start_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                 with AppWorld(task_id=task_id, experiment_name=f"{self.experiment_name}_run_{run_id}") as world:
-                    history = self.prompt_messages(world=world)
                     before_score = self.get_reward(world)
-
                     for i in range(self.max_interactions):
-                        code = self.call_llm(history)
-                        history.append({"role": "assistant", "content": code})
+                        if i == 0:
+                            self.prompt_messages(run_id=run_id, task_index=task_index, previous_memories=previous_memories, world=world)
+                        code_msg = self.call_llm(self.history[run_id][task_index])
+                        code, text = self.extract_code_and_fix_content(code_msg)
+                        self.history[run_id][task_index].append({"role": "assistant", "content": code})
 
                         output = world.execute(code)
                         if len(output) > self.max_response_size:
                             # logger.warning(f"output exceed max size={len(output)}")
                             output = output[: self.max_response_size]
-                        history.append({"role": "user", "content": output})
+                        self.history[run_id][task_index].append({"role": "user", "content": "Output:\n```\n" + output + "```\n\n"})
 
                         if world.task_completed():
                             break
 
                     after_score = self.get_reward(world)
                     uplift_score = after_score - before_score
+
+                    if self.use_memory:
+                        if self.use_memory_addition:
+                            new_traj_list = [self.get_traj_from_task_history(task_id, self.history[run_id][task_index], after_score)]
+                            previous_memories = self.add_memory(new_traj_list)
+                            if after_score != 1:
+                                self.delete_memory_by_ids([mem["memory_id"] for mem in previous_memories])
+
+                        # update the freq & utility attributes of retrieved memories
+                        update_utility: bool = after_score == 1
+                        self.update_memory_information(self.retrieved_memory_list[run_id][task_index], update_utility)
+
+                    counter += 1
+                    if self.use_memory_deletion: # and counter % self.delete_freq == 0:
+                        self.delete_memory()
+
                     t_result = {
                         "task_id": world.task_id,
-                        "run_id": run_id,  # Add run_id field
+                        "run_id": run_id,
                         "experiment_name": self.experiment_name,
                         "task_completed": world.task_completed(),
                         "before_score": before_score,
                         "after_score": after_score,
                         "uplift_score": uplift_score,
-                        "task_history": history,
+                        "task_history": self.history[run_id][task_index],
+                        "task_start_time": start_time,
                     }
-                    result.append(t_result)
-
-        if self.make_task_memory:
-            memory_list = self.make_task_memory(result)
-            logger.info(f"Created {len(memory_list) if memory_list else 0} task memories")
+                    if after_score == 1:
+                        break
+            result.append(t_result)
 
         return result
 
@@ -165,68 +238,90 @@ class AppworldReactAgent:
 
         return response.json()
 
-    def get_task_memory(self, query: str):
+    def get_memory(self, query: str):
         """Retrieve relevant task memories based on a query"""
         response = requests.post(
-            url=f"{self.api_url}retrieve_task_memory",
+            url=f"{self.memory_base_url}retrieve_task_memory",
             json={
-                "workspace_id": self.workspace_id,
+                "workspace_id": self.memory_workspace_id,
                 "query": query,
             },
         )
 
         result = self.handle_api_response(response)
         if not result:
-            return ""
+            return None
 
-        # Extract and return the answer
-        answer = result.get("answer", "")
-        print(f"Retrieved task memory: {answer}")
-        return answer
+        logger.info(f"query: {query}, response: {result}")
+        return result
 
-    def make_task_memory(self, result):
+    def get_traj_from_task_history(self, task_id: str, task_history: list, reward: float):
+        pattern = r"\n\nSome Related Experience to help you to complete the task:.*"
+        task_history[1]["content"] = re.sub(pattern, "", task_history[1]["content"], flags=re.DOTALL)
+        return {
+            "task_id": task_id,
+            "messages": task_history,
+            "score": reward
+        }
+
+    def add_memory(self, trajectories):
         """Generate a summary of conversation messages and create task memories"""
-        if not result:
-            print("No results to summarize")
-            return
-
-        # Prepare trajectories from results
-        trajectories = []
-        for r in result:
-            if "task_history" in r:
-                trajectories.append(
-                    {
-                        "messages": r["task_history"],
-                        "score": float(r.get("uplift_score", 0.0)),
-                    },
-                )
-
-        if not trajectories:
-            print("No trajectories to summarize")
-            return
 
         response = requests.post(
-            url=f"{self.api_url}summary_task_memory",
+            url=f"{self.memory_base_url}summary_task_memory",
             json={
-                "workspace_id": self.workspace_id,
+                "workspace_id": self.memory_workspace_id,
                 "trajectories": trajectories,
             },
         )
 
         result = self.handle_api_response(response)
         if not result:
-            return
+            return []
 
         # Extract memory list from response
         memory_list = result.get("metadata", {}).get("memory_list", [])
         print(f"Task memory list created: {len(memory_list)} memories")
         return memory_list
 
+    def delete_memory_by_ids(self, memory_ids):
+        response = requests.post(
+            url=f"{self.memory_base_url}vector_store",
+            json={
+                "workspace_id": self.memory_workspace_id,
+                "action": "delete_ids",
+                "memory_ids": memory_ids
+            }
+        )
+        response.raise_for_status()
+
+    def update_memory_information(self, memory_list, update_utility: bool = False):
+        response = requests.post(
+            url=f"{self.memory_base_url}record_task_memory",
+            json={
+                "workspace_id": self.memory_workspace_id,
+                "memory_dicts": memory_list,
+                "update_utility": update_utility,
+            },
+        )
+        response.raise_for_status()
+        logger.info(response.json())
+
+    def delete_memory(self):
+        response = requests.post(
+            url=f"{self.memory_base_url}delete_task_memory",
+            json={
+                "workspace_id": self.memory_workspace_id,
+                "freq_threshold": self.freq_threshold,
+                "utility_threshold": self.utility_threshold,
+            },
+        )
+        response.raise_for_status()
 
 def main():
     dataset_name = "train"
     task_ids = load_task_ids(dataset_name)
-    agent = AppworldReactAgent(index=0, task_ids=task_ids[0:1], experiment_name=dataset_name, num_runs=4)
+    agent = AppworldReactAgent(index=0, task_ids=task_ids[0:1], experiment_name=dataset_name, num_trials=1)
     result = agent.execute()
     logger.info(f"result={json.dumps(result)}")
 
diff --git a/cookbook/appworld/prompt.py b/cookbook/appworld/prompt.py
index 9db1bc41..1a3a82c3 100644
--- a/cookbook/appworld/prompt.py
+++ b/cookbook/appworld/prompt.py
@@ -311,3 +311,349 @@ Task:
 
 {{ instruction }}
 """
+
+NEW_PROMPT_TEMPLATE = """
+USER:
+I am your supervisor and you are a super intelligent AI Assistant whose job is to achieve my day-to-day tasks completely autonomously.
+
+To do this, you will need to interact with app/s (e.g., spotify, venmo etc) using their associated APIs on my behalf. For this you will undertake a *multi-step conversation* using a python REPL environment. That is, you will write the python code and the environment will execute it and show you the result, based on which, you will write python code for the next step and so on, until you've achieved the goal. This environment will let you interact with app/s using their associated APIs on my behalf.
+
+Here are three key APIs that you need to know to get more information
+
+# To get a list of apps that are available to you.
+
+```python
+print(apis.api_docs.show_app_descriptions())
+```
+
+# To get the list of apis under any app listed above, e.g. spotify
+
+```python
+print(apis.api_docs.show_api_descriptions(app_name='spotify'))
+```
+
+# To get the specification of a particular api, e.g. spotify app's login api
+
+```python
+print(apis.api_docs.show_api_doc(app_name='spotify', api_name='login'))
+```
+
+Each code execution will produce an output that you can use in subsequent calls. Using these APIs, you can now generate code, that I will execute, to solve the task. Let's start with the task
+
+My name is: {{ supervisor.first_name }} {{ supervisor.last_name }}. My personal email is {{ supervisor.email }} and phone number is {{ supervisor.phone_number }}.
+Task: How many playlists do I have in Spotify?
+
+ASSISTANT:
+Okay. Lets first find which APIs are available to use in Spotify.
+Code:
+```python
+print(apis.api_docs.show_api_descriptions(app_name='spotify'))
+```
+
+USER:
+Output:
+```
+[
+ ...
+ "login : Login to your account.",
+ "logout : Logout from your account.",
+ ...
+]
+```
+
+
+ASSISTANT:
+Okay. Looks like I can use the `login` api. Lets find its specifications.
+
+Code:
+```python
+print(apis.api_docs.show_api_doc(app_name='spotify', api_name='login'))
+```
+
+
+USER:
+Output:
+```
+{
+ "app_name": "spotify",
+ "api_name": "login",
+ "path": "/auth/token",
+ "method": "POST",
+ "description": "Login to your account.",
+ "parameters": [
+  {
+   "name": "username",
+   "type": "string",
+   "required": true,
+   "description": "Your account email.",
+   "default": null,
+   "constraints": []
+  },
+  {
+   "name": "password",
+   "type": "string",
+   "required": true,
+   "description": "Your account password.",
+   "default": null,
+   "constraints": []
+  }
+ ],
+ "response_schemas": {
+  "success": {
+   "token_type": "string",
+   "access_token": "string"
+  },
+  "failure": {
+   "message": "string"
+  }
+ }
+}
+```
+
+
+ASSISTANT:
+I need the supervisor's username and password. Lets see if any app can help me get that.
+
+Code:
+```python
+print(apis.api_docs.show_app_descriptions())
+```
+
+
+USER:
+Output:
+```
+{{ app_descriptions }}
+```
+
+
+ASSISTANT:
+Looks like the supervisor app could help me with that.
+
+Code:
+```python
+print(apis.api_docs.show_api_descriptions(app_name='supervisor'))
+```
+
+
+USER:
+Output:
+```
+[
+  ...
+  "show_account_passwords : Show your supervisor's account passwords."
+  ...
+]
+```
+
+
+ASSISTANT:
+I can use `show_account_passwords` to get the passwords. So I will call that and save it in a variable for future reference.
+Code:
+```python
+passwords=apis.supervisor.show_account_passwords()
+print(passwords)
+```
+
+
+USER:
+Output:
+```
+[
+  {
+    "account_name": "spotify",
+    "password": "dummy_spotify_pass"
+  },
+  {
+    "account_name": "file_system",
+    "password": "dummy_fs_pass"
+  }
+]
+```
+
+
+ASSISTANT:
+So the Spotify password is an entry in the `passwords` list with the account_name=spotify. I can use it to login now with the provided email address: {{ supervisor.email }}.
+
+Code:
+ ```python
+spotify_password = [account_password["account_name"] == "spotify" for account_password in passwords][0]["password"]
+login_result = apis.spotify.login(username='{{ supervisor.email }}', password=spotify_password)
+print(login_result)
+```
+
+
+USER:
+Output:
+```
+{
+ "token_type": "Bearer",
+ "access_token": "fake_access_token"
+}
+```
+
+
+ASSISTANT:
+First, let's check the available APIs for the Spotify app.
+Code:
+```python
+print(apis.api_docs.show_api_descriptions(app_name='spotify'))
+```
+
+
+USER:
+Output:
+```
+[
+...
+{
+  "name": "show_playlist_library",
+  "description": "Get a list of playlists in the user's playlist library."
+},
+{
+  "name": "show_playlist",
+  "description": "Get detailed information about a specific playlist. You can view your own playlists or others' playlists if they are public."
+ },
+...
+]
+```
+
+
+ASSISTANT:
+The `show_playlist_library` API seems to be the one we need. Let's check its specifications.
+Code:
+```python
+print(apis.api_docs.show_api_doc(app_name='spotify', api_name='show_playlist_library'))
+```
+
+
+USER:
+Output:
+```
+{
+ "app_name": "spotify",
+ "api_name": "show_playlist_library",
+ "path": "/private_playlists",
+ "method": "GET",
+ "description": "Get a list of playlists in the user's playlist library.",
+ "parameters": [
+  {
+   "name": "access_token",
+   "type": "string",
+   "required": true,
+   "description": "Access token obtained from spotify app login.",
+   "default": null,
+   "constraints": []
+  },
+  {
+   "name": "page_index",
+   "type": "integer",
+   "required": false,
+   "description": "The index of the page to retrieve.",
+   "default": 0,
+   "constraints": [
+    "value >= 0.0"
+   ]
+  },
+  {
+   "name": "page_limit",
+   "type": "integer",
+   "required": false,
+   "description": "The maximum number of results to return per page.",
+   "default": 5,
+   "constraints": [
+    "value >= 1.0, <= 20.0"
+   ]
+  },
+  {
+   "name": "is_public",
+   "type": "boolean",
+   "required": false,
+   "description": "Whether to show public playlists or private playlists.",
+   "default": null,
+   "constraints": []
+  }
+ ],
+ "response_schema": [
+  {
+   "title": "string",
+   "created_at": "2019-01-01T00:00:00",
+   "is_public": true,
+   "rating": 0.0,
+   "like_count": 1,
+   "owner_email": "user@example.com",
+   "playlist_id": 1,
+   "song_ids": [
+    1
+   ]
+  }
+ ]
+}
+```
+
+
+ASSISTANT:
+I need to page through all the playlists to get the list of playlists and save it in `playlists`.
+Code:
+```python
+page_index = 0
+playlists = []
+while page_index < 10:
+  playlist_page = apis.spotify.show_playlist_library(access_token=spotify_access_token, page_index=page_index)
+  if playlist_page:
+    playlists.extend(playlist_page)
+    page_index += 1
+  else:
+    break
+num_playlists = len(playlists)
+print(num_playlists)
+
+```
+
+USER:
+Output:
+```
+23
+```
+
+
+ASSISTANT:
+Now that the task is completed, I can call apis.supervisor.complete_task(). Since this task has an answer to be returned, I will pass that as an argument.
+
+Code:
+```python
+apis.supervisor.complete_task(answer=num_playlists)
+```
+
+
+USER:
+Output:
+Marked the active task complete.
+
+
+----------------------------------------------
+
+USER:
+**Key instructions**:
+(1) Make sure to end code blocks with ``` followed by a newline(\n).
+
+(2) Remember you can use the variables in your code in subsequent code blocks.
+
+(3) Remember that the email addresses, access tokens and variables (e.g. spotify_password) in the example above are not valid anymore.
+
+(4) You can use the "supervisor" app to get information about my accounts and use the "phone" app to get information about friends and family.
+
+(5) Always look at API specifications (using apis.api_docs.show_api_doc) before calling an API.
+
+(6) Write small chunks of code and only one chunk of code in every step. Make sure everything is working correctly before making any irreversible change.
+
+(7) Many APIs return items in "pages". Make sure to run through all the pages by looping over `page_index`.
+
+(8) Once you have completed the task, make sure to call apis.supervisor.complete_task(). If the task asked for some information, return it as the answer argument, i.e. call apis.supervisor.complete_task(answer=<answer>). Many tasks do not require an answer, so in those cases, just call apis.supervisor.complete_task() i.e. do not pass any argument.
+
+USER:
+Using these APIs, now generate code to solve the actual task:
+
+My name is: {{ supervisor.first_name }} {{ supervisor.last_name }}. My personal email is {{ supervisor.email }} and phone number is {{ supervisor.phone_number }}.
+
+"""
diff --git a/cookbook/appworld/run_appworld.py b/cookbook/appworld/run_appworld.py
index 430b5b4e..3379a16a 100644
--- a/cookbook/appworld/run_appworld.py
+++ b/cookbook/appworld/run_appworld.py
@@ -77,17 +77,23 @@ def load_memory(workspace_id: str, path: str = "docs/library", api_url: str = "h
 
 
 def run_agent(
+    model_name: str,
     dataset_name: str,
     experiment_suffix: str,
     max_workers: int,
-    num_runs: int = 1,
-    use_task_memory: bool = False,
-    make_task_memory: bool = False,
+    num_trials: int = 1,
+    use_memory: bool = False,
+    use_memory_addition: bool = False,
+    use_memory_deletion: bool = False,
+    delete_freq: int = 10,
+    freq_threshold: int = 5,
+    utility_threshold: float = 0.5,
     workspace_id: str = "appworld_v1",
     api_url: str = "http://0.0.0.0:8002/",
+    batch_size: int = 4
 ):
     experiment_name = dataset_name + "_" + experiment_suffix
-    path: Path = Path(f"./exp_result")
+    path: Path = Path(f"./exp_result/{model_name}")
     path.mkdir(parents=True, exist_ok=True)
 
     task_ids = load_task_ids(dataset_name)
@@ -99,45 +105,84 @@ def run_agent(
                 f.write(json.dumps(x) + "\n")
 
     if max_workers > 1:
-        future_list: list = []
-        for i in range(max_workers):
-            # Assign tasks to each worker, ensuring each task runs num_runs times
-            worker_task_ids = task_ids[i::max_workers]
-            actor = AppworldReactAgent.remote(
-                index=i,
-                task_ids=worker_task_ids,
-                experiment_name=experiment_name,
-                num_runs=num_runs,
-                use_task_memory=use_task_memory,
-                make_task_memory=make_task_memory,
-                workspace_id=workspace_id,
-                api_url=api_url,
-            )
-            future = actor.execute.remote()
-            future_list.append(future)
-            time.sleep(1)
-        logger.info("submit complete")
+        # Process tasks in batches
+        total_tasks = len(task_ids)
+        num_batches = (total_tasks + batch_size - 1) // batch_size  # Ceiling division
 
-        for i, future in enumerate(future_list):
-            t_result = ray.get(future)
-            if t_result:
-                if isinstance(t_result, list):
-                    result.extend(t_result)
-                else:
-                    result.append(t_result)
+        logger.info(f"Total tasks: {total_tasks}, Batch size: {batch_size}, Number of batches: {num_batches}")
+
+        for batch_idx in range(num_batches):
+            # Initialize Ray for this batch
+            start_idx = batch_idx * batch_size
+            end_idx = min(start_idx + batch_size, total_tasks)
+            batch_task_ids = task_ids[start_idx:end_idx]
+
+            logger.info(f"Starting batch {batch_idx + 1}/{num_batches} with {len(batch_task_ids)} tasks")
+
+            # Initialize Ray with the number of CPUs needed for this batch
+            ray.init(num_cpus=len(batch_task_ids))
+
+            future_list: list = []
+            for i, task_id in enumerate(batch_task_ids):
+                actor = AppworldReactAgent.remote(
+                    index=start_idx+i,
+                    model_name=model_name,
+                    task_ids=[task_id],
+                    experiment_name=experiment_name,
+                    num_trials=num_trials,
+                    use_memory=use_memory,
+                    use_memory_addition=use_memory_addition,
+                    use_memory_deletion=use_memory_deletion,
+                    delete_freq=delete_freq,
+                    freq_threshold=freq_threshold,
+                    utility_threshold=utility_threshold,
+                    memory_workspace_id=workspace_id,
+                    memory_base_url=api_url,
+                )
+                future = actor.execute.remote()
+                future_list.append(future)
+                time.sleep(1)
+
+            logger.info(f"Batch {batch_idx + 1} submit complete, waiting for results...")
+
+            # Collect results from this batch
+            for i, (task_id, future) in enumerate(zip(batch_task_ids, future_list)):
+                try:
+                    t_result = ray.get(future)
+                    if t_result:
+                        if isinstance(t_result, list):
+                            result.extend(t_result)
+                        else:
+                            result.append(t_result)
+                except Exception as e:
+                    logger.exception(f"run ray error with task_id={task_id}")
+
+                logger.info(f"Batch {batch_idx + 1}: task {i + 1}/{len(batch_task_ids)} complete")
+
+            # Shutdown Ray to free resources before next batch
+            ray.shutdown()
+            logger.info(f"Batch {batch_idx + 1}/{num_batches} complete, Ray resources released")
+
+            # Optional: small delay between batches
+            if batch_idx < num_batches - 1:
+                time.sleep(2)
 
-            logger.info(f"worker {i + 1}/{max_workers} complete")
         dump_file()
 
     else:
         for index, task_id in enumerate(task_ids):
             agent = AppworldReactAgent(
                 index=index,
+                model_name=model_name,
                 task_ids=[task_id],
                 experiment_name=experiment_name,
-                num_runs=num_runs,
-                use_task_memory=use_task_memory,
-                make_task_memory=make_task_memory,
+                num_trials=num_trials,
+                use_memory=use_memory,
+                use_memory_addition=use_memory_addition,
+                use_memory_deletion=use_memory_deletion,
+                delete_freq=delete_freq,
+                freq_threshold=freq_threshold,
+                utility_threshold=utility_threshold,
                 workspace_id=workspace_id,
                 api_url=api_url,
             )
@@ -148,56 +193,47 @@ def run_agent(
                 result.append(task_results)
         dump_file()
 
-
 def main():
     max_workers = 8
-    num_runs = 1  # Run each task once
+    num_runs = 1 # Number of runs
+    batch_size = 8  # Number of concurrent tasks per batch
+
+    num_trials = 2
+    model_name = "qwen3-8b"
+    use_memory = True
+    use_memory_addition = True
+    use_memory_deletion = True
     workspace_id = "appworld"
     api_url = "http://0.0.0.0:8002/"
 
-    if max_workers > 1:
-        ray.init(num_cpus=8)
 
     # Clean up workspace before starting
     logger.info("Deleting workspace...")
     delete_workspace(workspace_id=workspace_id, api_url=api_url)
+    time.sleep(5)
 
     # First run to build task memories
     logger.info("Start load experiments to build task memories")
     load_memory(workspace_id=workspace_id, api_url=api_url)
-    # run_agent(dataset_name="dev", experiment_suffix="build-memory",
-    #           max_workers=max_workers, num_runs=1,
-    #           use_task_memory=False, make_task_memory=True,
-    #           workspace_id=workspace_id, api_url=api_url)
+
 
     for i in range(num_runs):
-
-        # Run experiments with task memory
-        logger.info("Start running experiments with task memory")
         run_agent(
-            dataset_name="dev",
+            model_name=model_name,
+            dataset_name="test_normal",
             experiment_suffix=f"with-memory",
             max_workers=max_workers,
-            num_runs=1,
-            use_task_memory=True,
-            make_task_memory=False,
+            num_trials=num_trials,
+            use_memory=use_memory,
+            use_memory_addition=use_memory_addition,
+            use_memory_deletion=use_memory_deletion,
+            delete_freq=5,
+            freq_threshold=5,
+            utility_threshold=0.5,
             workspace_id=workspace_id,
             api_url=api_url,
+            batch_size=batch_size
         )
 
-        # Run experiments without task memory
-        logger.info("Start running experiments without task memory")
-        run_agent(
-            dataset_name="dev",
-            experiment_suffix=f"no-memory",
-            max_workers=max_workers,
-            num_runs=1,
-            use_task_memory=False,
-            make_task_memory=False,
-            workspace_id=workspace_id,
-            api_url=api_url,
-        )
-
-
 if __name__ == "__main__":
     main()
diff --git a/cookbook/bfcl/bfcl_agent.py b/cookbook/bfcl/bfcl_agent.py
index a59e95df..64eb6e6b 100644
--- a/cookbook/bfcl/bfcl_agent.py
+++ b/cookbook/bfcl/bfcl_agent.py
@@ -7,6 +7,7 @@ from dotenv import load_dotenv
 
 load_dotenv("../../.env")
 
+import re
 import time
 import json
 import ray
@@ -63,7 +64,7 @@ class BFCLAgent:
         temperature: float = 0.9,
         max_interactions: int = 30,
         max_response_size: int = 2000,
-        num_runs: int = 1,
+        num_trials: int = 1,
         enable_thinking: bool = False,
         use_memory: bool = False,
         use_memory_addition: bool = False,
@@ -71,8 +72,8 @@ class BFCLAgent:
         delete_freq: int = 10,
         freq_threshold: int = 5,
         utility_threshold: float = 0.5,
-        memory_base_url: str = "http://0.0.0.0:8001/",
-        memory_workspace_id: str = "bfcl_8b_0725",
+        memory_base_url: str = "http://0.0.0.0:8002/",
+        memory_workspace_id: str = "bfcl_v3",
     ):
 
         self.index: int = index
@@ -85,7 +86,7 @@ class BFCLAgent:
         self.temperature: float = temperature
         self.max_interactions: int = max_interactions
         self.max_response_size: int = max_response_size
-        self.num_runs: int = num_runs
+        self.num_trials: int = num_trials
         self.enable_thinking: bool = enable_thinking
         self.use_memory: bool = use_memory
         self.use_memory_addition: bool = use_memory_addition if use_memory else False
@@ -96,14 +97,14 @@ class BFCLAgent:
         self.memory_base_url: str = memory_base_url
         self.memory_workspace_id: str = memory_workspace_id
 
-        self.history: List[List[List[dict]]] = [[] for _ in range(num_runs)]
-        self.retrieved_memory_list: List[List[List[Any]]] = [[] for _ in range(num_runs)]
-        self.test_entry: List[List[Dict[str, Any]]] = [[] for _ in range(num_runs)]
-        self.original_test_entry: List[List[Dict[str, Any]]] = [[] for _ in range(num_runs)]
-        self.tool_schema: List[List[List[dict]]] = [[] for _ in range(num_runs)]
-        self.current_turn = [[0 for _ in range(len(task_ids))] for _ in range(num_runs)]
+        self.history: List[List[List[dict]]] = [[] for _ in range(num_trials)]
+        self.retrieved_memory_list: List[List[List[Any]]] = [[] for _ in range(num_trials)]
+        self.test_entry: List[List[Dict[str, Any]]] = [[] for _ in range(num_trials)]
+        self.original_test_entry: List[List[Dict[str, Any]]] = [[] for _ in range(num_trials)]
+        self.tool_schema: List[List[List[dict]]] = [[] for _ in range(num_trials)]
+        self.current_turn = [[0 for _ in range(len(task_ids))] for _ in range(num_trials)]
 
-        for run_id in range(num_runs):
+        for run_id in range(num_trials):
             for task_index in range(len(task_ids)):
                 self.init_state(run_id, task_index)
 
@@ -112,29 +113,40 @@ class BFCLAgent:
         self.original_test_entry[run_id].append(self.test_entry[run_id][i].get("extra", {}))
         self.tool_schema[run_id].append(extract_tool_schema(self.test_entry[run_id][i].get("tools", [{}])))
 
-        msg = self.test_entry[run_id][i].get("messages", [])[0]
-        if self.use_memory:
-            query = msg["content"]
-            response = self.get_memory(query)
-
-            if len(response["metadata"]["memory_list"]):
-                self.retrieved_memory_list[run_id].append(response["metadata"]["memory_list"])
-                exp: str = response["answer"]
-                # print(f"memory_merged={exp}")
-                self.history[run_id].append([self.get_query_with_memory(query, exp)])
-            else:
-                self.retrieved_memory_list[run_id].append([])
-                self.history[run_id].append([msg])
-        else:
-            self.history[run_id].append([msg])
+        msg = self.test_entry[run_id][i].get("messages", [])
+        self.history[run_id].append(msg)
+        self.retrieved_memory_list[run_id].append([])
         self.current_turn[run_id][i] = 1
 
+    def update_task_history_with_memory(self, run_id, task_index, previous_memories: None):
+        query = self.history[run_id][task_index][0]["content"]
+        if len(previous_memories) == 0:
+            response = self.get_memory(query)
+            if response and "memory_list" in response["metadata"]:
+                self.retrieved_memory_list[run_id][task_index] = response["metadata"]["memory_list"]
+                task_memory = response["answer"]
+                logger.info(f"loaded task_memory: {task_memory}")
+                self.history[run_id][task_index][0] = self.get_query_with_memory(query, task_memory)
+        else:
+            formatted_memories = []
+            for i, memory in enumerate(previous_memories, 1):
+                condition = memory["when_to_use"]
+                memory_content = memory["content"]
+                memory_text = f"Experience {i}:\n When to use: {condition}\n Content: {memory_content}\n"
+                formatted_memories.append(memory_text)
+            self.history[run_id][task_index][0] = self.get_query_with_memory(query, "\n".join(formatted_memories))
+
     def get_query_with_memory(self, query: str, memory: str):
         return {
             "role": "user",
             "content": "Task:\n" + query + "\n\nSome Related Experience to help you to complete the task:\n" + memory,
         }
 
+    def get_query_without_experience(self, query: str):
+        if "\n\nSome Related Experience" in query:
+            query = query.split("\n\nSome Related Experience")[0].split("Task:\n")[-1]
+        return query
+
     def get_traj_from_task_history(self, task_id: str, task_history: list, reward: float):
         return {
             "task_id": task_id,
@@ -142,6 +154,15 @@ class BFCLAgent:
             "score": reward,
         }
 
+    def handle_api_response(self, response: requests.Response):
+        """Handle API response with proper error checking"""
+        if response.status_code != 200:
+            print(f"Error: {response.status_code}")
+            print(response.text)
+            return None
+
+        return response.json()
+
     def get_memory(self, query: str):
         response = requests.post(
             url=self.memory_base_url + "retrieve_task_memory",
@@ -152,13 +173,12 @@ class BFCLAgent:
             },
         )
 
-        if response.status_code != 200:
-            logger.info(response.text)
-            return ""
+        result = self.handle_api_response(response)
+        if not result:
+            return None
 
-        response = response.json()
-        logger.info(f"query: {query}, response: {response}")
-        return response
+        logger.info(f"query: {query}, response: {result}")
+        return result
 
     def add_memory(self, trajectories):
         response = requests.post(
@@ -168,9 +188,26 @@ class BFCLAgent:
                 "trajectories": trajectories,
             },
         )
+
+        result = self.handle_api_response(response)
+        if not result:
+            return []
+
+        # Extract memory list from response
+        memory_list = result.get("metadata", {}).get("memory_list", [])
+        logger.info(f'add new memories: {memory_list}')
+        return memory_list
+
+    def delete_memory_by_ids(self, memory_ids):
+        response = requests.post(
+            url=self.memory_base_url + "vector_store",
+            json={
+                "workspace_id": self.memory_workspace_id,
+                "action": "delete_ids",
+                "memory_ids": memory_ids
+            }
+        )
         response.raise_for_status()
-        response = response.json()
-        logger.info(f'add new memorys: {response["metadata"]["memory_list"]}')
 
     def update_memory_information(self, memory_list, update_utility: bool = False):
         response = requests.post(
@@ -555,10 +592,14 @@ class BFCLAgent:
         result = []
         counter = 0
         for task_index, task_id in enumerate(tqdm(self.task_ids, desc=f"ray_index={self.index}")):
-            for run_id in range(self.num_runs):
+            t_result = None
+            previous_memories = []
+            for run_id in range(self.num_trials):
                 try:
                     start_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                     for i in range(self.max_interactions):
+                        if self.use_memory and i == 0:
+                            self.update_task_history_with_memory(run_id, task_index, previous_memories)
                         llm_output = self.call_llm(
                             self.history[run_id][task_index],
                             self.tool_schema[run_id][task_index],
@@ -605,11 +646,11 @@ class BFCLAgent:
 
                     reward = self.get_reward(run_id, task_index)
                     if self.use_memory:
-                        if reward == 1 and self.use_memory_addition:  # selectively add memories when succeed
-                            new_traj_list = [
-                                self.get_traj_from_task_history(task_id, self.history[run_id][task_index], reward),
-                            ]
-                            self.add_memory(new_traj_list)
+                        if self.use_memory_addition:  # selectively add memories when succeed
+                            new_traj_list = [self.get_traj_from_task_history(task_id, self.history[run_id][task_index], reward)]
+                            previous_memories = self.add_memory(new_traj_list)
+                            if reward != 1:
+                                self.delete_memory_by_ids([mem["memory_id"] for mem in previous_memories])
 
                         # update the freq & utility attributes of retrieved memories
                         update_utility: bool = reward == 1
@@ -628,11 +669,13 @@ class BFCLAgent:
                         "task_history": self.history[run_id][task_index],
                         "task_start_time": start_time,
                     }
-                    result.append(t_result)
+                    if reward == 1:
+                        break
 
                 except Exception as e:
                     logger.exception(f"encounter error with {e.args}")
                     result.append({})
+            result.append(t_result)
         return result
 
     def task_completed(self, run_id, index):
@@ -652,7 +695,7 @@ def main():
     agent = BFCLAgent(
         index=0,
         task_id=task_ids[0],
-        experiment_name=f"zouying_{dataset_name}",
+        experiment_name=f"qwen3_8b_{dataset_name}",
     )
     result = agent.execute()
     logger.info(f"result={json.dumps(result)}")
diff --git a/cookbook/bfcl/evaluation.ipynb b/cookbook/bfcl/evaluation.ipynb
deleted file mode 100644
index f5b36595..00000000
--- a/cookbook/bfcl/evaluation.ipynb
+++ /dev/null
@@ -1,250 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "03491979",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from datetime import datetime\n",
-    "from collections import defaultdict"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "5adda27f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def process_jsonl(file_path, num_runs, window_size=50):\n",
-    "    with open(file_path, 'r') as file:\n",
-    "        data = [json.loads(line) for line in file]\n",
-    "\n",
-    "    runs = defaultdict(list)\n",
-    "    for i, item in enumerate(data):\n",
-    "        runs[int(i/(len(data)/num_runs))].append(item)\n",
-    "\n",
-    "    all_average_rewards = []\n",
-    "\n",
-    "    for run_id in range(num_runs):\n",
-    "        run_data = runs[run_id]\n",
-    "        run_data.sort(key=lambda x: datetime.strptime(x['task_start_time'], \"%Y-%m-%d %H:%M:%S\"))\n",
-    "\n",
-    "        rewards = [item['reward'] for item in run_data]\n",
-    "        average_rewards = []\n",
-    "        for i in range(0, len(rewards) - window_size + 1):\n",
-    "            average_rewards.append(sum(rewards[i:i+window_size])*1.0 / window_size)\n",
-    "        all_average_rewards.append(average_rewards)\n",
-    "\n",
-    "    return all_average_rewards"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "f022683e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_average_rewards(num_runs, average_rewards):\n",
-    "    plt.figure(figsize=(12, 6))\n",
-    "\n",
-    "    for run_id in range(num_runs):\n",
-    "        plt.plot(range(len(average_rewards[run_id])), average_rewards[run_id])\n",
-    "    plt.title('Average Reward over Time')\n",
-    "    plt.xlabel('Time')\n",
-    "    plt.ylabel('Average Reward')\n",
-    "    plt.grid(True)\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "5e06ff3d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_mean_reward_with_variance(average_rewards):\n",
-    "    plt.figure(figsize=(12, 6))\n",
-    "\n",
-    "    rewards_array = np.array(average_rewards)\n",
-    "    mean_rewards = np.mean(rewards_array, axis=0)\n",
-    "    std_rewards = np.std(rewards_array, axis=0)\n",
-    "\n",
-    "    x = range(len(mean_rewards))\n",
-    "    plt.plot(x, mean_rewards, label='Mean Reward')\n",
-    "\n",
-    "    plt.fill_between(x, mean_rewards - std_rewards, mean_rewards + std_rewards, \n",
-    "                     alpha=0.2, label='Standard Deviation')\n",
-    "\n",
-    "    plt.title('Average Reward over Time')\n",
-    "    plt.xlabel('Time')\n",
-    "    plt.ylabel('Average Reward')\n",
-    "    plt.legend()\n",
-    "    plt.grid(True)\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "id": "2ed2eb74",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_compare_mean_rewards_with_variance(*reward_sets, labels=None, colors=None):\n",
-    "    plt.figure(figsize=(12, 6))\n",
-    "\n",
-    "    if labels is None:\n",
-    "        labels = [f'Set {i+1}' for i in range(len(reward_sets))]\n",
-    "    \n",
-    "    if colors is None:\n",
-    "        colors = plt.cm.rainbow(np.linspace(0, 1, len(reward_sets)))\n",
-    "\n",
-    "    for idx, (rewards, label, color) in enumerate(zip(reward_sets, labels, colors)):\n",
-    "        rewards_array = np.array(rewards)\n",
-    "\n",
-    "        mean_rewards = np.mean(rewards_array, axis=0)\n",
-    "        std_rewards = np.std(rewards_array, axis=0)\n",
-    "\n",
-    "        x = range(len(mean_rewards))\n",
-    "        plt.plot(x, mean_rewards, label=f'Mean {label}')\n",
-    "\n",
-    "        plt.fill_between(x, mean_rewards - std_rewards, mean_rewards + std_rewards, \n",
-    "                         alpha=0.2)\n",
-    "\n",
-    "    plt.title('Comparison of Mean Rewards over Time with Variance')\n",
-    "    plt.xlabel('Time')\n",
-    "    plt.ylabel('Reward')\n",
-    "    plt.legend()\n",
-    "    plt.grid(True)\n",
-    "    plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "id": "330631fe",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "num_runs = 4  \n",
-    "window_size = 50\n",
-    "file_path = 'exp_result/qwen3-8b/no_think/'\n",
-    "file_names = ['bfcl-multi-turn-base-val_w-exp-fixed-recall-only-new.jsonl',\n",
-    "              'bfcl-multi-turn-base-val_w-exp-w-add-w-delete-recall-only-new.jsonl']\n",
-    "labels = [name.split('_')[-1].split('.')[0] for name in file_names]\n",
-    "\n",
-    "average_rewards = []\n",
-    "for file_name in file_names:\n",
-    "    average_rewards.append(process_jsonl(file_path+file_name, num_runs, window_size))\n",
-    "# plot_average_rewards(num_runs,average_rewards)\n",
-    "# plot_mean_reward_with_variance(average_rewards)\n",
-    "plot_compare_mean_rewards_with_variance(*average_rewards,labels=labels)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9cd927b0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_difference_from_baseline(reward_sets, labels=None, colors=None):\n",
-    "    plt.figure(figsize=(12, 6))\n",
-    "\n",
-    "    if labels is None:\n",
-    "        labels = [f'Set {i+1}' for i in range(len(reward_sets))]\n",
-    "    \n",
-    "    if colors is None:\n",
-    "        colors = plt.cm.rainbow(np.linspace(0, 1, len(reward_sets) - 1))\n",
-    "\n",
-    "    baseline_rewards = reward_sets[0]\n",
-    "    min_length = min(len(r) for r in baseline_rewards)\n",
-    "    baseline_rewards = [r[:min_length] for r in baseline_rewards]\n",
-    "    baseline_mean = np.mean(baseline_rewards, axis=0)\n",
-    "\n",
-    "    for idx, (rewards, label, color) in enumerate(zip(reward_sets[1:], labels[1:], colors)):\n",
-    "        rewards = [r[:min_length] for r in rewards]\n",
-    "\n",
-    "        rewards_array = np.array(rewards)\n",
-    "        mean_rewards = np.mean(rewards_array, axis=0)\n",
-    "        difference = mean_rewards - baseline_mean\n",
-    "        std_difference = np.std(rewards_array, axis=0)\n",
-    "\n",
-    "        x = range(min_length)\n",
-    "        plt.plot(x, difference, label=f'{label} vs Baseline')\n",
-    "        plt.fill_between(x, difference - std_difference, difference + std_difference, \n",
-    "                         alpha=0.2)\n",
-    "\n",
-    "    plt.title('Difference in Mean Rewards from Baseline')\n",
-    "    plt.xlabel('Time')\n",
-    "    plt.ylabel('Reward Difference')\n",
-    "    plt.legend()\n",
-    "    plt.grid(True)\n",
-    "    plt.axhline(y=0, color='r', linestyle='--')\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 52,
-   "id": "cef3492e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_difference_from_baseline(average_rewards, labels=labels)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/cookbook/bfcl/init_exp_pool.py b/cookbook/bfcl/init_exp_pool.py
index f9f22b7a..0f61a774 100644
--- a/cookbook/bfcl/init_exp_pool.py
+++ b/cookbook/bfcl/init_exp_pool.py
@@ -9,7 +9,9 @@ import requests
 
 
 def load_task_case(data_path: str, task_id: str | None) -> Dict[str, Any]:
-    """按 ID加载单条 JSONL 训练用例。找不到就抛错。"""
+    """
+    load training cases by id
+    """
     if not Path(data_path).exists():
         raise FileNotFoundError(f"BFCL data file '{data_path}' not found")
 
@@ -41,15 +43,14 @@ def get_tool_prompt(tools):
 
 def group_trajectories_by_task_id(jsonl_entries: List[Dict[str, Any]]) -> List[List[Any]]:
     """
-    根据task_id字段对trajectories进行分组
+    group trajectories by task_id
 
     Args:
-        jsonl_entries: JSONL条目列表
+        jsonl_entries: JSONL entry list
 
     Returns:
-        List[List[Any]]: 按task_id分组的trajectory列表
+        List[List[Any]]: trajectory list grouped by task_id
     """
-    # 按task_id分组
     grouped = defaultdict(list)
 
     for entry in jsonl_entries:
@@ -62,37 +63,26 @@ def group_trajectories_by_task_id(jsonl_entries: List[Dict[str, Any]]) -> List[L
         entry["task_history"][0]["content"] += get_tool_prompt(tool_schema)
         grouped[task_id].append(entry)
 
-    # 对每组只保留最大和最小reward的两个
+    # retain only the two with the highest and lowest rewards
     filtered_groups = []
     for key, trajectories in grouped.items():
         if len(trajectories) == 1:
-            # 只有一个trajectory，直接保留
+            # when only one trajectory, retain it
             filtered_groups.append(trajectories)
         elif len(trajectories) == 2:
-            # 有两个trajectory，直接保留
+            # when there are two trajectories, retain them
             filtered_groups.append(trajectories)
         else:
-            # 多个trajectory，选择最大和最小reward的
+            # when there are more than two trajectories, choose the two with the highest and lowest rewards
             trajectories.sort(key=lambda t: t["reward"])
-            min_reward_traj = trajectories[0]  # 最小reward
-            max_reward_traj = trajectories[-1]  # 最大reward
+            min_reward_traj = trajectories[0]  # highest reward
+            max_reward_traj = trajectories[-1]  # lowest reward
             filtered_groups.append([min_reward_traj, max_reward_traj])
 
     return filtered_groups
 
 
 def post_to_summarizer(trajectories: List[Any], service_url: str, workspace_id: str) -> Dict[str, Any]:
-    """
-    将trajectories发送到summarizer服务
-
-    Args:
-        trajectories: trajectory列表
-        service_url: 服务URL
-        workspace_id: 工作空间ID
-
-    Returns:
-        响应结果
-    """
     trajectory_dicts = [
         {
             "task_id": traj["task_id"],
@@ -103,12 +93,12 @@ def post_to_summarizer(trajectories: List[Any], service_url: str, workspace_id:
     ]
 
     request_data = {
-        "traj_list": trajectory_dicts,
+        "trajectories": trajectory_dicts,
         "workspace_id": workspace_id,
     }
 
     try:
-        response = requests.post(f"{service_url}/summarizer", json=request_data)
+        response = requests.post(f"{service_url}/summary_task_memory", json=request_data)
         response.raise_for_status()
         return response.json()
     except Exception as e:
@@ -122,27 +112,25 @@ def process_trajectories_with_threads(
     n_threads: int = 4,
 ) -> List[Dict[str, Any]]:
     """
-    使用多线程处理trajectories组
+    use threads to process trajectories
 
     Args:
-        grouped_trajectories: 按task_id分组的trajectory列表
-        service_url: summarizer服务URL
-        workspace_id: 工作空间ID
-        n_threads: 线程数
+        grouped_trajectories: group trajectory list by task_id
+        service_url: memory summarizer service URL
+        workspace_id: workspace ID
+        n_threads: number of threads
 
     Returns:
-        所有结果列表
+        all results
     """
     results = []
 
     with ThreadPoolExecutor(max_workers=n_threads) as executor:
-        # 提交所有任务
         future_to_group = {
             executor.submit(post_to_summarizer, group, service_url, workspace_id): i
             for i, group in enumerate(grouped_trajectories)
         }
 
-        # 收集结果
         for future in as_completed(future_to_group):
             group_index = future_to_group[future]
             try:
@@ -151,7 +139,7 @@ def process_trajectories_with_threads(
                 result["group_size"] = len(grouped_trajectories[group_index])
                 results.append(result)
                 print(
-                    f"✅ Group {group_index} processed: {result.get('experience_list', 0) if 'experience_list' in result else 'error'}",
+                    f'✅ Group {group_index} processed: {result["metadata"].get("memory_list", 0) if "memory_list" in result["metadata"] else "error"}',
                 )
             except Exception as e:
                 error_result = {
@@ -166,13 +154,10 @@ def process_trajectories_with_threads(
 
 
 def main():
-    """
-    主函数，支持命令行参数
-    """
-    parser = argparse.ArgumentParser(description="Convert JSONL to experiences using experience maker service")
+    parser = argparse.ArgumentParser(description="Convert JSONL to memories using ReMe service")
     parser.add_argument("--jsonl_file", type=str, required=True, help="Path to the JSONL file")
-    parser.add_argument("--service_url", type=str, default="http://localhost:8001", help="Experience maker service URL")
-    parser.add_argument("--workspace_id", type=str, required=True, help="Workspace ID for the experience")
+    parser.add_argument("--service_url", type=str, default="http://localhost:8001", help="ReMe service URL")
+    parser.add_argument("--workspace_id", type=str, required=True, help="Workspace ID for the task memory pool")
     parser.add_argument("--output_file", type=str, help="Output file to save results (optional)")
     parser.add_argument("--n_threads", type=int, default=4, help="Number of threads for processing")
 
@@ -183,20 +168,13 @@ def main():
     print(f"Workspace ID: {args.workspace_id}")
     print(f"Threads: {args.n_threads}")
 
-    # 读取JSONL文件
-    try:
-        with open(args.jsonl_file, "r") as f:
-            data = [json.loads(line) for line in f]
-        print(f"Loaded {len(data)} entries from JSONL file")
-    except Exception as e:
-        print(f"Error reading JSONL file: {e}")
-        return
+    with open(args.jsonl_file, "r") as f:
+        data = [json.loads(line) for line in f]
+    print(f"Loaded {len(data)} entries from JSONL file")
 
-    # 分组处理
     grouped_trajectories = group_trajectories_by_task_id(data)
     print(f"Total groups: {len(grouped_trajectories)}")
 
-    # 多线程处理
     results = process_trajectories_with_threads(
         grouped_trajectories,
         args.service_url,
@@ -206,16 +184,14 @@ def main():
 
     print(f"Processed {len(results)} groups")
 
-    # 统计结果
     success_count = sum(1 for r in results if "error" not in r)
     error_count = len(results) - success_count
-    total_experiences = sum(len(r.get("experiences", [])) for r in results if "experiences" in r)
+    total_memories = sum(len(r["metadata"].get("memory_list", [])) for r in results if "memory_list" in r["metadata"])
 
     print(f"✅ Success: {success_count}")
     print(f"❌ Errors: {error_count}")
-    print(f"📊 Total experiences created: {total_experiences}")
+    print(f"📊 Total task memories created: {total_memories}")
 
-    # 保存结果到文件
     if args.output_file:
         try:
             summary = {
@@ -224,7 +200,7 @@ def main():
                 "total_groups": len(grouped_trajectories),
                 "success_count": success_count,
                 "error_count": error_count,
-                "total_experiences": total_experiences,
+                "total_task_memories": total_memories,
                 "results": results,
             }
 
@@ -235,28 +211,23 @@ def main():
             print(f"Error saving results: {e}")
 
 
-# 保持原有的使用示例（向后兼容）
 if __name__ == "__main__":
-    # 检查是否有命令行参数
     import sys
 
     if len(sys.argv) > 1:
-        # 使用新的命令行接口
         main()
     else:
-        # 保持原有的行为（向后兼容）
         print("Running in compatibility mode...")
-        with open("exp_result/qwen-max-2025-01-25/no_think/bfcl-multi-turn-base-train50_wo-exp.jsonl", "r") as f:
+        with open("exp_result/qwen3-8b/with_think/bfcl-multi-turn-base-train50_wo-exp.jsonl", "r") as f:
             data = [json.loads(line) for line in f]
 
-        # 分组
         grouped_trajectories = group_trajectories_by_task_id(data)
         print(f"Total groups: {len(grouped_trajectories)}")
 
         results = process_trajectories_with_threads(
             grouped_trajectories,
             "http://localhost:8001",
-            "bfcl_train50_qwen_max_2025_01_25_extract_compare_validate",
+            "bfcl_train50_qwen3_8b_extract_compare_validate",
             n_threads=4,
         )
         print(f"Processed {len(results)} groups")
diff --git a/cookbook/bfcl/init_task_memory_pool.py b/cookbook/bfcl/init_task_memory_pool.py
index 01896fe2..2a298407 100644
--- a/cookbook/bfcl/init_task_memory_pool.py
+++ b/cookbook/bfcl/init_task_memory_pool.py
@@ -218,7 +218,7 @@ if __name__ == "__main__":
         main()
     else:
         print("Running in compatibility mode...")
-        with open("exp_result/qwen3-14b/no_think/bfcl-multi-turn-base_wo-exp.jsonl", "r") as f:
+        with open("exp_result/qwen3-8b/no_think/bfcl-multi-turn-base_wo-exp.jsonl", "r") as f:
             data = [json.loads(line) for line in f]
 
         grouped_trajectories = group_trajectories_by_task_id(data)
@@ -227,7 +227,7 @@ if __name__ == "__main__":
         results = process_trajectories_with_threads(
             grouped_trajectories,
             "http://localhost:8001",
-            "bfcl_test",
+            "bfcl_v3",
             n_threads=4,
         )
         print(f"Processed {len(results)} groups")
diff --git a/cookbook/bfcl/local_file_to_library.py b/cookbook/bfcl/local_file_to_library.py
index 9131b512..3f51cf86 100644
--- a/cookbook/bfcl/local_file_to_library.py
+++ b/cookbook/bfcl/local_file_to_library.py
@@ -19,6 +19,8 @@ for exp in bfcl:
     new_exp["author"] = exp["metadata"]["author"]
 
     new_exp["metadata"] = exp["metadata"]["metadata"]
+    new_exp["metadata"]["utility"] = 0
+    new_exp["metadata"]["freq"] = 0
 
     new_bfcl.append(new_exp)
 
diff --git a/cookbook/bfcl/run_bfcl.py b/cookbook/bfcl/run_bfcl.py
index c3acbdda..fd8cc2db 100644
--- a/cookbook/bfcl/run_bfcl.py
+++ b/cookbook/bfcl/run_bfcl.py
@@ -19,7 +19,7 @@ def run_agent(
     dataset_name: str,
     experiment_suffix: str,
     max_workers: int,
-    num_runs: int = 4,
+    num_trials: int = 1,
     model_name: str = "qwen3-8b",
     data_path: str = "data/multiturn_data_base_val.jsonl",
     answer_path: Path = Path("data/possible_answer"),
@@ -30,8 +30,8 @@ def run_agent(
     freq_threshold: int = 5,
     utility_threshold: float = 0.5,
     enable_thinking: bool = False,
-    memory_base_url: str = "http://0.0.0.0:8001/",
-    memory_workspace_id: str = "bfcl_test",
+    memory_base_url: str = "http://0.0.0.0:8002/",
+    memory_workspace_id: str = "bfcl_v3",
 ):
     experiment_name = dataset_name + "_" + experiment_suffix
     path: Path = Path(
@@ -58,7 +58,7 @@ def run_agent(
             data_path=data_path,
             answer_path=answer_path,
             model_name=model_name,
-            num_runs=num_runs,
+            num_trials=num_trials,
             use_memory=use_memory,
             use_memory_addition=use_memory_addition,
             use_memory_deletion=use_memory_deletion,
@@ -89,20 +89,25 @@ def run_agent(
 def main():
     max_workers = 4
     num_runs = 1
+
+    num_trials = 2
+    model_name="qwen3-8b"
     use_memory = False
     use_memory_addition = False
     use_memory_deletion = False
-    memory_base_url = "http://0.0.0.0:8001/"
-    memory_workspace_id = "bfcl_test"
+    memory_base_url = "http://0.0.0.0:8002/"
+    memory_workspace_id = "bfcl_v3"
+
     if max_workers > 1:
         ray.init(num_cpus=max_workers)
+
     for run_id in range(num_runs):
         run_agent(
             dataset_name="bfcl-multi-turn-base",
             experiment_suffix=f"wo-exp",
-            model_name="qwen3-8b",
+            model_name=model_name,
             max_workers=max_workers,
-            num_runs=1,
+            num_trials=num_trials,
             data_path="data/multiturn_data_base_val.jsonl",
             answer_path=Path("data/possible_answer"),
             enable_thinking=False,
diff --git a/reme_ai/vector_store/delete_memory_op.py b/reme_ai/vector_store/delete_memory_op.py
index 68c26795..b7828f63 100644
--- a/reme_ai/vector_store/delete_memory_op.py
+++ b/reme_ai/vector_store/delete_memory_op.py
@@ -48,7 +48,6 @@ class DeleteMemoryOp(BaseAsyncOp):
 
         deleted_memory_ids = []
         for node in nodes:
-            # VectorNode 对象需要使用属性访问，不是字典访问
             freq = node.metadata.get("freq", 0)
             utility = node.metadata.get("utility", 0)
             if freq >= freq_threshold:
diff --git a/reme_ai/vector_store/vector_store_action_op.py b/reme_ai/vector_store/vector_store_action_op.py
index 7df2d68c..670e85b0 100644
--- a/reme_ai/vector_store/vector_store_action_op.py
+++ b/reme_ai/vector_store/vector_store_action_op.py
@@ -99,4 +99,4 @@ class VectorStoreActionOp(BaseAsyncOp):
         else:
             raise ValueError(f"invalid action={action}")
 
-        self.context.response.metadata["action_result"] = result
+        self.context.response.metadata["action_result"] = str(result)