diff --git a/examples/experimental/group_discussion_agents/group_discussion_agents.py b/examples/experimental/group_discussion_agents/group_discussion_agents.py
index e4b3c0c2c..8ef55e5c5 100644
--- a/examples/experimental/group_discussion_agents/group_discussion_agents.py
+++ b/examples/experimental/group_discussion_agents/group_discussion_agents.py
@@ -2,7 +2,7 @@
 from aact import Message, NodeFactory
 from aact.messages import Text, Tick, DataModel, DataModelFactory
 from sotopia.agents.llm_agent import ainput
-from sotopia.experimental.agents import BaseAgent
+from sotopia.experimental.agents.base_agent import BaseAgent
 
 from sotopia.generation_utils import agenerate
 from sotopia.generation_utils.generate import StrOutputParser
diff --git a/examples/experimental/interview_openhands/interview_openhands.toml b/examples/experimental/interview_openhands/interview_openhands.toml
new file mode 100644
index 000000000..805d4112e
--- /dev/null
+++ b/examples/experimental/interview_openhands/interview_openhands.toml
@@ -0,0 +1,45 @@
+redis_url = "redis://localhost:6379/0"
+extra_modules = ["examples.experimental.interview_openhands.llm_agent"]
+
+
+[[nodes]]
+node_name = "Jack"
+node_class = "llm_agent"
+
+[nodes.node_args]
+query_interval = 5
+output_channel = "Jack:Jane"
+input_text_channels = ["Jane:Jack"]
+input_env_channels = ["Runtime:Agent"]
+input_tick_channel = "tick/secs/1"
+goal = "Your goal is to effectively test Jane's technical ability and finally decide if she has passed the interview. Make sure to also evaluate her communication skills, problem-solving approach, and enthusiasm."
+model_name = "gpt-4o-mini"
+agent_name = "Jack"
+
+[[nodes]]
+node_name = "Jane"
+node_class = "llm_agent"
+
+[nodes.node_args]
+query_interval = 7
+output_channel = "Jane:Jack"
+input_text_channels = ["Jack:Jane"]
+input_env_channels = ["Runtime:Agent"]
+input_tick_channel = "tick/secs/1"
+goal = "Your goal is to do well in the interview by demonstrating your technical skills, clear communication, and enthusiasm for the position. Stay calm, ask clarifying questions when needed, and confidently explain your thought process."
+model_name = "gpt-4o-mini"
+agent_name = "Jane"
+
+[[nodes]]
+node_name = "tick"
+node_class = "tick"
+
+
+[[nodes]]
+node_name = "print"
+node_class = "print"
+
+[nodes.node_args.print_channel_types]
+"tick/secs/1" = "tick"
+"Jane:Jack" = "agent_action"
+"Jack:Jane" = "agent_action"
diff --git a/examples/experimental/interview_openhands/llm_agent.py b/examples/experimental/interview_openhands/llm_agent.py
new file mode 100644
index 000000000..67b0025f3
--- /dev/null
+++ b/examples/experimental/interview_openhands/llm_agent.py
@@ -0,0 +1,448 @@
+import logging
+import sys
+from enum import Enum
+from rich.logging import RichHandler
+from pydantic import Field
+
+from typing import Optional
+
+from aact import Message, NodeFactory
+from aact.messages import Text, Tick, DataModel
+from aact.messages.registry import DataModelFactory
+
+from sotopia.experimental.agents.base_agent import BaseAgent
+
+from sotopia.generation_utils import agenerate
+from sotopia.generation_utils.generate import StrOutputParser
+
+import json
+
+# Check Python version
+if sys.version_info >= (3, 11):
+    pass
+else:
+    pass
+
+# Configure logging
+FORMAT = "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+logging.basicConfig(
+    level=logging.WARNING,
+    format=FORMAT,
+    datefmt="[%X]",
+    handlers=[RichHandler()],
+)
+
+
+class ActionType(Enum):
+    NONE = "none"
+    SPEAK = "speak"
+    NON_VERBAL = "non-verbal"
+    LEAVE = "leave"
+    THOUGHT = "thought"
+    BROWSE = "browse"
+    BROWSE_ACTION = "browse_action"
+    READ = "read"
+    WRITE = "write"
+    RUN = "run"
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, ActionType):
+            return self.value == other.value
+        elif isinstance(other, str):
+            return self.value == other
+        else:
+            return NotImplemented
+
+
+@DataModelFactory.register("agent_action")
+class AgentAction(DataModel):
+    agent_name: str = Field(description="the name of the agent")
+    action_type: ActionType = Field(
+        description="whether to speak at this turn or choose to not do anything"
+    )
+    argument: str = Field(
+        description="the utterance if choose to speak, the expression or gesture if choose non-verbal communication, or the physical action if choose action"
+    )
+    path: Optional[str] = Field(description="path of file")
+
+    def to_natural_language(self) -> str:
+        action_descriptions = {
+            ActionType.NONE: "did nothing",
+            ActionType.SPEAK: f'said: "{self.argument}"',
+            ActionType.THOUGHT: f'thought: "{self.argument}"',
+            ActionType.BROWSE: f'browsed: "{self.argument}"',
+            ActionType.RUN: f'ran: "{self.argument}"',
+            ActionType.READ: f'read: "{self.argument}"',
+            ActionType.WRITE: f'wrote: "{self.argument}"',
+            ActionType.NON_VERBAL: f"[{self.action_type.value}] {self.argument}",
+            ActionType.LEAVE: "left the conversation",
+        }
+
+        return action_descriptions.get(self.action_type, "performed an unknown action")
+
+
+@NodeFactory.register("llm_agent")
+class LLMAgent(BaseAgent[AgentAction | Tick | Text, AgentAction]):
+    def __init__(
+        self,
+        input_text_channels: list[str],
+        input_tick_channel: str,
+        input_env_channels: list[str],
+        output_channel: str,
+        query_interval: int,
+        agent_name: str,
+        goal: str,
+        model_name: str,
+        redis_url: str,
+    ):
+        super().__init__(
+            [
+                (input_text_channel, AgentAction)
+                for input_text_channel in input_text_channels
+            ]
+            + [
+                (input_tick_channel, Tick),
+            ]
+            + [(input_env_channel, Text) for input_env_channel in input_env_channels],
+            [(output_channel, AgentAction)],
+            redis_url,
+        )
+        self.output_channel = output_channel
+        self.query_interval = query_interval
+        self.count_ticks = 0
+        self.message_history: list[tuple[str, str, str]] = []
+        self.name = agent_name
+        self.model_name = model_name
+        self.goal = goal
+
+    async def send(self, message: AgentAction) -> None:
+        if message.action_type == "speak":
+            await self.r.publish(
+                self.output_channel,
+                Message[AgentAction](data=message).model_dump_json(),
+            )
+
+        elif message.action_type in ("browse", "browse_action", "write", "read", "run"):
+            await self.r.publish(
+                "Agent:Runtime",
+                Message[AgentAction](data=message).model_dump_json(),
+            )
+
+    def _format_message_history(
+        self, message_history: list[tuple[str, str, str]]
+    ) -> str:
+        ## TODO: akhatua Fix the mapping of action to be gramatically correct
+        return "\n".join(
+            (f"{speaker} {action} {message}")
+            for speaker, action, message in message_history
+        )
+
+    def get_action_template(self, selected_actions: list[ActionType]) -> str:
+        """
+        Returns the action template string with selected actions.
+
+        Args:
+            selected_actions (list[ActionType]): List of ActionType enum members to include in the template.
+
+        Returns:
+            str: The action template with the selected actions.
+        """
+        base_template = """ You are talking to another agent.
+        You are {agent_name}.\n
+        {message_history}\nand you plan to {goal}.
+        ## Action
+        What is your next thought or action? Your response must be in JSON format.
+
+        It must be an object, and it must contain two fields:
+        * `action`, which is one of the actions below
+        * `args`, which is a map of key-value pairs, specifying the arguments for that action
+        """
+
+        action_descriptions = {
+            str(
+                ActionType.SPEAK
+            ): """`speak` - you can talk to the other agents to share information or ask them something. Arguments:
+                * `content` - the message to send to the other agents (should be short)""",
+            str(
+                ActionType.THOUGHT
+            ): """`thought` - only use this rarely to make a plan, set a goal, record your thoughts. Arguments:
+                * `content` - the message you send yourself to organize your thoughts (should be short). You cannot think more than 2 turns.""",
+            str(
+                ActionType.NONE
+            ): """`none` - you can choose not to take an action if you are waiting for some data""",
+            str(
+                ActionType.NON_VERBAL
+            ): """`non-verbal` - you can choose to do a non verbal action
+                * `content` - the non veral action you want to send to other agents. eg: smile, shrug, thumbs up""",
+            str(ActionType.BROWSE): """`browse` - opens a web page. Arguments:
+                * `url` - the URL to open, when you browse the web you must use `none` action until you get some information back. When you get the information back you must summarize the article and explain the article to the other agents.""",
+            str(
+                ActionType.BROWSE_ACTION
+            ): """`browse_action` - actions you can take on a web browser
+                * `command` - the command to run. You have 15 available commands. These commands must be a single string value of command
+                    Options for `command`:
+                        `command` = goto(url: str)
+                            Description: Navigate to a url.
+                            Examples:
+                                goto('http://www.example.com')
+
+                        `command` = go_back()
+                            Description: Navigate to the previous page in history.
+                            Examples:
+                                go_back()
+
+                        `command` = go_forward()
+                            Description: Navigate to the next page in history.
+                            Examples:
+                                go_forward()
+
+                        `command` = noop(wait_ms: float = 1000)
+                            Description: Do nothing, and optionally wait for the given time (in milliseconds).
+                            You can use this to get the current page content and/or wait for the page to load.
+                            Examples:
+                                noop()
+                                noop(500)
+
+                        `command` = scroll(delta_x: float, delta_y: float)
+                            Description: Scroll horizontally and vertically. Amounts in pixels, positive for right or down scrolling, negative for left or up scrolling. Dispatches a wheel event.
+                            Examples:
+                                scroll(0, 200)
+                                scroll(-50.2, -100.5)
+
+                        `command` = fill(bid, value)
+                            Description: Fill out a form field. It focuses the element and triggers an input event with the entered text. It works for <input>, <textarea> and [contenteditable] elements.
+                            Examples:
+                                fill('237', 'example value')
+                                fill('45', 'multi-line\nexample')
+                                fill('a12', 'example with "quotes"')
+
+                        `command` = select_option(bid: str, options: str | list[str])
+                            Description: Select one or multiple options in a <select> element. You can specify option value or label to select. Multiple options can be selected.
+                            Examples:
+                                select_option('a48', 'blue')
+                                select_option('c48', ['red', 'green', 'blue'])
+
+                        `command`= click(bid: str, button: Literal['left', 'middle', 'right'] = 'left', modifiers: list[typing.Literal['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift']] = [])
+                            Description: Click an element.
+                            Examples:
+                                click('a51')
+                                click('b22', button='right')
+                                click('48', button='middle', modifiers=['Shift'])
+
+                        `command` = dblclick(bid: str, button: Literal['left', 'middle', 'right'] = 'left', modifiers: list[typing.Literal['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift']] = [])
+                            Description: Double click an element.
+                            Examples:
+                                dblclick('12')
+                                dblclick('ca42', button='right')
+                                dblclick('178', button='middle', modifiers=['Shift'])
+
+                        `command` = hover(bid: str)
+                            Description: Hover over an element.
+                            Examples:
+                                hover('b8')
+
+                        `command` = press(bid: str, key_comb: str)
+                            Description: Focus the matching element and press a combination of keys. It accepts the logical key names that are emitted in the keyboardEvent.key property of the keyboard events: Backquote, Minus, Equal, Backslash, Backspace, Tab, Delete, Escape, ArrowDown, End, Enter, Home, Insert, PageDown, PageUp, ArrowRight, ArrowUp, F1 - F12, Digit0 - Digit9, KeyA - KeyZ, etc. You can alternatively specify a single character you'd like to produce such as "a" or "#". Following modification shortcuts are also supported: Shift, Control, Alt, Meta, ShiftLeft, ControlOrMeta. ControlOrMeta resolves to Control on Windows and Linux and to Meta on macOS.
+                            Examples:
+                                press('88', 'Backspace')
+                                press('a26', 'ControlOrMeta+a')
+                                press('a61', 'Meta+Shift+t')
+
+                        `command` = focus(bid: str)
+                            Description: Focus the matching element.
+                            Examples:
+                                focus('b455')
+
+                        `command` = clear(bid: str)
+                            Description: Clear the input field.
+                            Examples:
+                                clear('996')
+
+                        `command` = drag_and_drop(from_bid: str, to_bid: str)
+                            Description: Perform a drag & drop. Hover the element that will be dragged. Press left mouse button. Move mouse to the element that will receive the drop. Release left mouse button.
+                            Examples:
+                                drag_and_drop('56', '498')
+
+                        `command`=  upload_file(bid: str, file: str | list[str])
+                            Description: Click an element and wait for a "filechooser" event, then select one or multiple input files for upload. Relative file paths are resolved relative to the current working directory. An empty list clears the selected files.
+                            Examples:
+                                upload_file('572', '/home/user/my_receipt.pdf')
+                                upload_file('63', ['/home/bob/Documents/image.jpg', '/home/bob/Documents/file.zip'])""",
+            str(ActionType.READ): """`read` - reads the content of a file. Arguments:
+                * `path` - the path of the file to read""",
+            str(ActionType.WRITE): """`write` - writes the content to a file. Arguments:
+                * `path` - the path of the file to write
+                * `content` - the content to write to the file""",
+            str(
+                ActionType.RUN
+            ): """`run` - runs a command on the command line in a Linux shell. Arguments:
+                * `command` - the command to run""",
+            str(
+                ActionType.LEAVE
+            ): """`leave` - if your goals have been completed or abandoned, and you're absolutely certain that you've completed your task and have tested your work, use the leave action to stop working.""",
+        }
+
+        selected_action_descriptions = "\n\n".join(
+            f"[{i+1}] {action_descriptions[str(action)]}"
+            for i, action in enumerate(selected_actions)
+            if str(action) in action_descriptions
+        )
+
+        return (
+            base_template
+            + selected_action_descriptions
+            + """
+                You must prioritize actions that move you closer to your goal. Communicate briefly when necessary and focus on executing tasks effectively. Always consider the next actionable step to avoid unnecessary delays.
+                Again, you must reply with JSON, and only with JSON.
+            """
+        )
+
+    async def aact(self, message: AgentAction | Tick | Text) -> AgentAction:
+        match message:
+            case Text(text=text):
+                self.message_history.append((self.name, "observation data", text))
+                return AgentAction(
+                    agent_name=self.name, action_type="none", argument="", path=""
+                )
+            case Tick():
+                self.count_ticks += 1
+                if self.count_ticks % self.query_interval == 0:
+                    try:
+                        template = self.get_action_template(
+                            [action for action in ActionType]
+                        )
+
+                        agent_action = await agenerate(
+                            model_name=self.model_name,
+                            template=template,
+                            input_values={
+                                "message_history": self._format_message_history(
+                                    self.message_history
+                                ),
+                                "goal": self.goal,
+                                "agent_name": self.name,
+                            },
+                            temperature=0.7,
+                            output_parser=StrOutputParser(),
+                        )
+                    except Exception as e:
+                        print(f"Error during agenerate: {e}")
+
+                    agent_action = (
+                        agent_action.replace("```", "")
+                        .replace("json", "")
+                        .strip('"')
+                        .strip()
+                    )
+
+                    try:
+                        data = json.loads(agent_action)
+                        action = data["action"]
+                        if action == "thought":
+                            content = data["args"]["content"]
+                            self.message_history.append((self.name, action, content))
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type="thought",
+                                argument=content,
+                                path="",
+                            )
+
+                        elif action == "speak":
+                            content = data["args"]["content"]
+                            self.message_history.append((self.name, action, content))
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type=action,
+                                argument=content,
+                                path="",
+                            )
+
+                        elif action == "non-verbal":
+                            content = data["args"]["content"]
+                            self.message_history.append((self.name, action, content))
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type=action,
+                                argument=content,
+                                path="",
+                            )
+
+                        elif action == "browse":
+                            url = data["args"]["url"]
+                            self.message_history.append((self.name, action, url))
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type=action,
+                                argument=url,
+                                path="",
+                            )
+
+                        elif action == "browse_action":
+                            command = data["args"]["command"]
+                            self.message_history.append((self.name, action, command))
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type=action,
+                                argument=command,
+                                path="",
+                            )
+
+                        elif action == "run":
+                            command = data["args"]["command"]
+                            self.message_history.append((self.name, action, command))
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type=action,
+                                argument=command,
+                                path="",
+                            )
+
+                        elif action == "write":
+                            path = data["args"]["path"]
+                            content = data["args"]["content"]
+                            self.message_history.append((self.name, action, content))
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type=action,
+                                argument=content,
+                                path=path,
+                            )
+
+                        elif action == "read":
+                            path = data["args"]["path"]
+                            self.message_history.append((self.name, action, path))
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type=action,
+                                argument="Nan",
+                                path=path,
+                            )
+
+                        elif action == "none":
+                            return AgentAction(
+                                agent_name=self.name,
+                                action_type="none",
+                                argument="",
+                                path="",
+                            )
+                        else:
+                            print(f"Unknown action: {action}")
+                    except json.JSONDecodeError as e:
+                        print(f"Error decoding JSON: {e}")
+                else:
+                    return AgentAction(
+                        agent_name=self.name, action_type="none", argument="", path=""
+                    )
+            case AgentAction(
+                agent_name=agent_name, action_type=action_type, argument=text
+            ):
+                if action_type == "speak":
+                    self.message_history.append((agent_name, str(action_type), text))
+                return AgentAction(
+                    agent_name=self.name, action_type="none", argument="", path=""
+                )
+        raise ValueError(f"Unexpected message type: {type(message)}")
diff --git a/examples/experimental/interview_openhands/readme.md b/examples/experimental/interview_openhands/readme.md
new file mode 100644
index 000000000..fc78eb25d
--- /dev/null
+++ b/examples/experimental/interview_openhands/readme.md
@@ -0,0 +1,183 @@
+# OpenHands Interview Example
+
+In this example, we explore the interaction between two LLM agents, "Jack" and "Jane", within an OpenHands runtime node. These agents are designed to simulate an interview scenario where "Jack" evaluates "Jane's" technical abilities and communication skills.
+
+## Agents Overview
+
+- **Jack (Interviewer)**: An LLM agent tasked with assessing Jane's technical skills, communication, problem-solving approach, and enthusiasm.
+- **Jane (Interviewee)**: An LLM agent aiming to perform well in the interview by showcasing her skills and enthusiasm.
+
+### Customizing the Scenario
+
+You can modify the `interview_openhands.toml` file to simulate different scenarios by changing the goals, model names, and communication channels. This flexibility allows you to tailor the interaction to various use cases, such as customer service simulations, collaborative problem-solving, or educational tutoring.
+
+### Actions Available to LLM Agents
+
+- **speak**: Communicate with other agents by sending a message.
+- **thought**: Make a plan or set a goal internally.
+- **none**: Choose not to take any action, often used when waiting for data.
+- **non-verbal**: Perform a non-verbal action, such as a gesture.
+- **browse**: Open a web page.
+- **browse_action**: Perform actions on a web browser, such as navigating or interacting with elements.
+- **read**: Read the content of a file.
+- **write**: Write content to a file.
+- **run**: Execute a command in a Linux shell.
+- **leave**: Exit the conversation when goals are completed or abandoned.
+
+These actions enable the agents to interact dynamically with their environment and each other, providing a robust framework for simulating complex scenarios.
+
+## Dataflow Configuration
+
+The dataflow file `interview_openhands.toml` is used to configure the interaction between the agents. It acts as a blueprint, defining how the agents communicate and process information.
+
+### Example Configuration
+
+```toml
+[[nodes]]
+node_name = "Jack"
+node_class = "llm_agent"
+
+[nodes.node_args]
+query_interval = 5
+output_channel = "Jack:Jane"
+input_text_channels = ["Jane:Jack"]
+input_env_channels = ["Runtime:Agent"]
+input_tick_channel = "tick/secs/1"
+goal = "Your goal is to effectively test Jane's technical ability and finally decide if she has passed the interview. Make sure to also evaluate her communication skills, problem-solving approach, and enthusiasm."
+model_name = "gpt-4o-mini"
+agent_name = "Jack"
+
+[[nodes]]
+node_name = "Jane"
+node_class = "llm_agent"
+
+[nodes.node_args]
+query_interval = 7
+output_channel = "Jane:Jack"
+input_text_channels = ["Jack:Jane"]
+input_env_channels = ["Runtime:Agent"]
+input_tick_channel = "tick/secs/1"
+goal = "Your goal is to do well in the interview by demonstrating your technical skills, clear communication, and enthusiasm for the position. Stay calm, ask clarifying questions when needed, and confidently explain your thought process."
+model_name = "gpt-4o-mini"
+agent_name = "Jane"
+```
+
+### Auxiliary Nodes
+
+In addition to the agents, there are auxiliary nodes that facilitate the interaction:
+
+- **Tick Node**: Provides a stable clock signal for synchronization.
+- **Print Node**: Outputs real-time messages for monitoring the interaction.
+
+#### Auxiliary Node Configuration
+
+```toml
+[[nodes]]
+node_name = "tick"
+node_class = "tick"
+
+[[nodes]]
+node_name = "print"
+node_class = "print"
+
+[nodes.node_args.print_channel_types]
+"tick/secs/1" = "tick"
+"Jane:Jack" = "agent_action"
+"Jack:Jane" = "agent_action"
+```
+
+## Running the Example
+
+### Prerequisites
+
+1. **Redis**: Ensure Redis is hosted at `localhost:6379`. Update the `redis_url` in the `interview_openhands.toml` file if using a different Redis database.
+
+2. **Setting Up OpenHands Runtime**: Clone the repository and set up the environment.
+
+   - **Clone the Repository**: Clone the repository from GitHub to get the necessary files and configurations.
+     ```bash
+     git clone https://github.com/akhatua2/aact-openhands
+     cd aact-openhands
+     ```
+
+   - **Python and Poetry**: Ensure you have Python 3.12 installed. Install Poetry for dependency management if you haven't already.
+     ```bash
+     curl -sSL https://install.python-poetry.org | python3 -
+     ```
+
+   - **Install Dependencies**: Navigate to the project directory and install the dependencies using Poetry.
+     ```bash
+     poetry install
+     ```
+
+   - **Environment Variables**: Set up your environment variables. Copy the `.env.example` file to a new file named `.env` in the root of your project directory and replace the placeholder values with your actual API keys and URLs.
+     ```bash
+     cp .env.example .env
+     ```
+
+     Edit the `.env` file:
+     ```plaintext
+     MODAL_API_TOKEN_ID=your_actual_modal_api_token_id
+     MODAL_API_TOKEN_SECRET=your_actual_modal_api_token_secret
+     ```
+   - **Running the OpenHands Node**
+
+        To run the OpenHands node with the provided configuration, use the following command:
+
+        ```bash
+        poetry run aact run-dataflow examples/openhands_node.toml
+        ```
+
+        Upon successful execution, you should see output similar to the following:
+
+        ```bash
+        16:41:26 - openhands:INFO: openhands_node.py:120 - --------------------
+        16:41:26 - openhands:INFO: openhands_node.py:121 - RUNTIME CONNECTED
+        16:41:26 - openhands:INFO: openhands_node.py:122 - --------------------
+        16:41:26 - openhands:INFO: openhands_node.py:127 - Runtime initialization took 157.77 seconds.
+        ```
+
+These steps ensure that you have the necessary environment and dependencies to run the OpenHands node and the example scenario.
+
+### Command
+
+To run this interview setting example, use the following command:
+
+```bash
+uv run aact run-dataflow examples/experimental/interview_openhands/interview_openhands.toml
+```
+
+### Expected Output
+
+You will see JSON strings printed out, representing messages exchanged between the nodes. These messages include timestamps for easy debugging and data recording, demonstrating the real-time interaction between the agents.
+
+```json
+{"timestamp":"2024-11-12T17:27:27.797795","channel":"tick/secs/1","data":{"data_type":"tick","tick":0}}
+{"timestamp":"2024-11-12T17:27:28.810269","channel":"tick/secs/1","data":{"data_type":"tick","tick":1}}
+{"timestamp":"2024-11-12T17:27:29.805630","channel":"tick/secs/1","data":{"data_type":"tick","tick":2}}
+{"timestamp":"2024-11-12T17:27:30.803932","channel":"tick/secs/1","data":{"data_type":"tick","tick":3}}
+{"timestamp":"2024-11-12T17:27:31.804342","channel":"tick/secs/1","data":{"data_type":"tick","tick":4}}
+{"timestamp":"2024-11-12T17:27:32.805544","channel":"tick/secs/1","data":{"data_type":"tick","tick":5}}
+{"timestamp":"2024-11-12T17:27:33.094975","channel":"Jack:Jane","data":{"data_type":"agent_action","agent_name":"Jack","
+action_type":"speak","argument":"Hi Jane! I'm Jack, a Principal Software Engineer here at Fintech. It's great to meet you! Could you please introduce yourself and tell me a little about your education and any relevant experiences you've had?","path":""}}
+{"timestamp":"2024-11-12T17:27:33.801111","channel":"tick/secs/1","data":{"data_type":"tick","tick":6}}
+{"timestamp":"2024-11-12T17:27:34.803471","channel":"tick/secs/1","data":{"data_type":"tick","tick":7}}
+{"timestamp":"2024-11-12T17:27:35.118890","channel":"Jane:Jack","data":{"data_type":"agent_action","agent_name":"Jane","
+action_type":"speak","argument":"Hi Jack! I'm Jane, a college senior at Stanford University majoring in Computer Science. I've had a strong focus on software development, especially in fintech applications. I recently completed a project where I built a budgeting app using React and Node.js, which helped users manage their finances effectively. I'm excited about the opportunity to bring my skills to your team.","path":""}}
+{"timestamp":"2024-11-12T17:27:35.803424","channel":"tick/secs/1","data":{"data_type":"tick","tick":8}}
+{"timestamp":"2024-11-12T17:27:36.800113","channel":"tick/secs/1","data":{"data_type":"tick","tick":9}}
+{"timestamp":"2024-11-12T17:27:37.732772","channel":"Jack:Jane","data":{"data_type":"agent_action","agent_name":"Jack","
+action_type":"speak","argument":"That's a fantastic introduction, Jane! Your project sounds really interesting. Now, let's dive into some technical questions. Are you ready?","path":""}}
+{"timestamp":"2024-11-12T17:27:37.802020","channel":"tick/secs/1","data":{"data_type":"tick","tick":10}}
+{"timestamp":"2024-11-12T17:27:38.800835","channel":"tick/secs/1","data":{"data_type":"tick","tick":11}}
+{"timestamp":"2024-11-12T17:27:39.804363","channel":"tick/secs/1","data":{"data_type":"tick","tick":12}}
+```
+
+This output shows the following events:
+
+1. The tick node sends a tick message, indicating the passage of time.
+2. "Jack" initiates the conversation by introducing himself and asking "Jane" to introduce herself.
+3. "Jane" responds with her introduction, highlighting her education and relevant experiences.
+4. "Jack" acknowledges Jane's introduction and prepares to ask technical questions.
+
+Each message includes a timestamp for easy debugging and data recording. The interaction demonstrates the agents' ability to simulate a realistic interview scenario, with messages exchanged in real-time.
diff --git a/examples/experimental/tick_and_echo_agents/tick_and_echo_agents.py b/examples/experimental/tick_and_echo_agents/tick_and_echo_agents.py
index d05feb218..7cb65ddd9 100644
--- a/examples/experimental/tick_and_echo_agents/tick_and_echo_agents.py
+++ b/examples/experimental/tick_and_echo_agents/tick_and_echo_agents.py
@@ -1,6 +1,6 @@
 from aact import NodeFactory
 from aact.messages import Text, Tick
