Own the model of you.

Own the model of you.

What a personal corpus is, why your own trail is the highest-signal data about you, and what it unlocks once you hold it.

Every platform you touch already keeps a model of you.

Those models are good. They are simply not yours.

The model of you exists. It is just aimed away from you.

Their objective function is someone else's revenue. They predict what you'll click, what you'll buy, what keeps you scrolling, accurately, and on your behalf only by accident.

Four words this whole thing rests on.

Nothing here needs an account, and nothing gets uploaded. The list lives in one folder on your machine and never leaves it.

This flips who owns it, not how it works.

Other companies do this to sell to you. There is no reason the same data can't produce better recommendations, real self-knowledge, and a genuine digital voice, for you.

Your trail is already yours to download.

You don't need every source. The system is built to work with whatever subset you have, and to tell you, honestly, what's thin.

Start with two apps or twelve. The kind an app belongs to is what decides which part of the portrait it feeds.

Longitudinal, not a snapshot.

Years of it. That is what lets the system see eras, drift, and how you changed, instead of only where you are today.

In your own words.

Your sent messages and posts are the only large body of text that is unambiguously your voice, in real contexts, to real people, with real stakes.

That is what makes a credible Communication Signature possible at all. Not a style guess: a register map built from lines you actually wrote.

Unperformed.

The 2 a.m. text, the playlist you'd never share, the search you'd never post. The realest signal is exactly the material that never makes it into a public persona.

Which is also why it stays on your machine. See the privacy section.

The most valuable training set about you in the world is one you can already download.

This is the toolkit for using it yourself.

The same raw signal forks two ways.

Four things become possible.

This only works because it's local.

The whole premise, owning the model instead of renting it from a platform, falls apart the moment the data leaves your machine. No cloud, no telemetry, no exceptions.

A scattered trail becomes memory you can search.

Four steps, and each one hands the next one nothing but the list. Stop wherever you like, a source you never got never breaks anything downstream.

Six messy files in, one tidy list out.

One text message, before and after ingesting.

Four different apps, one entry shape.

Nothing here is clever. It is just consistent, and consistency is what lets one question reach across all four rows at once.

Questions no single platform can answer.

Each of these is one question asked once, against one list. That is the whole payoff of tidying first and interpreting second.

Auditable by construction.

"Not enough signal" is a valid result.

A claim resting on a thin slice gets flagged, never laundered into a finding. State the pattern, show the numbers, give the strongest counter-reading, and name what would kill it.

Longitudinal self-knowledge.

Two portraits from two halves of the same person: the Content Profile is your inputs, the Communication Signature is your outputs. The interesting findings live where they agree, or contradict.

Better agent decisions: Mirror Palace.

Mirror Palace is the cognitive-framework layer, 49 frameworks, ten life domains, six agent archetypes, that teaches an agent how a person works. It needs evidence. personal-corpus is where the evidence comes from.

github.com/TaylorONeal/mirror-palace

None of the right-hand answers require a smarter model. They require the model to have read your list.

Evidence on the left. Advice on the right.

The middle column is the part Mirror Palace supplies. It cannot invent the left column, which is exactly why the corpus comes first.

Two projects, one cycle.

Ordinary project memory helps you finish things. This kind helps you see what you keep doing.

Six hard rules.

Three things, and you probably have two.

You never have to know a command. Every step above is also a plain sentence you can say to the agent.

Two portraits and a substrate.

The Content Profile, the Communication Signature, and the one plain list both are built from.

A local toolkit that turns your data exports into a queryable model of you.

One person, two lenses, one substrate. Keeping the two portraits distinct is the core design idea.

The shape of the system.

Four stages on a shared local database. Stages communicate only through the store, so any stage runs on whatever the previous one produced.

The hard problems are at the edges, not the middle.

A user with two sources and a user with fifteen run the same code.

Eight inputs, any subset.

Goodreads and Reddit CSVs load through the generic csv kind with a column map, no code required.

Four readings of your inputs.

Eleven message and post sources.

Tinted sources are published, they feed the public register and the Content Profile's topics.

Three artifacts.

Inputs and outputs cross-check each other.

The Content Profile is what you take in; the Communication Signature is what you put out. Merged into one portrait, the disagreements disappear, and the disagreements are usually the finding.

The personal-context layer generic AI is missing.

Underneath both portraits: one normalized table of everything, with full-text search and ready-made read helpers.

All four read the same local store. The DB lands at corpus.db in the repo root, git-ignored, never committed.

Three tables.

