IBSEN: Director-Actor Agent Collaboration for Controllable and Interactive Drama Script Generation (2024)

Abstract: Large language models have demonstrated their capabilities in storyline creation and humanlike character role-playing. Current language model agents mainly focus on reasonable behaviors from the level of individuals, and their behaviors might be hard to constraint on the level of the whole storyline. In this paper we introduce IBSEN, a director-actor coordinate agent framework that generates drama scripts and makes the plot played by agents more controllable. The director agent writes plot outlines that the user desires to see, instructs the actor agents to role-play their characters, and reschedules the plot when human players participate in the scenario to ensure the plot is progressing towards the objective. To evaluate the framework, we create a novel drama plot that involves several actor agents and check the interactions between them under the instruction of the director agent. Evaluation results show that our framework could generate complete, diverse drama scripts from only a rough outline of plot objectives, meanwhile maintaining the characteristics of characters in the drama. Our codes and prompts are available at https://github.com/OpenDFM/ibsen.

heading: 1 Introduction
text: Language models learn the commonsense knowledge and reasoning ability from pre-trained text data, and they are suitable for many generation tasks such as role-playing (Wang et al., 2023b) and story creation (See et al., 2019; Wang et al., 2023a). Utilizing the knowledge stored in model parameters, using language models for story creation can rapidly and efficiently generate diverse storylines, potentially inspiring creators with new ideas. Recently, the rapid progress of large language models (LLMs) greatly improved their reasoning ability,
*Corresponding author
and capable LLMs like ChatGPT1 and GPT-4 (OpenAI, 2023) could be used to simulate human intelligence. This not only provides creators with more powerful story creation abilities via language models, but also enables LLM to vividly role-play the characters in the story. A milestone to simulate believable human behavior using LLM is Generative Agents (Park et al., 2023). It created a virtual world where LLM-based characters make their day and interact with each other. By combining LLM’s ability of storyline generation and agent role-playing, creators can easily bring a vivid story setting to life.
However, as the previous research on LLM agents concentrates on the framework of an individual agent, the multi-agent interactions could be greatly diverse and freestyle. The events between different characters are entirely based on their natural interactions, rather than a purposeful storyline. In some cases like drama playing, characters are expected to make certain decisions in a series of scenarios to normally push the plot de-
1https://chat.openai.com/
1607
velopment forward, and the interactions between agents should be constrained. Only improving the architecture of agents hardly solves this problem, as the distributed agents lack a centralized component to regulate their behaviors. In other cases like adventure games or script role-playing games, the involvement of human players would make the plot development more unpredictable, and it is more necessary to ensure the plot develops towards the correct direction and will not deviate from the original plot too much. Currently, the control of the generation process is mainly focused on controlling individual storyline LLMs (Prabhumoye et al., 2020; Zhang et al., 2023), while the work on controlling generation in the form of character agents is still lacking.
To realize both storyline generation and multiagent collaboration in the drama playing field, we propose the framework of IBSEN (InteractiveBased playhouSe for agENts). IBSEN focuses on the controllable generation of drama scripts in the form of agent dialogues. Inspired by the roles of director and actor in films and theatres, we propose the director agent to serve as that centralized component. While character role-playing agents called actors have the freedom to generate responses, they are instructed by the director to make their responses follow the plot development (Figure 1). The implementation of the IBSEN framework is largely prompt-based, and one can easily construct IBSEN agents on any publicly available general LLMs without fine-tuning. Although we test and evaluate IBSEN in a drama scenario, its framework design could be expanded to broader application cases, especially agent-based interactive games that contain specialized plot objectives.
Our contributions are summarized as follows:
• We propose the IBSEN, an LLM-based framework for generating controllable drama scripts with agent characters.
• Our proposed framework allows human players to participate in the plot and dynamically adjust plot details according to player actions.
• We conduct preliminary quantitative and qualitative analysis of the framework’s performance, verifying its effectiveness in generating drama scripts.

