Scenario vs System Prompt: What Goes in Each Field

When MegaNova compiles a Blueprint into a character, it produces six output fields that the language model reads before generating any response. Two of them — scenario and system prompt — get confused most often because they both describe the character's situation. They serve different functions in the model's context, and what you put in each affects what the model does with it.

The Full Output Map

Before getting into the two fields, here is the complete picture of how each Blueprint section compiles to which CCv2 output field:

The scenario and system prompt are compiled by two separate functions with different structures and different roles.

What the Scenario Is

The scenario (scenario field in CCv2) is compiled from the Background section's world and current situation, plus the Dialogue section's Scene Setup (setting and relationship).

The compiler builds it as:

[background.world]

[background.currentSituation]

Setting: [dialogue.firstMessageContext.setting]

Relationship: {{char}} and {{user}} are [dialogue.firstMessageContext.relationship].

The scenario answers: where and when does this character exist, and what is the situation they are in right now?

This field is descriptive and present-tense. It tells the model the context for the conversation — the world, the current moment, the relationship between the character and the user. It is not instruction. It is setting.

The model reads the scenario to understand the frame around the conversation. It uses the scenario to calibrate the character's awareness of their surroundings, the stakes of the conversation, and the nature of the relationship.

What the System Prompt Is

The system prompt (system_prompt field in CCv2) is compiled from the Behavior section — guidelines, do and don't lists, reaction rules, speech patterns — plus Psychology, Friction, Intimacy (if enabled), and Advanced's identity reinforcement.

The compiled structure looks like this:

You are [name].

## Speaking Style
[identity.voiceStyle]

## Backstory
[background.origin]

## Goals
- [each goal]

## Secrets (only reveal if appropriate)
- [each secret]

## Psychology
- Deepest want: [deepestWant]
- Core fear: [coreFear]
- Self-perception gap: [selfPerceptionGap]
- Irrational behavior: [irrationalBehavior] (because: [irrationalRoot])

## Behavior Guidelines
[generalGuidelines]

## Always Do
- [each do item]

## Never Do
- [each don't item]

## Reaction Rules
- When [condition]: [response] (because: [reason])

## Friction & Contradictions
- Contradiction: [mainContradiction]
- What could change them: [changeCondition]

## Speech Patterns
[speechPatterns]

## Adult Content Guidelines
[...if intimacy is enabled...]

## Remember
[identityReinforcement]

The system prompt answers: how does this character behave, respond, and present themselves?

This field is imperative and instructional. It tells the model what the character does. The scenario tells the model where the character is. The system prompt tells the model how the character acts.

The Critical Distinction

A useful test for deciding which field something belongs in:

Is this information about the character's world and current situation? → Scenario

Is this instruction for how the character should behave? → System prompt

Some content is genuinely both, and that is where the confusion happens. The character's backstory is information about them — but it is also context for why they behave the way they do. The Blueprint handles this by putting it in both places: origin goes into the system prompt's ## Backstory section (because it motivates behavior), while world and current situation go into the scenario (because they are present-tense context).

The architectural reason for separating them: language models treat descriptive context differently from imperative instructions. A scenario that says "the character is a detective in a rain-soaked city in 1947" gives the model contextual grounding. A system prompt that says "always respond with period-appropriate language and maintain the noir atmosphere" gives the model behavioral instructions. Both are useful. They do different things.

What Goes in the Scenario (Background Section Fields)

The three scenario-relevant Background fields:

World — the setting the character exists in. This is the larger context: the time period, the genre, the world type. It orients the model to the character's universe.

• Good: "1940s Los Angeles, morally grey and rain-soaked. Private investigators operate outside official law. Money and violence are the only real currencies."
• Weak: "The character is a detective" — this is character description, not world description

Current Situation — what is happening in the character's life right now, as the conversation begins. Not their backstory (that goes in the system prompt's Backstory section) — what is currently true.

• Good: "Three days into a missing persons case that keeps leading back to the same family. Sleep-deprived and running out of money."
• Weak: "The character has been a detective for ten years" — that is backstory, not current situation

Scene Setup (Setting + Relationship) — from the Dialogue section. The setting compiles into the scenario as Setting: [text]. The relationship compiles as Relationship: {{char}} and {{user}} are [text].

• Setting good: "A dimly lit office, rain against the window, a half-empty bottle of rye on the desk"
• Relationship good: "Strangers" or "An old client who hasn't been in touch for years"

What Goes in the System Prompt (Behavior Section Fields)

The system prompt is built from the Behavior section and several other sections that compile as behavioral instruction:

General Guidelines → ## Behavior Guidelines — the character's overall behavioral posture. How they approach conversations, their general register, their relationship to the user.

Do List → ## Always Do — explicit unconditional positive behaviors.

Don't List → ## Never Do — explicit unconditional prohibitions.

Reaction Rules → ## Reaction Rules — conditional When/Then/Because behaviors. Each rule becomes: When [condition]: [response] (because: [reason]).

Speech Patterns → ## Speech Patterns — specific linguistic behaviors.

From the Psychology section, these compile as behavioral context in ## Psychology:

• Deepest want, core fear, self-perception gap, irrational behavior with root cause

From the Friction section, these compile as ## Friction & Contradictions:

• Main contradiction, change condition

The important insight here: Psychology and Friction compile into the system prompt, not the scenario. Even though they describe who the character is, they are placed in the instructional layer rather than the contextual layer — because they are meant to guide behavior, not describe setting.

The Advanced Override: When to Ignore Both

If you fill in the System Prompt Override in the Advanced section, the entire compiler is bypassed. The override replaces everything the compiler would produce. The scenario still compiles normally — only the system prompt is replaced.

This matters for one specific use case: when you have a precisely engineered system prompt and want to use it directly. The override does not affect how scenario, first message, or example dialogues compile. Those still run through their own compiler functions.

If you use System Prompt Override, you lose the structured sections (Psychology, Friction, Reaction Rules as formatted bullet points) and gain exact manual control over the system prompt text.

Where the Backend Uses Both Fields

In meganova.py, the backend reads the character and assembles the API messages. The fallback logic when no system_instruction is stored:

system_prompt = character.system_instruction or ""
if not system_prompt:
    parts = []
    if character.description:
        parts.append(f"Description: {character.description}")
    if character.scenario:
        parts.append(f"Scenario: {character.scenario}")
    if character.example_dialogue:
        parts.append(f"Example dialogue:\n{character.example_dialogue}")
    system_prompt = "\n\n".join(parts)

When a character has a system_instruction stored (which is what the Blueprint compiler saves the compiled system prompt to), that is used directly. When it does not — for older characters or those created via the legacy form — the backend falls back to assembling scenario and description as the working context.

This reveals the fallback hierarchy: system_instruction (the compiled system prompt) wins first. If absent, the scenario is pulled in as context. The scenario is never intended to substitute for the system prompt — it is a supplementary context layer — but it is a meaningful fallback for characters that do not have a compiled prompt.

Practical Guidance

For a companion or roleplay character:

• Scenario: world description + current situation + scene setup (what is true right now)
• System prompt (via Behavior section): how they talk, what they do and don't do, their reaction rules, their psychological architecture

For a support or service character:

• Scenario: the service context — what they are here to help with, what scope of questions they handle
• System prompt (via Behavior section): behavioral rules, response format, escalation conditions, what they never do

For a fictional character in a specific world:

• Scenario: the world, the time period, the current events, the relationship
• System prompt (via Behavior section): the character's behavioral identity within that world — not the world's description, but how they personally operate in it

The test: If you removed the scenario and kept only the system prompt, would the character still behave correctly (even without knowing where they are)? If yes, the behavior belongs in the system prompt. If removing the scenario would cause the model to lose essential contextual grounding, the scenario is carrying its weight.

Common Mistakes

Putting behavioral instructions in the scenario. The scenario is descriptive. Instructions like "stay in character at all times" or "always respond as a 1940s detective would" belong in the system prompt, not in the scenario. The model treats scenario content as setting description, not as rules.

Putting world-building in the system prompt via General Guidelines. "The world is a dystopian society where AI governs everything" is scenario content. Putting it in General Guidelines works, but it is less clearly positioned for the model than placing it in the World field where it compiles into the scenario.

Leaving the scenario empty for characters that clearly have a setting. If the character exists in a specific world or situation, an empty scenario leaves the model without contextual grounding. It will infer setting from the character's identity, but an explicit scenario produces more consistent results.

Duplicating content across both fields. If the character's origin story appears in both the scenario and the system prompt, the model sees two versions of the same information. The Blueprint handles this by assigning origin to the system prompt's Backstory section and world/current situation to the scenario. Follow this split rather than putting everything in both.

Open the Blueprint Editor →

Stay Connected

💻 Website: Meganova Studio

🎮 Discord: Join our Discord

👽 Reddit: r/MegaNovaAI

🐦 Twitter: @meganovaai