Chatting Up Façade’s AI: 23 Ideas to Talk Your Game Into

Alex J. Champandard on November 5, 2007

Façade, created by Andrew Stern and Michael Mateas in 2005, took the independent games scene by storm with its unique gameplay based on interactive drama. Players find themselves entangled in the high-conflict dissolution of the marriage between Grace and Trip — the game’s protagonists.

Façade is not only a successful attempt at moving beyond traditional branching narrative to create a one-act interactive drama, but it also makes significant inroads towards emotionally interactive characters with believable behaviors. The game made it onto my Top 10 Most Influential AI Games because of it.

Video 1: The official trailer of Façade.

This technical review takes its cue from the many publications of Michael and Andrew, available from the game’s website at (see the references at the bottom of the page). In this article, you’ll learn about the technology and design principles behind this innovative simulation; what to reuse in your game as well as what to avoid.

Procedural Content & Design

The creators of Façade set out create innovative gameplay in multiple areas, which was achieved using the design approaches described in this section.

Grace and Trip Argument

Screenshot 1: Grace and Trip arguing, as usual!

1) Let the Story Unfold Procedurally

The motivating idea behind Façade is that procedural authoring of stories and gameplay, where the player interacts with believable characters to create the story, may lead new genres of interactive entertainment. As Andrew and Michael explain [1]:

“The dream of interactive drama, […] has players interacting with compelling, psychologically complex characters, and through these interactions having a real influence on a dynamically evolving storyline.”

This approach is responsible for the gameplay having an open-ended feeling, yet still being constrained to a story.

2) Don’t Make Story Branches Obvious

In Façade, there are certain points where the story reaches branching points, but they are not presented as such. The main reason is to give the player a sense of freedom [1]:

“We believe that when a player is faced with obvious choice points consisting of a small number of choices, it detracts from the sense of agency; the player feels railroaded into doing what the designer has dictated. Instead, in Façade, the story progression changes in response to many small actions performed by the player throughout the experience.”

In many cases, the players may well follow a path anticipated by the designer, but it’s entirely their choice.

3) Use Story Beats to Guide the Narrative

In an environment where events may vary dramatically based on the player’s actions, how can the game reflect a meaningful story chosen by the designer and portray it as a well-paced narrative? In Façade, this is achieved by using story beats, which represent nuggets of story information delivered by the protagonists.

“A Façade beat is comprised of anywhere from 10 to 100 joint dialog behaviors (JDBs). Each beat itself is a narrative sequencer, responsible for sequencing a subset of its JDBs in response to player interaction.”

In a way, the beat provides a theme for part of the game. For example, these are some of the beats:

  • Introduction — PlayerArrives, TripGreetsPlayer, PlayerEntersTripGetsGrace

  • Arguments — ArgueOverRedecorating, ArgueOverItalyVacation, FixDrinksArgument

  • Fillers — ExplainDatingAnniversary, PhoneCallFromParents, TripReenactsProposal
  • Climax — TransitionToTension2, BlowupCrisis, PostCrisis, TherapyGame, Revelations-Buildup, Revelations

  • Ending — EndingNoRevelations, EndingBothSelfAware, EndingSelfRevelationsOnly

Only one of these beats may be active at any time during the game.

4) Make the Story Affect Behaviors and Emotions

Beats are also accompanied with meta-level behaviors that express how the different characters react emotionally. For example [1]:

“During the first part of the story, Grace and Trip interpret all of the player’s discourse acts in terms of a zero-sum priority, conflict, affinity game that determines whose side Trip and Grace currently believe the player to be on.”

The second part of the game consists more of a therapy game where the player can provide advice to the protagonists to help them out of their tricky situation.

5) Rely on Social Interaction as Core Gameplay

Façade is mainly based on emotional interaction, but it still retains traditional gameplay elements such as increasing scores with low-level mechanics. Of course, there are key differences in practice:

  1. The numeric score in the social game represents the affinity between the character and the player.

  2. Players affect this score indirectly by using natural language discourse, like compliments, criticism, etc.

  3. The score itself is not communicated to the player directly, but drives the performance of the actors implicitly.

These common gameplay elements make it easier for players to understand the mechanisms behind the scenes.

6) Design Self-Absorbed Actors

Having the protagonists in the game be absorbed in their own problems has two advantages:

  • It drives the story world in a specific direction as crafted by the designers.

  • It gives the AI behaviors a way to ignore player input if it’s not understood.

This is how Andrew and Michael put it [1]:

“By design, Grace and Trip are self-absorbed, allowing them to occasionally believably ignore unrecognized or unhandleable player actions. Creating a loose, sparsely plotted story afforded greater local agency, but provided fewer opportunities for global agency.”

7) Drive the Story’s Pace with Multiple Actors

By using multiple actors that coordinate together, it’s much easier to drive the pace of the game and story — particularly if these two characters are self-absorbed:

“It helps to have two tightly-coordinated non-player characters who can believably keep dramatic action happening, in the event that the player stops interacting or acts uncooperatively. In fact, the fast pace of Grace and Trip’s dialog performance discourages lengthy natural language inputs from the player.”

This provides a fallback for the game to remain interesting as a demo if the players fails to make themselves understood.

A Behavior Language (ABL)

The design goals of Façade are achieved using a variation of a behavior tree, based on a believable agent language called Hap. In particular, the ABL supports and encourages concurrent behaviors, and provides mechanisms for synchronizing multiple actors.

Interactive Therapy

Screenshot 2: Interactive therapy game.

8) Don’t Be Afraid of Concurrent Behaviors

An important feature of ABL is the ability to execute behaviors and goals in parallel. This essentially allows the behavior tree to fork control into multiple subtrees, which benefits the designers in the following ways:

  • It allows separate behaviors to combine together emergently for additional realism.

  • It reduces the amount of work needed to model all the behaviors as one large sequence.

On the down side, however, introducing parallelism does change the nature of the problem, and requires the designers to get over a learning curve of how best to implement different features.

9) Coordinate with Joint Goals and Behaviors

To make sure the multiple actors can collaborate together for essential story elements, the ABL supports a construct that lets the underlying engine performs the bulk of the synchronization. There are known as joint goals, as described in [2]:

“When a goal is marked as joint, ABL enforces, in a manner transparent to the programmer, coordinated entry into and exit from the behaviors chosen to accomplish the goal. The keyword joint can be used to modify both goals and behaviors, telling ABL that entry into and exit from the joint behavior should be automatically coordinated with team members.”

This makes it much easier to script dialogs for example, or any scene that requires Grace and Trip to interact together.

10) Open Up the Internal AI Representation

Since the behavior tree is used extensively by multiple behaviors, it may be necessary for some of them to traverse the tree to work out what other behaviors are running, and act accordingly. This is done by supporting introspection:

“ABL gives behaviors reflective access to the current state of the ABT, supporting the authoring of meta-behaviors that match on patterns in the ABT and dynamically modify other running behaviors. Supported ABT modifications include succeeding, failing or suspending a goal or behavior, and modifying the annotations of a subgoal step, such as changing the persistence or priority.”

This functionality is used extensively for meta-behaviors that control the story, and reactive behaviors that interrupt long running processes temporarily.

11) Model Assumptions with Context Conditions

Most behaviors are built with assumptions in mind, and once these are broken, it no longer makes sense to keep trying. In ABL, these assumptions are expressed as context conditions, serving both as pre-conditions and conditions that must be maintained.

The behavior tree is designed to support these efficiently:

“Hap/ABL has a number of mechanisms for writing behaviors that are continuously reactive to the contents of working memory, and thus to sensed changes in the world. The details of sensors, like actions, depend on the specific world and agent body.”

12) Prioritize Behaviors when Necessary

Actors in Façade are built from many interacting behaviors running in parallel. To make it easy to arbitrate between multiple behaviors that are active at the same time, each can be assigned a priority level.

  • The priority of a sub-tree is specified using a keyword and a number in the range [0,100].

  • This priority is used when there are conflicts between different behaviors; low priority behaviors are suspended.

Andrew and Michael established standard values for priorities to make sure that these are always consistent. Assigning a priority is still a rather complex tasks, but the range of a priority value can be determined based on the type of the behavior.

Methodology & Architecture

Screenshot 3:

13) Use a Working Memory

The central point for information storage is a working memory, implemented as a dynamic blackboard. As Andrew and Michael explain in [2]:

“The working memory contains any information the agent needs to keep track of during execution. This information is organized as a collection of working memory elements (WMEs). WMEs are like instances in an object-oriented language; every WME has a type plus some number of typed fields that can take on values. WMEs are also the mechanism by which an agent becomes aware of sensed information. Sensors report information about changes in the world by writing that information into WMEs.”

14) Design Behaviors to be Independent

Since there are so many different types of behaviors, for them to work well together they must be designed to be independent from each other. As Michael and Andrew note:

“For example, while quibbling about their second honeymoon in Italy, or arguing about what type of drinks Trip should serve (affinity game beats, chosen by the drama manager), it is safe to mix in dialog about, for example, sex, or the wedding photo (hot-button game mix-ins, triggered by a player’s reference to their topics).”

These guidelines also apply to the way the voice is recorded. The audio must be applicable to many situations, so it is pronounced as if it was added in to the conversation tangentially.

15) Handle Interplay between Behaviors

A lot of effort for the behaviors in Façade went into the interplay between different behaviors. Specifically, when certain behaviors are interrupted, they resume in a context-sensitive way:

“Each beat goal has a reestablish JDB that gets performed if returning to the beat from a global mix-in (’So, I was going to say, about Italy…’). Mix-in’s themselves can be interrupted by other mix-in’s, but if so, are not repeated as beat goals are.”

Certain behaviors simply resume from the beginning though, as it may not be appropriate to resume in the middle.

