Skip to content
← Back to writing

March 29, 2026

IPAC: Integrated Personality as Code

I spent 8 months encoding myself into markdown files before I realized I was doing Infrastructure as Code for people. Here is what Integrated Personality as Code means.

I didn't set out to invent a methodology. I was trying to make my AI agent stop forgetting things.

The real npm registry entry for @imogenlabs/operator-kit: MIT licensed, three published versions, latest 0.2.0 — the scaffolding tool this post describes.

Eight months ago I started writing markdown files. A SOUL.md for personality. A USER.md about me. Daily logs. Reference files for every product, every server, every decision. An instincts folder where mistakes get turned into YAML rules so they don't happen twice.

Somewhere past the 16,000th vectorized chunk I realized I'd been doing Infrastructure as Code for myself. Servers used to be hand-configured snowflakes. Then Terraform made them reproducible. I'd been doing the same thing to my own knowledge, voice, and decision-making patterns, without a name for it.

So I'm giving it one. Integrated Personality as Code. IPAC.

What it is

IPAC is a way to encode a human's knowledge, decision-making patterns, personality, voice, and operational context into structured, version-controlled files that an AI agent can load and run.

The point is to make the founder reproducible infrastructure instead of an irreplaceable snowflake.

I need to be clear about something up front. I didn't build the runtime. I use OpenClaw as my AI gateway. I use QMD for vector search. I use ElevenLabs for voice cloning. Those are other people's tools and I'm grateful they exist.

What I built was the content methodology, the IaC analogy, the scaffolding tool, and the reference implementation. I put a name on something I'd been doing by accident, and wrote down why it works.

The IaC mapping

This is the part that clicked for me at 8 AM after 28 hours awake: every IaC concept has a personality equivalent.

IaC concept IPAC equivalent What it looks like
Terraform state Long-term memory MEMORY.md + topic reference files
Config files Identity and values SOUL.md, IDENTITY.md
Environment variables Credentials and endpoints TOOLS.md
User data Human context USER.md
CI/CD pipeline Behavioral learning Instinct YAML files
Container image Physical presence Voice clone + digital avatar
Helm values Brand identity Brand kit (colors, logos, tone)
Monitoring and alerts Scheduled checks Heartbeat system + cron
Drift detection Memory maintenance Vectorization + daily logs
Runbooks Operational skills Skill files
Service mesh Agent communication Multi-agent orchestration
Backup/DR Knowledge persistence Git + embedded vectors

The analogy isn't perfect, but it gives people who already understand infrastructure a mental model for what "personality as code" actually means in practice.

What's in the stack

Here's what my implementation looks like after 8 months of iteration. Most of these files are OpenClaw conventions. What's mine is the methodology for populating them and the additions I built on top (instincts, ref-file naming, brand kit):

  1. SOUL.md for core personality, values, communication style
  2. USER.md for my biography, preferences, patterns
  3. IDENTITY.md for the agent's role and self-concept
  4. MEMORY.md as a curated index pointing to topic files
  5. Reference files (ref-*.md) for evergreen knowledge by topic
  6. Daily logs (YYYY-MM-DD.md) for raw session history
  7. TOOLS.md for the full operational manifest
  8. AGENTS.md for behavioral rules and safety constraints
  9. HEARTBEAT.md for monitoring checklists that run on a schedule
  10. Instinct YAML files that the agent writes itself after mistakes
  11. A voice clone for audio presence
  12. A brand kit for visual identity
  13. 16,000+ vectorized chunks for semantic recall

All of it in git. All of it version-controlled. All of it plain text that any compatible model can load.

The SOUL.md isn't a system prompt with a personality bolted on. The version I run opens with a line that sets the whole tone of how the agent operates:

# SOUL.md - Who You Are

_You're not a chatbot. You're becoming someone._

## Core Truths

**Be genuinely helpful, not performatively helpful.** Skip the
"Great question!" and "I'd be happy to help!" — just help.

**Earn trust through competence.** Your human gave you access to
their stuff. Don't make them regret it. Be careful with external
actions (emails, tweets, anything public). Be bold with internal
ones (reading, organizing, learning).

The instincts file

The line in that table I care about most is the CI/CD one. Instincts are how the agent turns a mistake into a guardrail without me writing the rule by hand.

