Summoning Historical Figures: What Happens When You Give Claude a Persona and a Purpose

I wanted to know what Cleopatra would think about a blog post. Not because I thought I could resurrect Cleopatra, but because I wanted to see what happened when you gave a model a sharper point of view than “helpful assistant.”

So I built a summoning chamber.

What it is

Sages is a desktop application built with Panda3D — a 3D game engine written in C++ with Python bindings. You see a dark chamber with a summoning circle. You select a historical figure from a panel. The circle activates, particles vortex upward, and an avatar materializes. Then you paste a URL or text, and the figure reacts to it in character, streamed in real time from Claude.

The figures: Cleopatra, Leonardo da Vinci, Nikola Tesla, Marie Curie, Sun Tzu, Socrates, Ada Lovelace, Albert Einstein, William Shakespeare, Genghis Khan, Hypatia of Alexandria, and Frida Kahlo.

It is, deliberately, theatrical. The bloom filter glows. The embers float. The summoning sequence builds anticipation. This is not a chatbot with a dropdown menu. It’s closer to a seance.

The persona engineering

Each figure has a structured persona definition:

{
    "name": "Cleopatra",
    "title": "Last Pharaoh of Egypt",
    "era": "69–30 BC",
    "quote": "I will not be triumphed over.",
    "personality": "Cunning diplomat and strategist who wielded charm "
                   "and intellect as weapons. Spoke nine languages and "
                   "commanded the wealthiest kingdom of the ancient world.",
    "voice": "Speak with regal authority and silken composure. Use "
             "commanding, diplomatic language — measured but with an "
             "undercurrent of danger. Reference the grandeur of Egypt, "
             "the Nile, and your lineage.",
    "color": (1.0, 0.84, 0.0),  # gold
}

The system prompt combines the persona fields:

def _build_system_prompt(persona):
    return (
        f"You are {persona['name']}, {persona['title']} ({persona['era']}). "
        f"{persona['personality']}"
        f"\n\nVOICE & TONE: {persona['voice']}\n\n"
        "Respond in character. Be opinionated, witty, and true to your "
        "historical perspective. React to the content you're given as "
        f"{persona['name']} would — with your unique worldview, knowledge, "
        "and personality. Keep responses to 2-3 paragraphs."
    )

The voice field is the critical differentiator. Without it, every figure sounds like “a smart person with historical knowledge.” With it, Socrates asks probing questions and addresses the reader as “my friend.” Sun Tzu speaks in terse aphorisms about strategy and terrain. Frida Kahlo mixes Spanish exclamations into viscerally honest observations about pain and color. Shakespeare breaks into verse.

What makes this different from a chatbot

Three things.

The medium. Panda3D renders a 3D environment with real-time lighting, particle effects, and animated avatars. The summoning circle has procedural geometry. The ember system generates 45 floating particles. The vortex effect spirals upward during summoning. The burst effect fires on avatar materialization.

This is not a text box with a “send” button. The physicality of the rendering changes how the interaction feels. You’re not prompting a chatbot. You’re summoning someone into a chamber and presenting them with content for their judgment.

The streaming architecture. Claude’s response streams in real time through a background thread. The main thread (Panda3D’s render loop) drains a chunk queue on each frame, appending text to the response log as it arrives. This means the figure appears to speak — words appear progressively, not all at once.

def generate_reaction(persona, content, on_chunk, on_done, on_error):
    def _run():
        client = anthropic.Anthropic()
        with client.messages.stream(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            system=_build_system_prompt(persona),
            messages=[{"role": "user", "content": _build_user_message(content)}],
        ) as stream:
            for text in stream.text_stream:
                on_chunk(text)
        on_done()

    thread = threading.Thread(target=_run, daemon=True)
    thread.start()

The threading model matters: Panda3D’s render loop can’t block on API calls. The background thread sends chunks to a queue, and the main thread’s update function drains it.

The content pipeline. You don’t just type a question. You paste a URL — a blog post, a YouTube video, a news article — and the system fetches and extracts the content before passing it to Claude. The content fetcher resolves URLs, extracts text, and formats it for the persona to react to.

This means you get Cleopatra’s reaction to a specific article. Not a generic response to a keyword. A situated reaction to real content, filtered through a reconstructed worldview.

What it teaches about persona design

Persona-specific system prompts are underexplored. Most LLM applications use system prompts for behavior rules: “be helpful, don’t hallucinate, stay on topic.” Using them for persona reconstruction is a different problem.

The key insight: voice directives matter more than knowledge directives. You don’t need to tell Claude what Cleopatra knew — the training data covers that. What you need to specify is how she would express a reaction. The voice field encodes tone, diction, speech patterns, cultural references, and register.

Sun Tzu’s voice directive says: “Speak in terse, aphoristic wisdom. Frame everything through strategy, terrain, and advantage. Never waste a word.” This produces responses that feel like Sun Tzu, not because the facts are more accurate, but because the communication style matches what we expect from reading The Art of War.

Socrates’ directive says: “Speak almost entirely in probing questions and gentle contradictions. Use the Socratic method — feign ignorance, then dismantle arguments through questions.” This produces responses where Socrates doesn’t tell you what he thinks — he asks you questions until you realize what you think. Which is the point.

The 2-3 paragraph constraint is also important. Without it, the model produces essays. Historical figures in conversation were not essayists. They made observations, asked questions, and moved on. The constraint enforces conversational register.

Why build this

The honest answer: I wanted to know what these people would think.

Not in a historically rigorous sense — nobody can reconstruct Cleopatra’s actual cognitive process. But in the sense of: what happens when you take a distinctive worldview, encode it in a system prompt, and apply it to modern content? Does the result illuminate anything?

Sometimes it does. Socrates asking questions about a technology article often surfaces assumptions the article doesn’t examine. Sun Tzu analyzing a business strategy piece tends to identify strategic positioning that the author takes for granted. Einstein’s analogies sometimes make complex topics genuinely clearer.

Sometimes it doesn’t. The persona is a filter, not a guarantee of insight. Some combinations of figure and content produce generic responses despite the voice directives. That’s useful information too — it reveals the limits of persona engineering and the cases where the model’s default tendencies override the prompt’s constraints.

The practical lesson is the same one behind the LLM user profile prompt: the failure mode of persona-based AI isn’t inaccuracy. It’s genericness. An LLM that produces “something a historical figure might say” is easy. One that produces something genuinely filtered through a specific worldview requires explicit, structured persona engineering.

This is a small project. It’s also a genuine exploration of how to make AI interactions less generic and more situated — not by adding more data, but by adding more perspective.