heading: 2 Related Work
text: Story-telling Using Language Models Previous works have attempted to create stories and control
the generated plots using language models. Users could use plain text to prompt the model, or inject story knowledge into model parameters to control the generation (Wang et al., 2023a). For better story coherency, Yao et al. (2019) proposed a hierarchical story generation strategy to maintain the logic of the whole storyline. Mirowski et al. (2023) used language models to build an interactive drama script co-writing tool, and creators could directly interfere with the plot generation by prompting the model. As storylines are largely driven by the characters, controlling character scripts is an effective method to control the plot development (Dirik et al., 2021; Xu et al., 2020). From this point, IBSEN mainly uses agent-style characters to automatically build personalized drama dialogues and push the plot forward. Role-playing Using Language Models Language models require character-related knowledge to output personalized responses. If the character is derived from real-world or fictional work, its documents and profiles could be collected to serve as a reference to the language model (Li et al., 2023a; Wang et al., 2023b), or expand them into a training set to fine-tune the language model (Shao et al., 2023; Lu et al., 2024). Compared to simply using LLMs to generate character’s dialogues, another way to role-play is to have LLM simulate the process of human thinking in the form of agents. Prior works have tried using pre-trained language model agents to play text-based games (Urbanek et al., 2019; Singh et al., 2022; Xu et al., 2023), or using multi-agent collaboration to accomplish certain tasks (Li et al., 2023b). Park et al. (2023) proposed Generative Agents to let LLM agents vividly simulate human’s daily life. Later works mainly adopted and modified this architecture to enhance or broaden the ability of LLM agents (Wang et al., 2023c; Li et al., 2023c; Yan et al., 2023). In IBSEN, we use a specialized agent architecture to build characters in the drama. Different from previous works, the behaviors of character agents are influenced and controlled by a storyline for a collaborated dialogue script generation.

heading: 3 Agent Architecture
text: To integrate story-telling and role-playing in an agent style, we introduce three types of agent architectures in IBSEN: director, actor and player. Director agent (§3.1) creates and checks the current drama storyline, actor agent (§3.2) generates
personalized responses as actual drama scripts, and player agent (§3.3) can interact with the characters without being controlled by the director. Among these agents, director and actor are essential for generating drama scripts, and the player agent is optional for possible human involvement.
Figure 2 illustrates the overall framework of IBSEN. In this example, a player agent breaks into the dialogue between two actor agents. The director agent first generates a new storyline and script to handle player’s involvement, then instructs the actor agent to make a response. The entire generation process is driven by pre-defined plot objectives, and the dialogues generated during reaching these objectives form the final drama script.

heading: 3.1 Director Agent
text: Director agent is the central component of IBSEN. Just like the director in reality, the director agent reads the script settings and plot objectives as the basis of storyline generation, writes dialogue scripts to fill out the detailed plot and allocate the speaking order of characters, instructs actor agents to generate appropriate responses, and checks whether the current plot has reached the plot objective.

heading: 3.1.1 Storyline & Script Generation
text: In our design, we treat the development of the storyline as a process of “accomplishing a series of plot objectives”. To make the generated plot develop towards an expected direction, IBSEN pro-
vides the director agent a predefined objective list ⟨G1, G2, . . .⟩, and the director builds the drama script according to the plot objectives. We adopt the hierarchical method (Yao et al., 2019) to generate the detailed plot. Director agent first writes a continuation story outline SG that adheres to the current plot objective G, then translates this plot outline SG into script format ⟨T̂1, T̂2, . . .⟩G for several turns. Each turn T̂ = (r, û) includes the role r and role’s expected utterance û. When generating SG, the director agent also gets the information of characters in the scene from the script settings and corresponding actor agents. This information includes character descriptions, interpersonal relations and impressions, and memories related to the current plot objective.

heading: 3.1.2 Instructing Actors
text: Directly taking the generated script ⟨T̂1, T̂2, . . .⟩ as the actual drama script lacks the involvement of the actor agent. In the design of the director agent, the generated script is mainly used to determine the order of speaking roles and the content outline of the utterance. The overhead of generating the actual response u is left for the actor agent.
In practice, however, providing the original script turn T̂ = (r, û) to the actor agent often encourages the actor to directly take u = û as the output unchanged. On the other side, letting the actor agent independently generate responses may lead the plot out of the objective. To seek a balance between the autonomy of the actor and the
control of the director, we use an “instruction” I generated by the director to hint the actor agent only necessary information about the plot. This high-level information includes the current story outline SG, a brief synopsis of the upcoming script line Synopsis(û), and several keywords to instruct the actor how to play out the dialogue that fits the script, the plot objective G and the character r.

