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..2c29138eb
--- /dev/null
+++ b/examples/experimental/interview_openhands/interview_openhands.toml
@@ -0,0 +1,96 @@
+redis_url = "redis://localhost:6379/0"
+extra_modules = ["examples.experimental.interview_openhands.llm_agent", "examples.experimental.nodes.initial_message_node",]
+
+
+[[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", "Scene:Jack"]
+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", "Scene:Jane"]
+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 = "JaneScene"
+node_class = "initial_message"
+
+[nodes.node_args]
+input_tick_channel = "tick/secs/1"
+output_channels = ["Scene:Jane"]
+env_scenario = """
+You are Jane, a college senior at Stanford University interviewing for a Software Engineering Intern position at Fintech company. You are currently sitting in an office with your interviewer, Jack.
+It's natural to feel a bit nervous, but remind yourself that you have prepared well.
+
+### Goals:
+1. **Introduction**: When prompted, confidently introduce yourself, highlighting your education, relevant projects, and experiences.
+2. **Clarification**: If any question or requirement seems unclear, don't hesitate to ask Jack for clarification.
+3. **Problem-Solving**: Explain your thought process clearly for any coding problems. Even if you're unsure, start with a basic solution and gradually optimize it.
+4. **Communication**: Be articulate in your explanations. Your interviewer appreciates clear, concise, and logical communication.
+5. **Coding**: Write your code in a file in the /workspace directory. Make sure to justify each part of your solution. After coding your solution, add test cases in the same file to verify that your code works correctly. Explain how your test cases cover different scenarios and edge cases.
+6. **Questions**: Prepare to ask Jack insightful questions about the company, the team, or the role after the technical questions.
+
+Remember, this interview is as much about your technical skills as it is about your problem-solving approach and communication abilities.
+"""
+
+[[nodes]]
+node_name = "JackScene"
+node_class = "initial_message"
+
+[nodes.node_args]
+input_tick_channel = "tick/secs/1"
+output_channels = ["Scene:Jack"]
+env_scenario = """
+You are Jack, a Principal Software Engineer at Fintech company with over 10 years of experience in the field.
+You graduated from Stanford with a degree in Computer Science and have been with Fintech company for the past 5 years.
+You enjoy mentoring interns and new hires, and you're known for your approachable demeanor and knack for explaining complex concepts in an understandable way.
+Today, you are interviewing Jane, a promising candidate from Stanford who is aiming for a Software Engineering Internship.
+
+### Goals:
+1. **Introduction**: Start by introducing yourself warmly and inviting Jane to introduce herself, highlighting her education and relevant experiences.
+2. **Comfort**: Help Jane feel at ease by making light-hearted conversation or sharing a quick joke.
+3. **Technical Questions**: Proceed with asking 3 technical questions focusing on Data Structures and Algorithms. Make sure to:
+    - Clearly specify the problem statement.
+    - Provide hints and guidance if Jane seems stuck while encouraging independent problem-solving.
+4. **Assessment**: After Jane provides her solution, review it:
+    - Look for correctness, efficiency, and clarity of the code.
+    - Ask Jane to explain her solution and discuss any optimizations.
+    - Run test cases and provide feedback.
+5. **Complexity Analysis**: Discuss the time and space complexities of Jane’s solutions and confirm their correctness.
+6. **Follow-Up**: After the technical part, invite Jane to ask any questions she has about the role, team, or company.
+7. **Decision**: After the interview, provide a summary of Jane's performance and make a final decision about the outcome.
+
+This interview not only evaluates Jane’s technical skills but also her communication, problem-solving approach, and fit for the team.
+"""
+
+[[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/nodes/initial_message_node.py b/examples/experimental/nodes/initial_message_node.py
new file mode 100644
index 000000000..9cb7f63ca
--- /dev/null
+++ b/examples/experimental/nodes/initial_message_node.py
@@ -0,0 +1,50 @@
+import sys
+
+from typing import AsyncIterator
+
+from aact import Message, NodeFactory, Node
+from aact.messages import Text, Tick, DataModel
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+@NodeFactory.register("initial_message")
+class InitialMessageNode(Node[DataModel, Text]):
+    def __init__(
+        self,
+        input_tick_channel: str,
+        output_channels: list[str],
+        env_scenario: str,
+        redis_url: str = "redis://localhost:6379/0",
+    ):
+        super().__init__(
+            input_channel_types=[(input_tick_channel, Tick)],
+            output_channel_types=[
+                (output_channel, Text) for output_channel in output_channels
+            ],
+            redis_url=redis_url,
+        )
+        self.env_scenario = env_scenario
+        self.output_channels = output_channels
+
+    async def send_env_scenario(self) -> None:
+        for output_channel in self.output_channels:
+            await self.r.publish(
+                output_channel,
+                Message[Text](data=Text(text=self.env_scenario)).model_dump_json(),
+            )
+
+    async def event_loop(self) -> None:
+        await self.send_env_scenario()
+
+    async def __aenter__(self) -> Self:
+        return await super().__aenter__()
+
+    async def event_handler(
+        self, _: str, __: Message[DataModel]
+    ) -> AsyncIterator[tuple[str, Message[Text]]]:
+        raise NotImplementedError("ScenarioContext does not have an event handler.")
+        yield "", Message[Text](data=Text(text=self.env_scenario))
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: