AI NPCs vs Yarn Spinner, Ink and articy:draft - When to Use Which

"Should we use AI NPCs or a dialogue tool?" is one of the most common questions we hear from narrative teams. It is usually the wrong question. Authored dialogue and AI characters do different jobs, and most games that use AI characters well will use both.

This post compares the two approaches, looks at Yarn Spinner, Ink, articy:draft and Dialogue System for Unity, and shows how to run them side by side in one game.

Authored dialogue vs AI characters

Neither column wins outright. Authored dialogue gives you control: every line is written, reviewed, localised and voiced. AI characters give you coverage: the player can ask anything, and the character answers in voice and in character.

Yarn Spinner vs Ink vs articy:draft vs Dialogue System

Yarn Spinner reads like a screenplay: lines, options and commands in plain text files. Its team has published a post explaining why the product contains no generative AI.

Ink is a markup language for branching, state-heavy stories. It is designed so writers can keep a lot of text in one flowing file, and it is used in many narrative games.

articy:draft X is a visual database for characters, locations, flows and dialogue that exports to engines. Its AI extensions work at design time: one drafts barks, dialogue and preview images through your own OpenAI key, and another generates prototype voice-over through your own ElevenLabs account. The output is still authored content that ships as written.

Dialogue System for Unity is a full conversation and quest framework. Its generative AI add-on is sold separately and helps write, translate and, optionally, generate lines at runtime from player free text, using your own provider keys.

When AI characters are the better fit

An AI character platform like Neocortex works the other way round from these tools. You define who the character is (personality, emotion, knowledge, world and goals) and the character responds to whatever the player says.

That is what you want for:

• Open-ended conversations players can steer.
• Characters who answer questions about your world without you scripting every question.
• Replayable interactions that are different each time.
• Voice input, where players speak instead of picking options.
• Background characters whose lines would never justify a recording session.
• Many characters talking at once: group chat supports up to six in one conversation on the Pro and Team plans.

One town, both systems: a short example

Picture a small fantasy town.

The mayor's scene is the inciting incident. It is written in Yarn Spinner, every line is reviewed, and it is voiced by an actor. It sets a variable, met_mayor, when it ends.

The blacksmith is a Neocortex character. Her Knowledge node holds the town's history and her price list from a TXT file. Her personality is gruff but fair. When the player walks in after meeting the mayor, the game sends that event as context, so she already knows why they are there.

The player asks about the mayor, then about a rumour the writers never scripted, then haggles. She answers all of it in her own voice. A Conversation Flow steers the talk toward one beat: she offers to repair the player's sword. When the player agrees, the reply carries a flowState checkpoint keyword, and the game sets a Yarn variable that opens the next authored scene.

The writers controlled the story. The blacksmith filled the space around it.

What changes for writers

Adding AI characters does not remove writing from the job. It moves it.

From lines to people. Instead of writing every reply, writers define how a character thinks and speaks: temperament, history, opinions, and what they will never say. That is closer to a character bible than to a script.

From branches to knowledge. The lore that used to be spread across dialogue nodes goes into documents the character can draw on. In Neocortex, those are PDF or TXT files attached to the Knowledge node, so updating a fact means editing a document, not a dozen branches.

From playthroughs to conversations. Testing an authored scene means playing every branch. Testing an AI character means talking to it, trying to break it, and adjusting personality and guardrails until it holds. Writers can do that in the browser without a build.

From recording sessions to casting. Each character gets one voice, cloned from a sample you have the rights to or designed from a description, and every generated line uses it.

Authored scenes stay exactly as they were. The writing around them gets a new shape.

Combine them in four steps

1. Keep authored scenes authored. Use Yarn Spinner, Ink, articy or Dialogue System for cutscenes and key story beats.
2. Give the world a voice. Use Neocortex for shopkeepers, companions, quest givers and townsfolk players can talk to freely.
3. Share state. Pass flags and variables from your dialogue tool to Neocortex as context, and let Neocortex actions set flags back.
4. Add structure where it matters. Conversation Flows steer an AI character through a story beat and tell your game when a checkpoint is reached, so free conversation still lands where your story needs it.

Related comparisons

• Dialogue System for Unity with AI vs Neocortex
• Charisma.ai alternative

Where Neocortex fits in a narrative pipeline

Keep your dialogue tool for the scenes that must land exactly as written, and add Neocortex for everything players want to say that you could never script. The visual node editor feels familiar to anyone who has used a dialogue graph, but instead of writing every line, writers shape the character: personality, emotion, knowledge, intents and actions. Everyone on the team can test that character in the browser before it goes into the game, and in-editor testing never uses credits.

Tool details were last checked in October 2026.

Frequently Asked Questions