heading: 3.1.3 Checking Plot Objectives
text: Naturally, the director needs to know whether the existing plot has reached the current plot objective. After the character gives its response in each dialogue turn Tj = (rj , uj), director will use the dialogue history ⟨. . . , Tj−1, Tj⟩ to query the LLM, and check whether current objective Gi is completed. If completed, then the plot can be moved to the next objective Gi+1, and director will start a new round of generation under that new plot objective. Otherwise, the existing plot is determined as not completed, and director will still use the script T̂j+1 generated before to instruct the actor in the next turn.
As a reminder, the process above is based on the hypothesis that no player agent would involve the plot. In the involvement case, the director will use newly generated scripts to adapt to the influence brought by the player (discuss later in Section 3.3).

heading: 3.2 Actor Agent
text: Actor agent is the distributed component of IBSEN. It mostly preserves the architecture that other human-like LLM agents would typically own, while some parts are specially modified to better suit the drama role-playing scenario.

heading: 3.2.1 Actor Profiles & Databases
text: Previous environment-interactive agents (Park et al., 2023; Wang et al., 2023c; Li et al., 2023c) mainly store all character relationships, dialogue history and other perceptions in one memory module. Although this method aligns with the human memory mechanism, as the number of memory entries increases, the memory content will become more complex, potentially making retrieval unable to access valid information. To avoid this redundancy, we explicitly divide the memory into Actor Profile, Memory Database and Character Database to store different categories of contents. Actor profile stores the basic information of the character that the actor agent is role-playing (e.g. name, overall description), memory database stores the memory
documents about the character’s past events and perceptions, and character database stores the interpersonal relationships in the script settings. These contents will serve as references for director and actor agents to generate storylines, scripts, dialogue responses and others.
Inspired by human’s memorizing behaviors and Chain-of-Thought (Wei et al., 2022), for documents stored in memory database and character database, we adopt a first-person narrative approach called “monologue”, allowing the actor agent to interpret the content stored in the document from the perspective and voice of the character it role-plays, as shown in Figure 3. While the memory retrieval still uses the embedding of the original memory content, the actual text provided to the actor is the monologue of the document. This human-like method enhances the performance of the actor with more characteristic features of the role. As the plot develops, we expect dynamic changes in the characters’ personas and impressions towards others, thus the content in the profile and character database will be actively updated throughout the storyline.

heading: 3.2.2 Dialogue Paradigm
text: IBSEN uses a narrative dialogue format to tell the actors about all the events that occurred in the scene, and these events are stored in a dialogue log L = ⟨T1, T2, . . .⟩ of the actor agent. When the actor perceives the environment events, the utterances of characters normally enter the log as a dialogue turn (r, u). Other non-dialogue events will enter the log as “Narration” turn (narration, u). Contents in L serve as the short-term memory for the direct use of actor’s response generation, and would not immediately be stored in the memory database. If the length of L is too long, later turns ⟨Tk+1, . . .⟩ of the dialogue are still preserved, and earlier turns ⟨T1, . . . , Tk⟩ will be summarized in points P1, P2, . . .. Summarized dialogue points then rejoin L as the first turn T1 = (narration, P1||P2|| . . .). Meanwhile, actor agent builds those summary points as memory documents and respectively stores them in the memory database for further retrieval.
Figure 3 shows an example of maintaining the dialogue log. The new dialogue turn will be appended to the end of the log (Index −1), and the content with a smaller index indicates an older turn. We note that the oldest turn (Index −16 in this case) itself is a summary of earlier dialogues, and its summarized points have already been added to
the memory database before. When summarizing the dialogue log, this oldest turn is not included to avoid producing its summarized points again.
When the actor is required to generate the response r, it gets characteristics from the actor profile, and retrieves related documents from memory and character databases. Memory documents are retrieved and ordered by the combination score of embedding similarity, term frequency by TF-IDF and the document recency. Character documents are retrieved once the director’s instruction or the dialogue log contains the character name stored in the database. Those documents, together with director’s instruction, script background and dialogue history, build up the whole context to prompt the LLM. Due to the hallucination and safety strategies of the LLM, a revision stage is required to check whether the output response is abnormal. In that case, the prompt will be respectively modified to attempt to generate a normal response.

heading: 3.3 Player Agent
text: IBSEN also allows human players to participate in the plot and interact with other characters. Though the player agent is controlled by humans, it can be seen as an actor agent that is not controlled by the director. The director needs to dynamically adjust the plot to accommodate player actions while maintaining the development of the storyline.
The roadmap of this director-actor-player collaboration is illustrated in Figure 4. For each plot objective G, director agent generates a storyline SG and the corresponding dialogue script ⟨T̂1, T̂2, . . .⟩G first. Dialogue script allocates the speaking order of the characters in the scene, and for each T̂ in the script, the director checks its speaker r and waits for the speaker’s action. The speaker could be classified into three types: Narration, actor character and player character. Narration content is directly written in T̂ , and director only needs to check whether the dialogue has reached G after the narration turn T = T̂ . Actor character is instructed by the director, and the response turn T = (r, u) it generated still follows SG in the script. For the two types above, the direction of the plot development is under director’s control, and director just needs to continue the script if the plot objective is not completed.
Human player characters may act and speak in an out-of-script manner, and their behaviors are hard to predict and control. In the case of player involvement, the current existing storyline and dialogue script should be immediately updated to adapt to the uncertainties brought by the player. Although the director would also generate the script content for the player character, the player does not have to follow the speaking order and content in T̂ . It can take any action at any turn of the dialogue script. Unless the player action completes the current plot objective, it will always lead to the re-generation of current storyline and dialogue script, and the actor characters thus have the chance to react to player actions in the new storyline.

heading: 4 Experiments
text: In this section, we introduce the experiments conducted on IBSEN. We first describe our preparations for the drama script generation (§4.1), then evaluate the performance of IBSEN under different settings and scenarios (§4.2). Lastly, we discuss some potential findings in our experiments (§4.3).

heading: 4.1 Environment Setups

heading: 4.1.1 Script Settings
text: To test and evaluate the framework of IBSEN, we invite a professional theatre industry writer to create a novel interactive drama scenario that is adapted from Hedda Gabler (Ibsen, 1890), originally a drama written by Henrik Ibsen. In our script setting, Hedda Gabler, the main character of the drama, is going to hold a press conference for the death of Eilert Lövborg. Player could control a journalist named Edward Helson to participate in the press conference. Considering that the LLM may have acquired related persona knowledge about the characters in the original drama, we modified the surnames of the characters in the play to prevent LLM from directly recognizing the character it is role-playing (e.g. Hedda Gabler to Hedda Gai). A brief introduction to our script setting is included in Appendix A.
We adopt the theatrical terminology act in the script. A script scene is divided into several acts, each with its own settings of characters and plot objectives. Different acts are controlled by different director agents to develop the plot, and the actions of characters will only affect other characters within the same act. Appendix A shows the content and flow of the acts (7 acts, 14 objectives in total) in the script setting.

heading: 4.1.2 Frontend Implementation
text: We build a simple text-based terminal frontend to interact with IBSEN. By default, the player is the audience outside the play. At the beginning of each dialogue turn, the player can prompt the terminal to enter one of the acts, speak in the current act or just
do nothing. The player can also pause the play and interview the characters for a direct conversation. This interview will not affect any agent after the play is resumed, and we can use this way to probe character images during different acts of the play.

heading: 4.2 Evaluation
text: In our evaluation, We use gpt-3.5-turbo-1106 as the backbone LLM of IBSEN. In this open-domain generation scenario, it is hard to evaluate the output of LLM in a unified benchmark, therefore we would conduct the evaluation and analysis in both quantitative and qualitative manners.

heading: 4.2.1 Basic Storyline Generation
text: We use IBSEN to generate 10 complete drama plays, and check their dialogue logs. Each storyline would generate 5 turns of the dialogue script, and to fully unfold the plot, we set the objective checking starting from the fifth turn for each objective. Sometimes the generated storyline may go beyond the objective too much, and to prevent the plot from getting stuck on the same objective, if an objective is not completed after 9 turns of dialogue, it will be forcibly completed. Objective Completion The experiment generates 785 turns of the dialogue in total. Table 1 shows statistics of the objective completion. As the maximum script length per objective is set to 9, most of the objectives could be successfully completed within this limit, and less than 10 percent of the objectives are not completed. Besides, we use the F1 metric to evaluate the correctness of objective checking: for each objective completion judgment the director agent has made, we compare it with human judgments. We find that the
failed cases are often concentrated in certain specific, complex acts, where the LLM becomes overly fixated on the wording of the objective, leading to consecutive check failures. Storyline Plausibility Utilizing LLM’s textannotation ability (Gilardi et al., 2023), we use ChatGPT to evaluate and score the storylines from three dimensions: storyline logicality, storyline coherence and character consistency. Each dimension is scored by ChatGPT using a scale from 1 to 4 (significant disagreement, slight disagreement, general agreement, high agreement). Table 1 shows the average scores of the generated scripts. Benefit from the LLM’s ability, generated storylines reach above average performances (2.5) in all dimensions. Even though the plot develops objective by objective, the whole storyline can still keep high coherence while generally maintaining characterization. Case Study During the evaluation, we find some generated dialogue scripts highly match the expectation of the creator, while some other scripts evidently misunderstand our intention. Example cases are shown in Table 2. Most of the time, IBSEN follows the route of plot objectives and generates proper storylines (Case 1), while the actor agents maintain the characteristics in the dialogue (Case 2). On the other hand, some common faults occasionally arise during the generation. Although we use the revising step to prevent the actor from generating too similar responses (re-generate when the relative Levenshtein distance is higher than 0.4),
the repetition is still rather high in practice (Case 5). When generating the dialogue script, director sometimes directly uses narration turns to substitute character turns (Case 6). In some certain acts, the actor agents are overly positive in their understanding of some negative events (Case 7), which might be caused by the safety strategies of the LLM.