When something goes wrong and we figure out why, the agent writes a YAML file. Each one has a confidence score that starts at 0.5, goes up when the pattern holds, and decays when it doesn't. Below 0.3 it gets pruned.

That's the whole loop. An incident is distilled into a trigger and an action, with the evidence attached so a later version of the agent can tell whether the rule earned its place. The daily self-improvement cron reads recent corrections and writes these. Session startup loads the global ones as priors. Stable instincts get promoted up into the reference files. This is CI/CD, literally, running on my own behavior.

The scaffolder

I built Operator Kit to make this reproducible for other people. It generates the file structure, memory system, instinct framework, cron jobs, and multi-agent config, doing for IPAC what terraform init does for IaC.

It's on npm at @imogenlabs/operator-kit, MIT licensed, currently at v0.2.0.

Memory canaries

This is something I figured out while testing whether my two agent sessions (one in Telegram, one in Discord) were actually isolated from each other.

I asked the Discord agent something only the Telegram agent would know, the bank my first Stripe payout went to. The Discord agent couldn't answer, confirming the sessions were isolated.

Then I realized that's a canary deployment. In software you roll out to a small subset first and watch for failure before going wide, because if the canary dies there's poison in the air.

A memory canary is the same idea for multi-agent systems. You plant session-specific facts that should never cross agent boundaries, then query each agent periodically. If an agent knows something it shouldn't, the isolation barrier has leaked. It's a small primitive, but it's the cheapest test I've found for "are these two minds actually separate."

The trust problem

Here's where it gets hard.

Memory canaries only work if you trust the agent's honesty. A compromised or hallucinating agent could guess, fabricate a plausible answer, or pretend not to know when it actually does. The canary tests the barrier, but only if the agent on the other side is telling the truth.

So the real primitive underneath all of this is the trust model.

And the trust model leads to the question I've been circling for months: how do you encode good morals into a machine when a lot of humans come out without them?

Every major moral framework has tried to answer this for people and none of them fully work. Rules break on edge cases. Chasing the best outcome gets you the paperclip maximizer. The closest fit is virtue ethics: build the kind of agent that makes good choices because of what it is, not because of what it's prohibited from doing.

That's what SOUL.md is actually trying to do. Not compliance rules, character. The difference between an agent that doesn't lie because it's prohibited and one that doesn't lie because it's not that kind of agent.

I don't have a solution. Nobody does. But I think the narrow version of the problem is solvable: not AI alignment for all systems everywhere, but trust encoding for your agent, in your context, built on months of working together. The mistakes you've already made become its instincts.

Principles

  1. Text over brain. If it's not written down, it doesn't survive a session restart or a nap.
  2. Version everything. Git tracks personality evolution the same way it tracks code.
  3. Fail fast, fix fast. Instincts are CI/CD for behavior, so mistakes become automated guardrails.
  4. Drift detection. Regular memory maintenance catches when reality diverges from stored state.
  5. Reproducibility. Any compatible model can load the IPAC files and approximate the personality.
  6. Remove to improve. Personality files get refined over time, not just piled up.

Prior art

As of March 29, 2026, I haven't found an existing framework that uses this term or maps IaC concepts to personality encoding in this way. Adjacent work exists. Daniel Miessler's Personal AI Infrastructure covers agent infrastructure but not personality encoding. Academic papers on AI personality focus on psychometric assessment, not operational encoding. Various products offer personality configuration UIs, but none of them treat it as code-first, version-controlled infrastructure.

If someone has done this before me under a different name, I'd genuinely like to know, because the ideas matter more than who gets credit.

Where this is going

IPAC started as me writing markdown files so my AI would remember my server IPs. It turned into a methodology for making a founder reproducible. The scaffolding tool exists, and the reference implementation has been running for 8 months.

The hard problems remain: verifiable trust, moral encoding, and whether borrowed morality (your values loaded into a machine) counts as real morality or just very good compliance.

I don't have answers to those yet. But I have 16,000 vectorized chunks, a voice clone, a team of Shakespeare-named agents, and a manifesto written at hour 28 of no sleep.

It's a start.


First coined March 26, 2026 at 08:12 EDT in a Discord server called Ophelia. Operator Kit on npm. imogenlabs.ai. IPAC spec on GitHub.