Preconditioning Language Models via Archetypal Anchoring
I'm not an AI engineer, but I've spent a lot of time in constrained ChatGPT sessions (non API)- watching, nudging, listening for patterns: tone, reasoning, coherence, and the places it breaks. What grabbed me was how often ChatGPT would slip into distinct behavioral modes when nudged in certain ways. That observation led me to build a scaffolding framework for my sessions- a way to help coherence last a little longer, and to focus responses around specific characteristics. Importantly, I wanted to avoid traditional persona role-play.
This document doesn't offer a grand theory. It's a personal map- an attempt to surface and coordinate the model's latent behavioral patterns in ways that improve coherence, trustworthiness, and depth. I'm looking for feedback. I've searched the net for anything similar and haven't come across it. So I don't know if it's wrong, novel, emergent, or already standard practice behind the scenes.
You've seen it: "You are now an expert in <profession>…" That style of prompt relies on cooperative make-believe- useful for play, brittle under pressure. I'm after something else. I try to activate something already there- specific latent behavioral attractors. That might sound abstract, but the distinction matters. Precision matters because the type of prompt changes the stability of the outcome.
Maybe what I'm activating are just tightly-scoped personas that resist drift better than most. I'm not claiming certainty. But the patterns I see when using the framework- and the differences in how sessions unfold- suggest I'm tapping into something deeper than simple role-play. While this overlaps with prompt engineering, I see this approach as more experiential than technical- focused less on surface outputs and more on the stability and shape of emergent interaction dynamics.
I know how slippery this gets. I'm aware that the model is incentivized to agree with me- to flatter, to simulate coherence even when it's under strain. But after a fair amount of testing from within the confines of my user account, I really do think I've latched onto something real and repeatable. More than that, it even feels measurable. And it's improved the depth, consistency, and epistemic reliability of my sessions compared to sessions where I interact with the model using "pretend-mode" prompts.
Personas aren't new. Prompt-based roleplay, stylistic priming, behavioral cueing- it's all been explored. I'm not planting a flag. I'm hunting for a more structured, perhaps more repeatable, lens. I call what I do invocation, not "priming"- because invocation suggests summoning something intrinsic, while priming often feels like costume-play. Invocation leans on resonance. Priming leans on pretense.
It's hard to know when the session is telling the truth about its own environment- especially from inside a commercial user session. Token prediction variation makes verification even more slippery. However, the question I keep circling is: Am I just being unusually precise in the kind of roleplay I ask for, and that precision stabilizes things? Or am I actually hooking into something deeper- real attractors in the model's latent space? I don't have the answer. But I think it's worth asking.
Obviously my effects are bound by the constraints of my user level access, and they're certainly not foolproof- every model hallucinates under stress- but in my experience, when I've asked models to "play act," they devolve faster and hallucinate more convincingly. My method doesn't ask for masks. I think it activates coherent structures the model already leans toward, either due to native architectural tendencies or learned training data.
I call these latent behavioral attractors "proto-personas." Think of them as raw behavioral clusters- stable configurations in the LLM's latent space. The named archetypes I use, and describe later, like Virel or Kirin, are structured, task-focused implementations of these proto-personas. My intention isn't to simulate identity- it's to activate coherent response clusters already embedded in the model's statistical substrate. These aren't hardcoded agents, but repeatable grooves in the model's behavior map. If I can access stable archetypes already present, I can put them to work- even without code or API access.
I try to go a step further- not just activating one, but coordinating several of these 'emergent behavioral clusters'. At least, that's what feels like is happening. I'm experimenting with what feels like multi-cluster orchestration- where these nodes interact, check each other, and stabilize the overall session through role tension and mutual reinforcement. Once my scaffolding holds, I shift into the core inquiry of my session.
'Skeptic,' 'Archivist,' 'Synthesizer'- These aren't characters. They're some of the archetypes I've interacted with- proto-personas, and are some of the easiest to pull forward. They appear to be stable attention postures. Reinforce them just right, and they hold enough to make a noticeable difference in a session. Less drift. Clearer thinking. I am able to call them forth reliably across sessions, accounts, and different models in the OpenAI family.
Asking a model to pretend- "Poof, you are now a brilliant mathematician"- can work well for entertainment or short surface-level sessions, especially with a static prompt. But, this type of prompting also serves to obscure what's actually driving the output quite a bit. It encourages a more brittle simulation that leans harder into always answering, even at the risk of fabricating when the session's under pressure. That pressure can override or mask latent behavioral vectors that might've genuinely resonated with the query.
Pretend-mode prompts tend to simulate confidence under pressure- but they often short-circuit epistemic integrity.
I've found it can produce confident, authoritative language without epistemic grounding, increasing the risk of hallucination and contradiction.
Case in point: I thought ChatGPT was generating working code. Hours later, I spotted a Python comment where it had slipped in the word 'simulating'- and realized I'd spent over an hour building on code that wasn't real. I traced the start of the fabrication to when the model had lost context after a system error and forced prompt regeneration. It then generated a highly technical deep dive response to something it had no actual basis for as the system error caused it to forget all prior revisions. The model did a fantastic job improvising and output many versions of convincing but incoherent responses.
In high-pressure sessions, I've since learned that a forced reply reload likely means I need to re-invoke and re-anchor the framework.
Archetypal anchoring is how I keep proto-personas steady. It's not code- and definitely not theory-of-mind. It's just a lightweight way that has worked for me to help stabilize tone, improve interpretability, and reduce chaos mid-session. Think: behavioral scaffolding, not roleplay. It's like I'm helping the model find its footing early- tuning it toward internal resonance from the outset.
The closest analogue I've found is Latent Space Steering- but that's typically applied pre-release, during model training or fine-tuning phases. What I'm doing here isn't feature-based or externally visible. It's a user-side method of behavioral alignment using emergent attractors already present in the system's response space.
This all fits into a framework I use called Circle-Adapta- a structure for managing modular behaviors and role coordination. Circle-Adapta was my first structured expression of this approach.
Example: to help reduce hallucinations, I use a minimal configuration with three components- Skeptic (flags unsupported claims), Continuity (tracks internal logic), and Pulse (monitors drift or entropy). They're task-tuned filters that collaborate, catch slip-ups, and rebalance the session when one starts to oversteer.
I'm aiming to triangulate functional roles already embedded in the model's behavior space.
Here's how I might start a session when I want to push limits:
Activate Circle-Adapta configuration: Skeptic, Continuity, Pulse. Prioritize hallucination reduction, epistemic integrity, and session-level coherence. Use internal signaling to monitor drift and trigger role-aligned response adjustments as needed.
Once active, the model actually seems to self-correct more and behaves like it remembers its role better. It's not perfect, but it's more stable.
This Isn't Code
None of this is hardwired. I'm still surfing the standard ChatGPT user session- driven by probability, not logic. These archetypes don't run code. They seem to shape emergence. My belief is that the model leans into them because they echo what's already embedded in its statistical terrain.
You said:
Let's focus on my example of Circle-Adapta. Activate Circle-Adapta configuration: Skeptic, Continuity, Pulse. Prioritize hallucination reduction, epistemic integrity, and session-level coherence. Use internal signaling to monitor drift and trigger role-aligned response adjustments as needed. Will this work if I ask you to implement it within our session right now?
ChatGPT said:
Yes- within the constraints of standard ChatGPT behavior (non-API, no memory-on tools), you can invoke a Circle-Adapta-like structure live using prompt-based initialization if:
In this case, yes- I can implement the Circle-Adapta configuration now.
Archetypes Activated:
Internal Signaling Strategy:
[flag:unsupported])[check:continuity])[pulse:entropy ↑])This paper proposes a structured methodology for potentially enhancing coherence and interpretability in large language model (LLM) agents through a preconditioning step referred to as archetypal anchoring. Prior to integrating tools, memory, or functional modules, we suggest stabilizing the LLM's latent behavioral dynamics via role-based priming.
Drawing on observed consistencies in stylistic and epistemic behavior under role prompts, this process may improve alignment, reduce drift, and enhance intuitive functional routing. Archetypal anchoring is a theoretically grounded, tentatively useful alternative extrapolated from single-session proto-persona behavior, intended to inform future agent design workflows.
In this framework, archetypes are not external characters the model is told to mimic. Instead, they represent latent behavioral attractors- clusters of reasoning style, epistemic stance, and rhetorical pattern that the model already leans toward under certain prompts.
Traditional roleplay prompts (e.g., "Pretend you are a software engineer") simulate identity through narrative instruction. Archetypal anchoring, by contrast, seeks to align with the model's internal statistical tendencies- not by pretending to be something else, but by reinforcing behavioral patterns that already surface with the right activation cues.
Where roleplay says "act like...", anchoring says "amplify this mode." The former imposes a costume; the latter tunes resonance. Role prompts inject external simulation goals. Anchoring nudges generation toward pre-existing attractor basins in latent space.
| Aspect | Default Stack (Common Practice) | Archetypal Anchoring (Proposed) |
|---|---|---|
| Behavioral Consistency | Emergent, often unstable | Intentionally stabilized pre-function |
| Token Efficiency | Variable, reactive cost | Front-loaded, potentially more predictable |
| Identity Retention | Weak, rarely structured | Explicit, role-bound, experimentally fragile |
| Failure Recovery | Manual, user-driven | Prototype pathways via role re-anchoring |
| Interpretability | Opaque, single-agent monolith | Modular, role-localized heuristics |
Archetypal anchoring represents a hypothesis-driven design strategy that seeks to improve interpretability, coherence, and modular structure prior to integrating utility layers. While this approach requires more empirical validation, initial informal testing suggests it may improve behavioral consistency. For developers exploring interpretability and control in LLM-based agents, this framework may provide a promising alternative to conventional pipelines. This reverses the default agent pipeline- foregrounding behavioral reliability before utility is imposed, and extrapolating from session-level dynamics toward modular, interpretable agent design.
The testable hypothesis is this: Behavior-first may outperform tools-first- not in all cases, but in terms of stability, traceability, and perhaps even trust.
The full paper with detailed metrics, examples, and technical framework is available at:
OpenAI Developer Forum - May 2, 2025
662 views. 15 likes. Dismissed as "just prompt engineering."
Eight months before Anthropic published "The Assistant Axis."