-from sotopia.experimental.agents import BaseAgent
+from sotopia.experimental.agents.base_agent import BaseAgent
 
 
 @NodeFactory.register("simple_echo_agent")
diff --git a/sotopia/experimental/__init__.py b/sotopia/experimental/__init__.py
index 21175f409..2f2166320 100644
--- a/sotopia/experimental/__init__.py
+++ b/sotopia/experimental/__init__.py
@@ -1,3 +1,3 @@
-from .agents import BaseAgent
+from .agents.base_agent import BaseAgent
 
 __all__ = ["BaseAgent"]
diff --git a/sotopia/experimental/agents.py b/sotopia/experimental/agents/base_agent.py
similarity index 93%
rename from sotopia/experimental/agents.py
rename to sotopia/experimental/agents/base_agent.py
index 209fc22d8..a7bbafae6 100644
--- a/sotopia/experimental/agents.py
+++ b/sotopia/experimental/agents/base_agent.py
@@ -1,14 +1,16 @@
 import asyncio
 import sys
 
+
 if sys.version_info < (3, 11):
     from typing_extensions import Self
 else:
     from typing import Self
 
 from typing import Any, AsyncIterator, TypeVar
-from aact import Node
-from aact.messages import DataModel, Message
+
+from aact import Message, Node
+from aact.messages import DataModel
 
 T_agent_observation = TypeVar("T_agent_observation", bound=DataModel)
 T_agent_action = TypeVar("T_agent_action", bound=DataModel)
@@ -51,13 +53,13 @@ async def event_handler(
             await self.observation_queue.put(message.data)
         else:
             raise ValueError(f"Invalid channel: {channel}")
-            yield "", self.output_type()  # unreachable code
+            yield "", self.output_type()
 
     async def send(self, action: T_agent_action) -> None:
         for output_channel, output_channel_type in self.output_channel_types.items():
             await self.r.publish(
                 output_channel,
-                Message[output_channel_type](data=action).model_dump_json(),  # type: ignore[valid-type]
+                Message[output_channel_type](data=action).model_dump_json(),  # type:ignore[valid-type]
             )
 
     async def _task_scheduler(self) -> None: