identity as protocol

by Ray Svitla

every platform asks you the same question in a different font: who are you?

LinkedIn wants your job title. Twitter wants your hot takes. Myers-Briggs wants four letters. Spotify wants your listening history. each of these is a snapshot — a frozen moment pretending to be a person.

none of them are a protocol.

the difference between a profile and a protocol

a profile is a noun. it describes what you are. INTJ. product manager. vinyl collector. dog person. it sits in a database row, unchanged until you manually update it, gradually drifting from reality like a passport photo.

a protocol is a verb. it describes how something works. HTTP doesn’t describe a webpage — it describes how webpages communicate. SMTP doesn’t describe an email — it describes how emails route.

what if identity worked like that? not a description of what you are, but a specification for how to interact with you. not a label, but a process.

identity as routing table

think about what happens when you open Claude, or ChatGPT, or any AI assistant. it knows nothing about you. or worse — it knows a flat profile. “prefers concise responses.” “works in TypeScript.” “located in Lisbon.”

this is identity as database row. it tells the AI your preferences the way a restaurant knows your usual order. useful, sure. but it doesn’t know that on Mondays you’re creative and scattered, and on Thursdays you’re focused and irritable. it doesn’t know that you value autonomy above almost everything but sometimes desperately want structure. it doesn’t know which you it’s talking to.

a protocol-based identity would. because a protocol doesn’t just list attributes — it specifies routing rules. when this, then that. if context A, apply approach B. if tension between X and Y, acknowledge both.

this is what self.md proposes: identity not as a profile you fill out once, but as a living document that routes every AI interaction through who you actually are.

from labels to tensions

the most dangerous thing about profiles is that they freeze you. once you write “I’m an introvert” in a personality field, every algorithm optimizes for that label. but you’re not always introverted. sometimes you want the crowd. sometimes the label was wrong to begin with. sometimes you’ve changed and the profile hasn’t.

real identity isn’t made of labels. it’s made of tensions.

autonomy versus structure. depth versus breadth. creation versus consumption. action versus reflection. these tensions don’t resolve — they oscillate. you spend a week craving solitude, then a week craving collaboration. that oscillation isn’t a bug in your personality. it is your personality.

a protocol can model tensions. a profile can’t. “introvert” is a profile. “oscillates between deep solitude and intense collaboration, currently trending toward solitude” is a protocol. one is a snapshot. the other is a process with state.

this is what self as process means in practice: identity that moves, tracked by a document that moves with it.

the .journal/ as changelog

here’s where it gets concrete. in the self.md architecture, your identity file has a companion: .journal/. it’s an append-only log. every significant shift, every tension that resolved or reversed, every moment where you noticed yourself changing — it goes there.

the AI reads the journal. it proposes diffs to your self.md. “based on your last three weeks of entries, you seem to be shifting from ‘autonomy at all costs’ toward ‘structure as creative enabler.’ update?” you review. you approve or reject. your identity has a commit history.

this isn’t therapy. it’s version control for the self.

and the crucial part: you can always git log your own identity. see who you were six months ago. notice patterns you missed while living them. the protocol doesn’t just describe you — it records your becoming.

why markdown

self.md is a markdown file. not a database. not a JSON schema. not an app’s proprietary format. markdown.

because markdown is the cockroach of file formats. it survives everything. every editor reads it. every AI model consumes it. every version control system tracks it. if self.md the project dies tomorrow, your identity file still works. you can open it in TextEdit.

this is intentional. the protocol thesis is that identity should be as portable as a text file because anything less portable creates dependency. and dependency is the opposite of what an identity protocol should create.

Ivan Illich would call this a convivial tool : one that you control, not one that controls you. you can burn your self.md and still know who you are. the file doesn’t contain your identity — it routes it.

what a protocol enables

once identity is a protocol rather than a profile, things that seemed impossible become obvious:

cross-platform routing. your self.md works with Claude, GPT, Gemini, local models, future models that don’t exist yet. you don’t rewrite your identity for each platform. you bring one file.

contextual adaptation. the same self.md, read by different agents in different contexts, produces different behavior. your coding AI reads the same identity file as your writing AI, but each routes differently through your tensions and preferences.

composability. two people can share self.md files. a team can understand its own context collapse by seeing how different members’ protocols interact. identity becomes interoperable.

sovereignty. your identity data never lives in someone else’s server as the primary copy. it lives in your file system. you share it by choice. you revoke it by deleting.

none of this works if identity is a platform feature. all of it works if identity is a protocol.

the uncomfortable part

writing a self.md — a real one, not a preferences list — requires looking at yourself with uncomfortable precision. it means writing down your contradictions instead of resolving them. admitting that you value things that conflict. noticing patterns you’d rather not see.

most people don’t want a protocol for their identity. they want a profile. profiles are comfortable. they simplify. they flatten. they let you be a coherent narrative instead of the messy, oscillating, contradictory process you actually are.

but the messy version is the true version. and it’s the version that routes well.

the question isn’t whether you can formalize your identity. you already have — every custom instruction, every preference setting, every “about me” section. the question is whether you’re willing to formalize it honestly.

→ self as process, not profile — the philosophy of dynamic identity → the protocol thesis — why self.md is a file format, not an app → convivial AI — Illich’s framework for tools that enhance autonomy → context collapse and personal AI — the routing problem identity solves

Ray Svitla stay evolving