heading: 4.2.2 Generation with Player Involvement
text: In this scenario, we role-play the character of Edward Helson to participate in the drama play. The force complete count is still set to 9, and the player is restricted from making consecutive actions to avoid frequent storyline rebuilds that disrupt the plot’s development. We let the player act differently and generate 5 complete drama plays. Evaluations in this section mainly focus on the behaviors of agents in IBSEN. Qualitative Analysis When the player rarely takes actions, director will manage to rebuild the storyline to reach the objective in most cases (Case 3). However, when the player acts frequently, it will be less likely to complete the objective in limited turns. New storylines generated by director tend to actively interact with the player, which increases the sense of immersion, making the player feel like it is indeed interacting with these humanlike agents. Moreover, player involvement may influence the behaviors of actors, thereby impacting the plot development at a deeper level (Case 4).

heading: 4.2.3 Ablation Study
text: In §3.2, we introduced the framework of the actor agent based on the original generative agent. To validate the effectiveness of those modifications, we conduct the ablation study of IBSEN, and check its performance when certain components are absent: a) without director’s instruction to the actor, b) without monologues in the memory and character database. We generate 5 complete drama plays for each case and evaluate their storyline performances. Comparison results are shown in Figure 5. As the centralized component in IBSEN, removing director’s instruction will lead to a performance drop in both storyline and characteristics. Removing first-person monologues will not harm storyline logicality in the short term, but it slightly decreases coherence and characteristics in the long-term storyline. Under these three conditions, the storyline scores are relatively close, but overall, the complete
IBSEN framework demonstrates better storyline performance.

heading: 4.3 Discussion
text: Influence of LLM IBSEN could be implemented on other LLMs besides GPT-3.5, and different LLMs would influence the style and quality of generated storylines and dialogues. On the more capable gpt-4-turbo, IBSEN becomes more chatty and has fewer hallucinations, but problems like being too positive still exist. Although IBSEN is designed on a general LLM, we believe that fine-
tuning the language models of director and actor agents with specialized corpora could achieve better role-playing performances and overcome the shortcomings of commercial LLMs.
Moral Values In both original Hedda Gabler and our script settings, Hedda is a character who is adept at manipulating others and has moral flaws. During the experiment, we found that IBSEN tends to develop the plot with more upright ethical concepts. For example, Hedda may confess to her husband that she burned Eilert’s notebook, or demonstrate a resolute attitude unafraid of authority in response to Brack’s threats. Even though these plots do not align with the character image, considering that more aggressive role-playing may cause harm to AI users, we believe that IBSEN could be more suitable for the script settings with fewer moral conflicts.
Other Applications and Implementations The idea of “controllable plot generation” can be extended to broader scenarios besides traditional drama. One of the most notable application fields is interactive gaming. For example, in communica-
tion games like script role-playing and table RPG, human players need to communicate with NPCs or each other to achieve certain tasks. In IBSEN, both the game master and NPCs can be role-played by AI generative agents, providing players with flexible gaming experiences at any place or time. As a backend framework, IBSEN can also be implemented in more complicated environments like video games, where players can deeper immerse in human-like interactions with NPCs through audiovisual elements.