One flat items table instead of per-source tables: synthesis stays source-agnostic, and partial coverage becomes a non-event rather than a special case.

Buckets decide which portrait an item feeds.

Three buckets is enough to drive the three synthesis dimensions, relationships, voice, interests, and keeps every query simple.

Re-ingest is always safe.

Run it twice, run it wrong, run it again next month, the counts stay honest.

The same text message, arriving twice.

An SMS shows up in the iMessage database and again in the Google Voice export. Two files, two formats, one event.

Without this, every sent-to-received ratio in the profile would be quietly wrong, inflated by whichever platform you happened to export twice.

Five read helpers, straight out of the box.

Shown after every ingest, and read first by profile and analyze, it is the contract between what exists and what may be claimed.

The generic kinds take --source, --bucket, --direction, and a --map of column names, so most tabular exports work without writing code.

Partial coverage is a non-event.

With Instagram DMs and bookmarks alone you can still produce a real profile, you simply scope the claims. Missing a source narrows the reading; it never breaks the pipeline.

The guarantees that make it usable.

The five-stage playbook.

Request, collect, import, profile, analyze. What each step does, and the traps it already knows about.

The pipeline at a glance.

Skills encode judgment. The engine encodes mechanism.

Don't put mechanism in skills or judgment in the engine. Skills are thin; the engine is the substance.

Get your data onto disk, small and parseable.

Each request is recorded in exports/_manifest.json with a rough ETA, so collect knows what to watch for. Partial coverage is fine; the rest of the pipeline adapts.

The customize screen has multiple sections, each with its own "Clear all".

Miss one section and the archive arrives tens of gigabytes larger, days later, mostly media you will never parse.

Four more requests, plus the local copies.

The AI drives the UI up to the auth step and hands off.

It never enters your password, your 2FA code, or your payment information. Nothing in the repo documents or automates anything that would.

What it watches for.

Email links are treated as untrusted input: the sender domain and the link domain both have to match the platform, or the skill stops and asks.

The dispatcher in run_ingest.py is the single source of truth for kinds and flags, docs are verified against the code, never against other docs.

Six rules that don't get relaxed.

What's in the corpus, which dimensions are thin, and which source would add the most next.

It writes two files.

Deterministic where possible: every claim traces to a query, not a vibe.

Coverage first, then five structured pulls.

Five commitments the profile holds.

Five deep dives, on demand.

Four steps, every module, no exceptions.

Rigor, not flattery, and not diagnosis.

Where the findings go: Mirror Palace.

analyze produces cited patterns. Mirror Palace is the framework layer that reasons over them, turning "this is what happened" into domain status, decision support, and an agent that paces itself to you.

github.com/TaylorONeal/mirror-palace

The pitch.

The problem, the wedge, how it sits against the alternatives, and what would move it forward.

AI got good at remembering your projects. It knows nothing about you.

Every assistant starts each conversation from zero on taste, voice, relationships, and history, so it writes in generic assistant prose and recommends the median thing.

The good models of a person are rented, not owned.

The gap is not access to data. It is the absence of tooling between a downloaded archive and something an agent can read.

Export rights plus local compute is enough to build the model yourself.

No API deals, no platform permission, no cloud bill. Seventeen CLI kinds, one schema, and a local SQLite file are the entire dependency list.

Two portraits and a substrate.

Five skills drive it end to end: acquire, collect, ingest, profile, analyze.

Four stages, one contract.

Stages talk only through the store, so a user with two sources and a user with fifteen run identical code.

Four things converged.

Four audiences, in order of urgency.

Positioning against the alternatives.

The nearest comparable is a personal knowledge base, but PKM captures only what you chose to write down. This captures what you actually did.

v0.1 is shipped and smoke-tested.

Engine, skills, and docs are public under MIT, with a plugin manifest so the whole pipeline installs in one step.

Coverage tells you what you have and what's thin. The profile is generated from exactly that, with the caveats stated up top.

The schema is easy to copy. The judgment took the time.

Encoded as skills rather than code, so it improves by being argued with.

Privacy is the architecture, not the policy page.

This is also the product argument: the same guarantees are why a user will hand over a decade of messages at all.

The first consumer is already built: Mirror Palace.

A cognitive-framework toolkit, 49 frameworks, ten life domains, six agent archetypes, that teaches an agent how a person works. It has always needed evidence. This is the evidence layer.

github.com/TaylorONeal/mirror-palace

Next, in order.

Risks, and what absorbs them.

Three things move this forward.