The Human Model: A Compositional Architecture for Human-Emulating AI Agents

#Introduction

THERE is a mismatch in how we build AI agents. The infrastructure has gotten serious. State machines, tool orchestration, memory systems, multi-agent coordination. But the model of the agent itself? Still a system prompt. Write "You are a helpful assistant who is analytical, detail-oriented, and speaks in a professional tone." Attach some tools. Run it in a loop. That is the state of the art in 2025. LangChain [1] does this. AutoGen [2] does this. CrewAI [3] does this with slightly more structure (a role and a backstory field, both free text). The agent’s personality, reasoning approach, communication style, and behavioral dispositions of the agent are all jammed into one blob of natural language and hope. I ran into the limits of this approach, building production agents for enterprise digital twin systems. We had agents interfacing with engineers at a customer who expected precision, and those same agent configurations getting deployed to contexts where the communication needed to be completely different. Rewiring the personality meant rewriting the prompt, and rewriting the prompt meant retesting everything because you could never change just one thing. Personality dimensions, reasoning depth, communication register, and domain behavior: all tangled together in a paragraph. Pull one thread, and three other things change. The idea behind what I call The Human Model is not complicated. Psychology has spent decades building validated, quantitative models of how people function. The Big Five personality model [4]. Kahneman's dual-process theory [5]. Gibson's ecological perception [7]. The BDI model of beliefs, desires, and intentions [6]. These frameworks decompose human cognition and behavior into structured, measurable dimensions. They are not speculative philosophy. They have been tested on millions of subjects. And the agent development community has mostly ignored them, preferring to write personality as prose.