16) Create Patterns and Behaviors Manually

Façade’s approach to creating AI is based on an author-intensive approach that requires editing or programming lots of rules. This applies in different parts of the architecture:

  1. In the behavior tree, each of the behaviors are designed and authored manually to fit with the story.

  2. For the natural language system, the templates are also edited manually to make sure that.

By combining strong technology with designer control, it’s much easier to create predictable and believable behaviors.

Natural Language Understanding

Screenshot 4:

17) Remember NLP Is Hard!

Researchers have been working on natural language processing (NLP) for decades now, and it still remains an elusive problem, even when the scope of the game is limited:

“While Façade is a micro-domain, a dramatically-heightened representation of a specific situation, not the whole world, there are still no general theories, techniques or systems which can handle the syntactic, semantic and pragmatic breadth of the language use which occurs in Façade.”

So building a full scale parser for the english language is simply not feasible for games these days!

18) Ignore Syntax, Focus on Meaning

The solution to this problem is to treat parsing as an imperfect process that tries to extract as much information as possible without choking [3]:

“Our approach in Façade it to view the natural language understanding problem as a dialog management problem, focusing on the pragmatic effects of language (what a language utterance does to the world) rather than on the syntax (the form of surface text) or semantics (meaning) of language.”

This is achieved using a rule-based system, as described next.

19) Rely on Pattern Matching

In a sense, the natural language recognition engine in Façade is similar to the AIML technology behind the Alice chatbot. There are, however, notable improvements:

  • There are different kinds of rules for matching text with separate words, contiguous text, regular expressions, etc.

  • The rules are responsible for extracting meaning, rather than expressing a direct response (the ABL does that).

  • Rules are structured in layers and processed incrementally to attempt to extract meaning from the text.

20) Use Idioms to Help Manage Rules

In Façade, the rules for parsing natural language are organized in a specific order, as explained by Andrew and Michael in [3]:

  1. At the low-level, a collection of high salience template rules, recognize generically useful patterns, synonyms, negative words, etc.

  2. The next (lower-salience) tier of rules recognizes idiomatic expressions (e.g. common expressions) and retracts them from the text.

  3. The next tier of rules also uses retraction to cancel out adjacent negative words.

  4. The final tier of rules consists of keyword and combination rules to match general discourse.

This structure is designed to prevent misinterpretations, particularly by retracting words once they have been understood.

21) Make Promiscuous Rules

In a system that’s hand edited, it’s generally beneficial for rules to match a larger scope than necessary. This helps match input from more players, at a cost:

“Template rules tend to be promiscuous, mapping a large number of ungrammatical inputs to discourse acts. Keyword rules, in particular, tend to produce false positives. False positives can be reduced by writing ever more elaborate combination rules (in essence, moving towards full parsing), but at the expense of increasing false negatives (player utterances that should be recognized as a discourse act but aren’t).”

22) Establish Common Meanings

The system in Façade does not understand English in general. It does its best to transforms user input into specific chosen statements that were chosen based on their likelihood and importance for the AI. This includes [3]:

Agree, Disagree, Positive Exclamation, Negative Exclamation, Express Emotion, Thank, Greet, Ally, Oppose, Don’t Understand, Uncertain, Apologize, Praise, Criticize, Flirt, Pacify, Explain, Advice, Refer to Object, Intimate, Goodbye, Inappropriate, System Failure

The system repeatedly applies rules to extract meanings from the player’s input, and builds up understanding incrementally by combining intermediate representations together.

23) Make Interpretation Context-Sensitive

Since the natural language system works from rules, they can be activated or deactivated in different contexts.

“It is within Phase 2 that a stack of discourse contexts is actively maintained and used to determine a context-appropriate response to a given discourse act. Phase 1 only makes use of discourse contexts insofar that different collections of phase 1 rules may be turned on and off in different contexts.”

This mechanism is very powerful, but there aren’t many examples of what it’s used for in Façade. However, it can help implement cognitive resonance; if an AI is in a state where it’s not expecting the player to express something, then those rules can be disabled to prevent understanding problems.


[1] Procedural Authorship: A Case-Study Of the Interactive Drama Façade
Mateas M. and Stern A.
Digital Arts and Culture (DAC), 2005
Download (PDF, 97.7 Kb)
[2] A Behavior Language: Joint Action and Behavioral Idioms
Mateas M. and Stern A.
Life-like Characters: Tools, Affective Functions and Applications
Eds. H. Prendinger and M. Ishizuka
Springer, 2004
Download (PDF, 1.0 Mb)
[3] Natural Language Understanding in Façade: Surface-text Processing
Mateas M. and Stern A.
Technologies for Interactive Digital Storytelling and Entertainment, 2004
Download (PDF, 193 Kb)

Discussion 0 Comments

If you'd like to add a comment or question on this page, simply log-in to the site. You can create an account from the sign-up page if necessary... It takes less than a minute!