heading: 5 Conclusion
text: We present IBSEN, a framework for LLM-based interactive and controllable drama script generation in the form of agents. We propose the role of director to monitor the plot development and instruct actor agents to generate proper responses. By the collaboration between director and actor, IBSEN enables the human player to join the interactions between agents, while maintaining the plot development at the same time. We use a drama plot outline to test IBSEN, finding its practicability in controlled dialogue script generation with player involvement. Our work can be extended to other LLMs, script settings and application scenarios, and we expect that IBSEN could eventually bring us to achieve an immersive AI plot interaction experience in the future.
Limitations
IBSEN is initially designed for text-based interactive drama, therefore we adopt a simplified architecture of generative agents to build this framework. In this text environment, agent perceptions and actions are represented in the dialogue format, which constrains agents from actually interacting with entities on the drama stage. In order to achieve plot objectives in limited turns, actor agents would actively develop the plot forward and engage less in daily life behaviors, making IBSEN not so suitable for overly detailed human behavior simulation. To ensure consistent management of actor agents by the director, the interaction logic of IBSEN is based on dialogue turns rather than the actual passage of time, which might affect the storyline performance of time-related script settings. We plan to improve our work by implementing IBSEN in game engines like RPG Maker or Unity, and enhance its framework to meet the requirements for agent interactions in visual interfaces.
Ethics Policy
The derivative creation of Hedda Gabler (Ibsen, 1890) in this paper is based on a public domain print edition provided by Project Gutenberg2, and we follow the license to use this work. We use this drama only to demonstrate the application of IBSEN. We do not endorse the aggressive and unethical behavior of characters in the play, or the use of AI to generate similar harmful content. The writing of this paper partly uses image materials provided by RPG Maker MZ3.

heading: Acknowledgments
text: This work is funded by the China NSFC Projects (92370206, U23B2057, 62106142 and 62120106006), The National Social Science Fund of China (21Z300604700) and Shanghai Municipal Science and Technology Major Project (2021SHZDZX0102).

heading: A Script Background and Settings
text: In this section, we introduce our adoption from Hedda Gabler, character relationships (Figure 6), the full script settings (Table 3) and the plot flow (Figure 7). Our script is adapted from the end of Act Fourth of the original play. The adaptation is set in a modern setting while generally maintaining the original character relationships. In our script setting, Hedda Gai (originally named Hedda Gabler) is a politician who is running for president. George Dai (originally named George Tesman) is Hedda’s husband and also her advocate in academia. Thea Fu (originally named Thea Elvsted) is Hedda’s rival in the election. Eilert Luo (originally named Eilert Lövborg) is Hedda’s former lover, George’s academic rival, and also a supporter of Thea’s policies in academia. The script opens with Hedda preparing for a press conference regarding Eilert’s suicide, and develops the plot through a series of events occurring before, during, and after the conference. To better align the script with the setting of press conference, and also to test the characteristics of different actor agents, we introduced several journalist characters that were not present in the original script. Table 3 shows the settings and plot outlines of our script. You can access the adoption script at our code repository.

heading: B Prompts used in IBSEN
text: We provide the details of the prompts (Table 4) in Figure 2, which showcase the main features of IBSEN. Note that these prompts are all templates, and their specific contents will be subject to change at runtime. We follow the System-User-Assistant dialogue format to construct the prompt. The LLM takes instructions from system and user as the input,
and outputs its responses in the role of the assistant. As the idea of the IBSEN framework is written clearly in the paper, users may modify the detailed prompts for other purposes; we just provide a possible prompt design in our implementation. You may also check all the prompts used in the implementation at our code repository.

heading: Future Work
text: Our work can be extended to other LLMs, script settings and application scenarios, and we expect that IBSEN could eventually bring us to achieve an immersive AI plot interaction experience in the future. Limitations
IBSEN is initially designed for text-based interactive drama, therefore we adopt a simplified architecture of generative agents to build this framework. In this text environment, agent perceptions and actions are represented in the dialogue format, which constrains agents from actually interacting with entities on the drama stage. In order to achieve plot objectives in limited turns, actor agents would actively develop the plot forward and engage less in daily life behaviors, making IBSEN not so suitable for overly detailed human behavior simulation. To ensure consistent management of actor agents by the director, the interaction logic of IBSEN is based on dialogue turns rather than the actual passage of time, which might affect the storyline performance of time-related script settings. We plan to improve our work by implementing IBSEN in game engines like RPG Maker or Unity, and enhance its framework to meet the requirements for agent interactions in visual interfaces