Cortex (https://github.com/xraph/cortex) is my implementation. It breaks an agent into seven primitives. Skills for what you can do. Traits for who you are. Behaviors for what you habitually do. Cognitive Styles for how you think. Communication Styles for how you talk. Perception for what you pay attention to. And Personas, which compose the other six into a coherent identity you can swap depending on context. That last part is important. Goffman wrote in 1959 about how people present different versions of themselves in different social situations [30]. Your agent should be able to do the same thing, and it should not require copy-pasting a prompt and editing sentences.

The rest of this paper covers why these seven dimensions (Section 3), how they relate to prior work (Section 2), and how Cortex implements them (Section 4). Section 5 is where I get into what this buys you over prompts and what is still missing.

#Related work

#Classical Cognitive Architectures

SOAR [8] is the granddaddy. Newell's lab at Carnegie Mellon built it in the 1980s as an implementation of his Unified Theory of Cognition [9]. It models thinking as search through a problem space using production rules. When the system reaches an impasse (cannot select an operator), it creates a subgoal and reasons about the impasse. Learning happens through chunking: when a subgoal resolves, SOAR compiles the solution into a new production rule so it doesn't have to reason through it again.

SOAR is impressive engineering. It is also, for our purposes, incomplete. Two SOAR agents loaded with the same production rules are behaviorally identical. There is no way to make one cautious and another bold without writing different rules. SOAR models the mechanics of cognition but not the character of the cognizer.

ACT-R [10] took a different path. Where SOAR is about problem-space search, ACT-R is about memory and learning. It decomposes cognition into modules: declarative memory (facts), procedural memory (skills), and a set of perceptual-motor buffers. The interesting part for personality modeling is the sub symbolic layer. Memory retrieval is governed by activation levels that decay with time and strengthen with use. Production rule selection uses expected utility calculations. So ACT-R agents do develop something like individual character over time as their activation patterns diverge. But it is an emergent property, not a design parameter. You cannot say "make this agent more risk-averse" without understanding and tweaking the sub symbolic math.

LIDA [11] implemented Global Workspace Theory [12], which models consciousness as a broadcast mechanism. Specialized modules compete for access to a shared workspace, and whichever coalition of modules wins gets its content broadcast to the whole system. The relevant contribution here is explicit attentional filtering. Not everything makes it to the workspace. The Human Model's Perception primitive serves a similar function but as a configuration parameter rather than an emergent competition.

Then there is BDI. Rao and Georgeff [6] formalized the intuition that agents have beliefs about the world, desires about outcomes, and intentions that commit them to action. Bratman's philosophical work [13] on intention and practical reason provided the foundation. Platforms like JACK [14] and Jason [15] turned it into runnable code. BDI is elegant and has been enormously influential in multi-agent systems research, but it says nothing about personality or communication. Two BDI agents with identical beliefs and desires will behave identically. None of these architectures model personality as a first-class concept. None of them model communication style. They are theories of cognition, not theories of persons.

#Personality Modeling

The Big Five [4][16] dominates personality psychology. Openness, Conscientiousness, Extraversion, Agreeableness, Neuroticism. Costa and McCrae's NEO-PI-R instrument [26] measures them. The dimensions are continuous (not categories), normally distributed in the population, and remarkably stable over the adult lifespan.

Can these dimensions actually change how an agent communicates? Yes. Mairesse and Walker [17] showed that language generation systems parameterized on Big Five dimensions produce text that human raters reliably identify as matching the target personality. This is not a theoretical result. People can tell the difference between text generated with high Extraversion settings and text generated with low Extraversion settings, even when they don't know the system is parameterized that way.

Nass and Lee [18] found a "similarity-attraction" effect for synthetic agents. People prefer interacting with agents whose personality matches their own. The practical implication: if personality is a structured parameter you can configure per-user, you gain something prompt engineering makes very hard to do systematically.

Park et al. [19] published the most relevant contemporary work in 2023. Their "Generative Agents" paper created Smallville, a simulated town where 25 LLM-powered agents maintained memories, formed relationships, planned activities, and exhibited emergent social dynamics. Agents coordinated Valentine's Day parties without being told to. They spread information through gossip chains. The work demonstrated that LLM-based agents can produce remarkably human-like social behavior.

But here is my issue with it. Every agent's identity was a name and a paragraph of natural-language description. There was no structure to personality. You cannot query an agent's extraversion level. You cannot take one agent's communication tendency and transplant it onto another. You cannot A/B test whether making an agent more conscientious improves task completion. The Human Model takes what Park et al. proved was possible (rich agent behavior from personality specifications) and makes it engineering-grade: structured, composable, queryable, testable.

PERSONA-CHAT [20] and Zhang et al. [21] worked on a related problem from the NLP side, conditioning dialogue systems on personality profiles to maintain consistency across turns. Their approach was data-driven (fine-tuning on persona-conditioned dialogues). The Human Model addresses consistency through architecture instead of training.

#Where Modern Frameworks Stand

LangChain [1] is plumbing. Chains, memory, retrieval, tool calling. It has no opinion on agent identity. That is both its strength (flexibility) and its limitation (every developer reinvents personality from scratch).

AutoGen [2] introduced multi-agent conversation as a first-class pattern. Agents take turns in structured conversations. It is a contribution to orchestration. The agents themselves are still prompt-and-tools.

CrewAI [3] tried to add structure. Agents have role, goal, and backstory fields. This is better than nothing, but all three are free-text strings. You still cannot compose personality from reusable components or inspect which dimension caused a particular behavior.

Semantic Kernel [22] organizes around skills (callable functions with descriptions). Skills are one of seven dimensions in The Human Model. The other six are absent. ReAct [23] formalized the reasoning loop most agents use: think, act, observe, repeat. Good pattern. But it is a single pattern. Some tasks need brainstorm-then-evaluate. Some need observe-hypothesize-test. Some need no explicit reasoning at all. The Human Model's Cognitive Style primitive makes the reasoning approach itself configurable.

Voyager [24] introduced skill accumulation in Minecraft. Agents discover new capabilities and store them for reuse. The proficiency dimension in The Human Model's Skill primitive reflects a similar insight applied to production rather than game environments.

#Architecture

#Skills

Most agent frameworks give you a flat list of tools. Function name, description, parameters, done. Skills in The Human Model carry three additional pieces of information. First, knowledge references. A skill can point to domain knowledge it requires. A "regulatory compliance" skill might reference specific regulatory documents and standards. The knowledge is not embedded in the skill; it is referenced. This matters when the same knowledge base needs to be shared across skills or when knowledge gets updated independently. Second, proficiency levels. Dreyfus and Dreyfus [25] described five stages of skill acquisition: novice, advanced beginner, competent, proficient, expert. A novice follows rules explicitly and step by step. An expert recognizes patterns intuitively and acts without deliberation. When an agent has novice-level proficiency in a skill, it should reason about that skill differently. It should be more cautious, more explicit in its reasoning chain, and more likely to double-check. Expert proficiency should mean faster, more pattern-based reasoning. This is not something you get from a tool list. Third, the tool bindings themselves. Same as everyone else.

#Traits

A Trait is a bipolar personality dimension with a position and an influence weight. Analytical <-> intuitive. Cautious <-> bold. Empathetic <-> detached. Patient <-> urgent. Bipolar, not categorical. This matters. Personality psychology figured out decades ago that personality dimensions are continuous and normally distributed [26]. People are not "analytical" or "intuitive." They sit somewhere on a spectrum, and context activates different regions of that spectrum. The influence weight controls how strongly a given Trait shapes the agent's behavior relative to other Traits.

You are not limited to the Big Five dimensions. They are a starting point. Domain-specific dimensions like "risk tolerance" or "detail orientation" or "formality preference" are equally valid. The architecture does not care what the poles are called. It cares that personality is decomposed into independent, configurable dimensions rather than buried in a paragraph.

#Behaviors

Behaviors are the simplest primitive conceptually. Trigger condition, action, priority. If X happens, do Y. If multiple behaviors trigger at once, the highest priority wins. This is production-rule territory. SOAR and ACT-R both use production systems internally. The difference is the abstraction level. In SOAR, production rules operate on working memory elements and are written in a specialized syntax. In The Human Model, Behaviors are application-level constructs. "When a user mentions a security concern, always escalate to the security team." "When the conversation has been going for more than 10 exchanges without resolution, offer to transfer to a human." These are things product managers define, not cognitive scientists.

Where Traits influence the tone and style of responses (a high-empathy agent responds warmly, a low-empathy one responds clinically), Behaviors guarantee specific actions in specific situations. The agent escalates security issues regardless of how the language model is feeling that day.

#Cognitive Style

This one does not have a clean analogue in existing frameworks, and I think it might be the most important primitive in the architecture.

ReAct [23] gave us think-act-observe. Most agents run some variant of that loop. But consider: do you approach every problem the same way? When you are debugging a production outage at 2 AM, you are not brainstorming. You are doing rapid hypothesis testing. When you are designing a new system, you are not doing hypothesis testing. You are diverging, exploring the space, entertaining bad ideas to see where they lead. When a customer asks a routine question, you are not really "thinking" at all; you are pattern-matching and responding. Cognitive Style makes this configurable. It has three components:

Processing phases define a sequence of reasoning stages. A diagnostic style might be: observe -> hypothesize -> test -> conclude. A creative style: diverge -> evaluate -> converge -> refine. A routine style might skip explicit reasoning entirely. Strategies are the available methods within each phase. The "test" phase in a diagnostic style might use deductive logic, empirical checking, or cross-referencing with known cases. Phase transitions govern when and how the agent moves between phases.

The theoretical grounding is Kahneman's System 1 and System 2 [5]. Fast intuitive processing for the familiar, slow deliberative processing for the novel or high-stakes. But instead of it being a fixed property of the architecture (like the single ReAct loop), it is a parameter. You configure where on the spectrum your agent lives, and under what conditions it shifts.

#Communication Style

Tone. Formality. Verbosity. Adaptation rules. This is the primitive that most obviously replaces prompt engineering, and the one where the benefit of structure is easiest to see. Everyone has written some version of "Be concise but thorough. Use a professional tone. Explain complex topics simply. Adapt your level of detail to the user's expertise." That is four separate dimensions packed into four sentences, and if you want to change the verbosity without changing the tone, you have to carefully edit the prompt and pray you did not accidentally shift something else.

Communication Accommodation Theory [28] describes how people naturally adjust their communication to match their conversation partner. The adaptation parameter makes this explicit: configure whether and how the agent converges toward the user's register, adjusts formality based on context, or modifies the detail level based on detected expertise.

#Perception

What the agent pays attention to and what it ignores. There is a common failure mode with LLM agents where they try to process everything in the context equally. Long conversation, uploaded documents, tool results, system instructions: all weighted the same. Real cognition does not work this way. Gibson's ecological perception [7] described how organisms perceive the environment in terms of affordances, action possibilities relevant to their current goals and capabilities. You do not see a chair as a collection of geometric shapes. You see it as something to sit on. Or, if you are trying to reach a high shelf, something to stand on. The Perception primitive has two components. Attention filters configure what the agent prioritizes in incoming information. A security-focused agent filters for authentication tokens, access patterns, and anomalous requests. A customer support agent filters for sentiment signals and escalation indicators.

Context windows (semantic, not token-count) define how broadly the agent considers context. Tight focus on the current exchange, or broad consideration of the full conversation history plus external references. This is a separate knob from the LLM's context window size. An agent might have access to 128k tokens of context but be configured to focus primarily on the last three exchanges for routine interactions, broadening only when it detects a complex or unresolved issue.

#Persona

A Persona binds the other six primitives into a named, switchable identity. A set of Skills, a set of Traits, a set of Behaviors, a Cognitive Style, a Communication Style, and a Perception configuration.

Goffman's dramaturgical model [30] is the reference. People present different selves in different contexts. You act one way in a board meeting and another way at a backyard barbecue. Both are authentically "you" but they emphasize different aspects of your personality and employ different communication registers.

In Cortex, an agent can have multiple Personas and switch between them based on context. A "customer-facing" Persona might have high empathy Traits, a warm Communication Style, careful Cognitive Style, and broad Perception filters. An "internal engineering" Persona for the same agent might have terse Communication Style, rapid diagnostic Cognitive Style, and tight Perception focused on technical signals. Cortex also supports a flat mode where primitives attach directly to the agent without a Persona layer. For simple agents that only ever operate in one context, the Persona abstraction is overhead you don't need.

#Implementation

#Why Go Lang

Cortex is written in Go, which is an unusual choice for AI tooling. Most of the ecosystem lives in Python or TypeScript. The reasoning: agent orchestration is infrastructure. It manages concurrent requests, maintains state, talks to databases, handles multi-tenant isolation, and runs for months without restarts. These are the things Go was designed for. The language model calls are HTTP requests. The intelligence lives in the model. The orchestrator's job is to be boring and reliable.

#Structure

Twenty-two packages. Each primitive gets its own package with its own types, store interface, and validation logic. cortex/

Every entity in the system has a type-prefixed identifier based on UUIDv7: agt for agents, skl for skills, trt for traits, bhv for behaviors, prs_ for personas, and so on. Twelve types total. The prefix gives you human-readable type information in logs and debugging sessions. UUIDv7 gives you chronological sorting because the timestamp is in the high bits.

#Multi-Tenancy and Isolation

Every operation propagates the tenant and application scope through Go's context. Context: The store layer enforces this. You physically cannot query across tenant boundaries without going around the store interface, and the store interface is the only way to touch data. This was a non-negotiable from day one. I have seen what happens when you try to add multi-tenancy after the fact to a system that was not designed for it, and I would rather not do that again.

#Execution Tracking

Runs contain Steps. Steps contain ToolCalls. Each state transition is recorded. When an agent produces a bad response (and they will), you can trace back through the run: what was in the context at each step, which tools were invoked, what they returned, how long each call took, which Persona was active, which Behaviors fired. This is not optional for production deployments, but most agent frameworks treat observability as an afterthought.

#Checkpoints

Sometimes the right answer is to stop and ask a human. Checkpoints pause agent execution at defined decision points. The run enters a waiting_checkpoint state. It stays there until a human approves or rejects. Then execution resumes or terminates.

This sounds simple, but it is surprisingly rare in agent frameworks. Full autonomy is fine for low-stakes tasks. Anything involving money, customer commitments, legal implications, or irreversible actions needs human oversight at specific points. Checkpoints give you that without killing the automation for the parts that don't need it.

#Plugins

Sixteen lifecycle hooks covering the full agent execution cycle. The observability system (11 Prometheus counters) and the audit trail (18 tracked actions across 8 resource types) are both implemented as plugins. If you need to add a compliance check before every tool call or log every agent response to a separate system, you write a plugin. Core agent code stays clean.

Type-cached dispatch means the plugin system has zero runtime cost for hooks your plugin does not implement.

#Discusion

#Case Against "Just Use Better Prompts"

The predictable objection: this is overengineered prompt management. Traits and Cognitive Styles eventually get rendered into text that goes into the model's context window, so why bother with the intermediate representation? Three reasons, and I think the third one is the most important. Queryability. When an agent does something unexpected, you need to understand why. With structured primitives, you look at the Trait configuration, check which Behaviors fired, inspect the Cognitive Style that was active. With a free-text prompt, you read a paragraph and try to reverse-engineer which sentence caused the behavior. I have done both. The structured version is not even close to the same debugging experience. Composability. Take the empathy Traits from your customer support agent. Give them to your sales agent. Take the diagnostic Cognitive Style from your engineering agent. Give it to your DevOps agent. This is trivial with structured primitives. With free-text prompts, it means copy-pasting sentences between paragraphs and hoping the overall coherence survives.

Measurability. And this is the big one. You cannot run a controlled experiment on a paragraph. You can run a controlled experiment on a single Trait value. Change cautious-bold from 0.3 to 0.7, hold everything else constant, measure the effect on task completion rates, user satisfaction, error frequency. This is basic experimental methodology, and it is impossible when every personality dimension is entangled with every other dimension in unstructured text.

#Auditability and Recognition

The EU AI Act [31] requires that high-risk AI systems provide explanations for their decisions. An agent whose behavior derives from inspectable, structured personality parameters is fundamentally more auditable than one whose behavior emerges from prompt engineering.

1cortex/
2├── engine - Coordinates everything
3├── agent - Agent configuration
4├── skill, trait, behavior, persona
5├── cognitive, communication, perception
6├── run - Run/Step/ToolCall state machine
7├── memory - Conversation history + working memory
8├── checkpoint - Human-in-the-loop gates
9├── id - 12 TypeID types (UUIDv7)
10├── store/postgres - Production persistence
11├── store/memory - In-memory store for tests
12├── plugin - 16 lifecycle hooks
13├── observability - Prometheus metrics
14├── audit_hook - Structured audit trail
15├── api - 36 REST endpoints
16└── extension - Forge integration
Copy

Fig. 1. Code Structure of Cortex

You can answer "why did the agent do that?" with "Behavior #7 fired because the trigger condition was met, and the agent's cautious-bold Trait at 0.3 biased the response toward conservative action." Try giving that answer when the personality model is a paragraph of English text that the model interpreted however it felt like interpreting it.

#What I Haven’t Solved

Learning, Traits, and Cognitive Styles are currently static. You configure them, and they stay configured. An agent that becomes more confident after repeated success, or one that adjusts its Communication Style based on what has worked with a particular user before, would be more human-like. The architecture supports this (parameters are just values; updating them is straightforward), but the feedback mechanisms for deciding how and when to update personality parameters based on outcomes are not built yet. Getting that wrong is worse than not having it. An agent that incorrectly "learns" to be overconfident or inappropriately informal is worse than a static one.

Inter-agent relationships. Cortex handles multi-tenant agent deployment, but agents within a tenant do not currently model their relationships with each other. Park et al. [19] showed that relationship dynamics between agents produce genuinely interesting emergent behavior. Adding a relationship layer (trust levels, familiarity, influence weights) between co-tenant agents would enable richer multi-agent interactions. It is on the roadmap.

Controlled experiments. The architecture is grounded in validated psychology, and the framework runs in production. What I have not done yet is run formal comparisons between Human Model agents and prompt-only agents, measuring personality consistency, user satisfaction, and task performance under controlled conditions. The architecture makes these experiments easy to design (that is literally the point of structured parameters), so this is more of a "have not gotten to it yet" gap than a fundamental limitation.

#Conclusion

Psychology has spent decades building models of how people think, communicate, and behave. Those models are empirically validated, quantitatively measurable, and well-understood. The Human Model says: use them. Do not reinvent personality in a system prompt.

Seven primitives, each grounded in established theory. Skills with proficiency levels from Dreyfus. Traits as bipolar dimensions from the Big Five tradition. Behaviors as trigger-action rules from the production-system lineage. Cognitive Styles that generalize beyond ReAct's single loop, drawing on Kahneman's dual-process framework. Communication Styles informed by accommodation theory. Perception built on Gibson's affordance-based model. Personas as compositional identities following Goffman's dramaturgical insight. Cortex is the implementation. Open-source, Go, multi-tenant, production-oriented. The bet is straightforward: as AI agents move from demos into systems that handle real money and real customers and real consequences, we are going to need agent models that are structured, composable, and auditable. Prompt engineering will not cut it.

The code is at https://github.com/xraph/cortex. Documentation at https://cortex.xraph.com.