emulo

Your real coding-agent sessions already contain the rules you never wrote down: what “done” means, what you reject on sight, how you debug, how you design UI, and how you write when you are actually working.

Emulo mines selected evidence from those sessions — Claude Code, Codex, Copilot CLI, OpenCode, and Google Antigravity logs out of the box — into a private working profile your agent reads before every task. Separate layers for work, design, writing, and video mean the right part of you loads for the right task.

The mined profile loads where your agents already live: Claude Code and Codex natively, Cursor, Gemini, and OpenCode through explicit adapters, and OpenClaw and Hermes Agent as a standard skill (guide).

The Emulo Proof v1 methodology is an unexecuted methodology until a separately approved evidence release exists.

Open source and Emulo Pro

Emulo's local engine stays MIT licensed and useful without an account. Your session extraction, redaction, caches, profile, and agent adapters remain on your machine unless you explicitly choose a model provider for mining.

Emulo Pro is the optional hosted layer for client-encrypted approved-generation continuity across up to five devices, managed pairing and revocation, conflict-preserving history, and a bounded encrypted recovery/export window. Raw session evidence, decryption keys, and model-provider tokens do not enter the hosted service. Ending Pro access never disables local Emulo, its history, or rollback.

The hosted Worker source is public so its authentication, checkout, webhook, and entitlement rules can be audited. Production credentials and customer records are held by Cloudflare and Polar and are never stored in Git. Public source code is not public access to the hosted service or its data.

Profile Build, $300

Mining takes seconds. Deciding which of the mined rules are actually true about you, and cutting the rest, is the part that takes judgment, and it is the part most people never finish.

I do that pass by hand for $300.

You send two files: the you.md your agent drafted, and the receipts.json that emulo verify you.md --json writes on your machine. Nothing else. I never ask for your session logs and I never see them.

Back within three business days:

• the profile rewritten, with every rule whose quote appears in none of your sessions removed rather than softened
• every rule that would be true of any developer removed as well, because a profile full of those makes an agent confidently bland, which is worse than an agent that knows nothing
• what survives restructured into the work, design, write and video layers, so a design opinion never loads into a debugging session
• the exact install lines for the agents you actually use
• a note listing everything I cut, split into "no receipt" and "too generic"

If it does not contain at least three rules you agree with and would never have thought to write down, I refund you and tell you why.

I will not claim this makes your agent better. I restructured evidence you produced, and you will judge whether it helped faster if I have not oversold it.

Paid by invoice or PayPal. This is a service, not a product in the store, so it does not go through the Emulo checkout.

ohadkrispin@gmail.com

Not memory

Memory is what you explicitly told the model.

Emulo mines what your work already proved about you: what you reject, what "done" means, when you ask for proof, how you talk when you're actually working, and the agent behaviors that make you stop the task.

That's why it reads raw session logs, not your CLAUDE.md or rules file.

A real run

One line to the same agent, twice: "help me post emulo on reddit." Once cold, once with the Emulo profile loaded.

Here's how I'd play it.

Subreddits: r/ClaudeAI and r/ChatGPTCoding are your core audience. r/LocalLLaMA fits the local angle. r/cursor, r/SideProject, r/opensource for reach. Don't blast all at once — post to one, tune the title, repost over a few days.

Title: I built a local tool that reads your AI coding logs and writes a "you.md" your agents read before every task

Titles (pick per sub):

• I built a local tool that reads your AI coding logs and writes a "you.md" your agents read before every task
• emulo: mine your own Claude Code history into a profile so your agent codes like you (local, open source)

Body:

Every fresh agent session starts from zero — it doesn't know how you work, so you re-explain yourself every time. All of that is already in your session logs. So I built emulo: it reads your history, mines how you decide and talk, and writes a you.md your agents read before every task.

• runs locally, your logs never leave your machine
• redacts secrets before processing
• open source: [link]

Also: open with the pain not the product, reply fast in the first hour, add a demo gif, and flair it correctly. Want me to write tuned variants for each subreddit?

the insight first: the mining number is your whole post. "i read 1,656 of my own sessions" is a confession, not a pitch, and nobody scrolls past a confession. lead with the mirror, not the mechanism.

one sub, not five — a skills sub, where people come looking for this instead of arguing about it.

Title: I built a Claude skill from 8 months of my own Claude Code sessions

body: I use claude code and codex every day. 8 months, solo. every session gets logged and i never really looked back at them.

then it hit me that those logs are probably the most honest record of how i actually work. not my CLAUDE.md, not my docs, not the rules i remembered to write down. the real sessions.

so i built emulo.

What I did: pulled every message i typed from my local claude/codex logs. stripped tool output, pasted errors, file dumps, and assistant replies. kept only my words. came out to around 1,656 sessions and almost 3M tokens of just me.

then i split it into chunks and had agents read each slice. each one pulled patterns like how i define done, what kind of code i reject, when i ask for proof, what makes me stop a task, and how i talk when i am actually working.

then i merged the repeated traits into one you.md.

the useful part is that it installs as a claude skill. so now instead of starting every task cold, claude reads my profile first and already knows how i work.

not memory exactly. memory is what you told the model. this is more like mining what your work already proved about you.

I posted it on r/ClaudeSkills, as written:

What it finds

The kind of rules a mine pulls out, each backed by dated verbatim receipts from real sessions:

done means it runs live. never trust "done" off a code edit. show it working first.

fix the one thing. rewriting or "cleaning up" code that isn't the problem gets rejected every time.

builds faster than they understand what they built — then asks the agent to explain their own system back.

gets frustrated by repeating the same ask until it lands, not by escalating.

Nobody wrote those rules down. They came out of one person's own history, with receipts.

This is an example. Yours is mined from your logs and will read nothing like it.

The usage report

Mining answers "who is this person." The usage report answers a different question: where are you losing time with the model.

python emulo.py --coach                   # every source it can find
python emulo.py --coach --source claude   # Claude Code only

It runs before any mining, makes no model call, and finishes in seconds. It counts what your own messages already show: asks you sent three times in a row without changing them, context you re-explained after the agent lost it, runs where you rephrased the same request instead of adding the missing constraint, and how often you open a turn by correcting the last answer.

Every finding prints the dated messages behind it. Checks that come in under their bar are printed with their counts as well, so a clean result reads as a result rather than as silence.

It