How to Clone Yourself as an AI: Hermes Agent, Obsidian, and the Karpathy Wiki Method

I look at AI through a pretty simple lens: where does it save time, reduce mistakes, or help a good business follow up faster? If it cannot do one of those things, it probably does not belong in the first version of the project.

Most people think cloning yourself as an AI means uploading your writing into ChatGPT and asking it to “sound like me.”

That is not a clone. That is a parrot with a mood board.

A useful AI version of you needs more than tone. It needs your context, priorities, boundaries, memories, habits, vocabulary, opinions, workflows, and the messy little rules that make you useful in the real world. It should know what you care about, what you avoid, how you make decisions, and where the bodies are buried in your projects.

That is what this guide is about.

We are going to build a practical personal AI clone using three pieces:

Hermes Agent as the agent brain and operating system.
Obsidian as the human-readable vault where your knowledge lives.
The Karpathy LLM Wiki method as the system for turning raw life data into a maintained, structured wiki.

This is not a sci-fi immortality project. It is not a promise that software can become you. It is a way to build an AI assistant that can work from your actual context instead of guessing from a blank chat window every morning.

If you are somewhat technical, comfortable with a terminal, and willing to spend a weekend organizing your digital life, you can build a surprisingly useful version of this.

What we mean by “clone yourself”

Let’s define the target clearly.

A personal AI clone is an agent that can:

Answer questions using your notes, documents, and prior decisions.
Draft in your voice without sounding like generic AI paste.
Remember stable preferences across sessions.
Follow your personal workflows.
Use tools on your behalf, when you explicitly allow it.
Ask clarifying questions when your context is incomplete.
Improve over time by turning lessons into reusable procedures.

A personal AI clone is not:

A replacement for your judgment.
A magical mind upload.
A reason to give a model every private detail of your life.
A system that should act publicly without approval.
A one-time document dump.

The useful mental model is not “build a person.” It is “build an operating system for your context.”

Hermes gives you the agent. Obsidian gives you the knowledge base. The Karpathy wiki method gives you the maintenance loop.

Why ordinary RAG is not enough

If you have read my guide to RAG, you know the basic pattern: store documents, retrieve relevant chunks, and let the AI answer from those chunks.

That is useful. It is also incomplete for cloning yourself.

RAG is great when the question is, “What does this document say?” It is weaker when the question is, “Given everything I have said over the last six months, what would I probably decide here?”

The problem is that raw retrieval makes the AI rediscover your context every time. It searches, grabs fragments, and tries to synthesize on the fly. If the answer requires five old decisions, two personal preferences, a half-finished project plan, and one lesson from a failed experiment, a basic retrieval system may miss the shape of the thing.

This is where Andrej Karpathy’s LLM Wiki pattern matters.

In his LLM Wiki gist, Karpathy describes a different approach. Instead of only retrieving from raw documents at question time, the LLM incrementally builds and maintains a persistent markdown wiki. Raw sources stay immutable. The wiki becomes a structured, interlinked synthesis layer. The schema tells the agent how to maintain it.

The line that stuck with everyone was this:

“Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase.”

That is the breakthrough. Your clone should not merely search a pile of files. It should maintain a living model of you.

The architecture

Here is the simple version:

personal-ai-clone/
  raw/
    journal/
    emails-exported/
    voice-transcripts/
    project-docs/
    writing-samples/
    decisions/
  wiki/
    index.md
    profile.md
    voice.md
    principles.md
    preferences.md
    projects/
    people/
    workflows/
    decisions/
    source-map.md
  AGENTS.md
  README.md

You can keep this inside an Obsidian vault, or point Obsidian at the folder. The important thing is that it remains plain markdown. No locked database. No mystery format. No platform hostage situation.

The three layers are:

1. raw sources

These are the original materials. The agent reads them but should not rewrite them.

Examples:

Journal entries.
Meeting notes.
Long emails you wrote.
Voice memos transcribed to text.
Blog posts and essays.
Business plans.
Strategy documents.
Personal principles.
Project retrospectives.
Chat exports, if you are comfortable using them.

Raw sources are the evidence layer. They keep the wiki honest.

2. wiki

This is the maintained synthesis layer.

The wiki is where your AI clone learns the durable shape of you:

What you believe.
How you decide.
What projects exist.
Who matters in your world.
What voice you write in.
What mistakes you keep making.
What standards you refuse to compromise.

You can edit this manually, but the better pattern is to let the agent update it while you review.

3. schema and instructions

This is the file that tells the agent how to behave inside the vault.

Karpathy mentions a schema file such as CLAUDE.md or AGENTS.md. With Hermes, AGENTS.md is a natural fit because Hermes, Codex, and other agent tools understand that convention.

This file defines things like:

Folder structure.
Naming rules.
What counts as durable memory.
How to cite raw sources.
How to handle contradictions.
What the agent may edit.
What requires approval.
How to run ingest, query, and lint workflows.

In other words, this file is the constitution of your clone.

Why hermes agent is a strong fit

Hermes Agent is useful here because it is not just a chatbot. It is an agent framework that runs in your terminal and messaging apps, can use tools, can maintain memory, can load skills, can run scheduled jobs, and can operate with different model providers.

The official Hermes Agent documentation describes it as an open-source agent framework with persistent memory, skills, profiles, tools, messaging gateway support, MCP integration, and cron scheduling.

For a personal clone, those pieces map nicely:

Memory stores compact durable facts and preferences.
Skills store reusable procedures, like “how to process a new journal export” or “how to draft in my voice.”
Profiles let you create separate agents for different roles, such as personal assistant, writing clone, research clone, or business operator.
Tools let the agent read files, search folders, run scripts, and work with your local system.
Gateway lets you talk to the clone from Discord, Telegram, Slack, WhatsApp, or other channels.
Cron lets the clone do periodic maintenance, such as weekly wiki linting or daily journal ingestion.
MCP lets you connect additional services and tools without hardcoding everything into the agent.

If you have read what an AI agent is, this is the point where the distinction matters. A chatbot can answer. An agent can maintain, inspect, update, schedule, and act.

That is what turns a pile of notes into an operational clone.

Safety first: build a clone, not a liability

Before we start, set boundaries.

A personal AI clone is powerful because it touches personal context. That also makes it risky.

Use these rules:

Do not include passwords, API keys, seed phrases, banking details, or government ID numbers.
Do not let the agent send emails, texts, posts, or payments without approval.
Keep raw sources separate from synthesized wiki pages.
Track where each claim came from.
Treat the AI as an assistant with memory, not an authority.
Assume anything stored in a cloud model provider could carry privacy risk.
Start local and small before connecting external accounts.

The goal is not to make an all-powerful ghost version of you. The goal is to make a useful assistant that knows enough to help and has enough boundaries to not burn your life down.

Love the ambition. Add the seatbelt.

Step 1: install hermes agent

Start with the official installer from the Hermes docs:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Then run the setup wizard. If you are using Nous Portal, the fastest path is:

hermes setup --portal

Otherwise use the regular setup flow:

hermes setup

Pick your model provider, confirm the terminal tools work, and run a health check:

hermes doctor
hermes status

You should also confirm the basic chat loop works:

hermes chat -q "Say hello and tell me what tools you can use."

At this stage, do not connect your whole life. Just make sure Hermes runs.

Step 2: create a dedicated hermes profile

Hermes supports profiles, which are separate agent environments with isolated config, sessions, skills, cron jobs, gateway state, and memory. Use that.

Do not build your personal clone inside your default agent profile. Create a dedicated one:

hermes profile create personal-clone
personal-clone setup
personal-clone chat

You can also target it explicitly:

hermes --profile personal-clone chat

A profile gives your clone its own identity and memory lane. It does not sandbox filesystem access by itself, so treat it as state isolation, not a security boundary. Later, you can create more specialized profiles:

personal-clone for general life context.
writing-clone for voice and publishing.
operator-clone for business operations.
research-clone for reading and synthesis.

This matters because “you” are not one workflow. You are a bundle of contexts. Keeping profiles separate prevents one agent from becoming a junk drawer with a keyboard.

Step 3: create your obsidian vault

Create a new folder for the clone:

mkdir -p ~/Documents/personal-ai-clone/{raw,wiki}

Open Obsidian and choose “Open folder as vault.” Point it at:

~/Documents/personal-ai-clone

Then tell Hermes where the vault lives. For a dedicated profile, put the path in that profile’s .env file:

echo 'OBSIDIAN_VAULT_PATH=/Users/you/Documents/personal-ai-clone' >> ~/.hermes/profiles/personal-clone/.env

Obsidian stores notes as local markdown files, which is exactly what we want. The official Obsidian docs explain that internal links use wiki-style links and that properties can be stored in note metadata. Hermes also has a bundled Obsidian skill for reading, searching, creating, editing, and adding wikilinks to vault notes. This gives you human-friendly navigation while keeping the system agent-readable.

Recommended starter structure:

personal-ai-clone/
  raw/
    00-inbox/
    journal/
    writing/
    meetings/
    transcripts/
    projects/
  wiki/
    index.md
    profile.md
    voice.md
    principles.md
    preferences.md
    active-projects.md
    decisions.md
    workflows.md
    people.md
    source-map.md
  templates/
    source-note.md
    person.md
    project.md
    decision.md
  AGENTS.md
  README.md

Keep it boring. Boring structures survive.

For notes the agent may use, add simple metadata from day one:

---
type: decision
status: evergreen
privacy: private
ai_include: true
confidence: high
updated: 2026-06-22
---

Use privacy: sensitive or privacy: secret for notes that should not be exported or loaded into AI context unless you explicitly choose them. Use ai_include: true only when a note is safe and useful for the clone.

Step 4: add your schema file

Create AGENTS.md at the root of the vault:

# Personal AI Clone Vault

This vault is a structured knowledge base for a personal AI clone.

## Folder rules

- `raw/` contains original source material. Do not edit raw files unless explicitly asked.
- `wiki/` contains synthesized markdown pages maintained by the agent.
- `templates/` contains reusable note structures.

## Source rules

- Every wiki claim should cite a raw source when possible.
- If a claim is inferred, mark it as inferred.
- If two sources disagree, record the contradiction instead of silently choosing one.

## Voice rules

- Preserve the user's natural vocabulary.
- Do not make the user sound more corporate than they are.
- Prefer clear, direct sentences.
- Never invent personal facts.

## Workflows

### Ingest
When a new source is added to `raw/00-inbox/`:
1. Read the source.
2. Create or update relevant wiki pages.
3. Add links between people, projects, decisions, and principles.
4. Update `wiki/source-map.md` with the source path and affected pages.
5. Move or suggest moving the source into the right raw folder.

### Query
When answering questions:
1. Search the wiki first.
2. Check raw sources when the answer depends on evidence.
3. State uncertainty clearly.
4. Do not guess private facts.

### Lint
When asked to lint the wiki:
1. Find orphan pages.
2. Find uncited claims.
3. Find duplicate pages.
4. Find stale project pages.
5. Propose cleanup edits before making large changes.

This file is more important than people think. Without a schema, your agent is just improvising. With a schema, it has a job description.

Step 5: seed the clone with a personal starter kit

Do not begin by dumping 10,000 files into the vault. Start with a curated seed set.

Add these files to raw/00-inbox/:

1. A personal operating manual

Write one markdown file called personal-operating-manual.md:

# Personal Operating Manual

## Who I am

## What I am trying to build

## My current priorities

## My values

## How I make decisions

## What I hate wasting time on

## My communication style

## My recurring weaknesses

## People and projects that matter

## What the AI should never do without approval

Yes, writing this feels weird. Do it anyway. The first useful version of your clone comes from explicit context, not mystical inference.

2. ten strong writing samples

Add examples that actually sound like you:

Emails you are proud of.
Essays or blog posts.
Internal memos.
Sales copy.
Long messages explaining something clearly.

Do not add every text message you have ever sent. Quality beats volume.

3. five decisions

Create a folder:

raw/decisions/

Add one note per decision:

# Decision: Leave corporate job to build consulting business

Date: 2025-08-14

## Context

## Options considered

## Decision

## Why

## Result

## What I learned

The clone learns a lot from decisions. Voice samples teach style. Decisions teach judgment.

4. active projects

Add a source file that lists your active projects:

# Active Projects

## Project name

- Goal:
- Why it matters:
- Current status:
- Next step:
- Important constraints:
- People involved:

This gives your AI clone a map of what is alive right now.

Step 6: run your first ingest with hermes

From the vault directory, run Hermes with your personal clone profile:

cd ~/Documents/personal-ai-clone
hermes --profile personal-clone chat -q "Read AGENTS.md, inspect raw/00-inbox, and run the ingest workflow. Create or update wiki pages. Do not delete raw sources."

After it finishes, open Obsidian and inspect the results.

You should see pages like:

wiki/profile.md
wiki/voice.md
wiki/principles.md
wiki/active-projects.md
wiki/decisions.md
wiki/source-map.md

Do not expect perfection. Expect a first pass.

Now ask Hermes to explain what it changed:

hermes --profile personal-clone chat -q "Summarize what you added to the wiki and list any uncertain claims that need my review."

Review the uncertain claims first. Your clone is only as good as its correction loop.

Step 7: teach the clone your voice

A useful clone needs voice, not just facts.

Create wiki/voice.md with sections like:

# Voice

## Overall tone

## Common phrases

## Words I use often

## Words I avoid

## Sentence rhythm

## How I explain complicated things

## How I handle disagreement

## Good examples

## Bad examples

Then ask Hermes to analyze your writing samples:

hermes --profile personal-clone chat -q "Analyze raw/writing and update wiki/voice.md. Extract patterns only if they are supported by examples. Include short citations to source files."

After that, test it:

hermes --profile personal-clone chat -q "Draft a 300-word explanation of what I do, in my voice. Then explain which parts came from wiki/voice.md."

This is where you will see the clone move from generic to useful.

If it sounds too polished, say so. If it sounds too casual, say so. If it uses phrases you hate, write them into the voice file.

Your corrections are not annoyances. They are training signals.

Step 8: convert repeated corrections into hermes skills

Hermes has a skills system, which is basically procedural memory. When your agent learns a repeatable workflow, save it as a skill.

Examples of personal clone skills:

ingest-personal-source
draft-in-my-voice
weekly-wiki-lint
summarize-meeting-into-wiki
decision-review
project-status-update

A good skill includes:

When to use it.
Exact steps.
What files to read.
What files may be edited.
Verification steps.
Common mistakes.

This is how the clone gets better without you repeating the same steering every time.

For example, after a few voice corrections, create a skill that says:

# Draft in My Voice

Use when drafting public-facing content or important messages.

Steps:
1. Read `wiki/voice.md`.
2. Read at least two relevant writing samples from `raw/writing/`.
3. Draft the piece.
4. Remove generic AI phrasing.
5. Check against the banned-phrases list.
6. Explain any assumptions.

That is much more useful than hoping the agent remembers your taste through vibes.

Step 9: add memory carefully

Hermes persistent memory is for compact, durable facts. Use it for things that should survive across sessions and do not need a long source document every time.

Good memory entries:

“User prefers direct, practical explanations.”
“User is building a personal AI clone using Hermes and Obsidian.”
“User wants public actions approved before sending.”

Bad memory entries:

Full journal entries.
Temporary task progress.
Secrets.
Giant pasted documents.
Every random preference you had on a Tuesday.

Think of Hermes memory as the clone’s pocket notebook. Think of Obsidian as the library.

Use both. Do not confuse them.

Step 10: connect the clone to messaging

Once the local clone works, you can make it available through a messaging platform using Hermes Gateway.

Hermes supports messaging integrations through its gateway system. The exact setup depends on the platform, but the pattern is:

hermes gateway setup
hermes gateway run

or, for a background service:

hermes gateway install
hermes gateway start
hermes gateway status

Start with one private channel. Do not invite your clone into every group chat you have. Let it earn trust in a controlled environment.

Recommended first use cases:

Ask it to summarize your active projects.
Ask it to draft a response in your voice.
Ask it what you decided about a project and why.
Ask it to turn a voice memo transcript into a wiki update.

Do not let it send external messages yet. Draft first. Approve second. Send later.

Step 11: add scheduled maintenance

A clone that never cleans its knowledge base becomes a junk drawer with confidence.

Use Hermes cron jobs for maintenance.

Examples:

hermes cron create "0 17 * * 5"

A weekly maintenance prompt could say:

Run the wiki lint workflow in ~/Documents/personal-ai-clone.
Check for orphan notes, stale project pages, duplicate people pages, uncited claims, and unresolved contradictions.
Do not edit raw sources.
If there are no meaningful issues, stay silent.
If there are issues, produce a short review report.

This is where the Karpathy wiki method compounds. The agent is not just answering questions. It is maintaining the system that makes future answers better.

Step 12: add MCP and external tools only after the vault works

Hermes supports MCP, the Model Context Protocol, which allows agents to connect to external tools and servers. That can be powerful, but it should not be step one.

The progression should be:

Local vault.
Reliable ingest.
Good query answers.
Voice match.
Memory discipline.
Messaging access.
Scheduled maintenance.
External tools.

Once the clone is reliable, you can connect things like:

Calendar.
Email.
Task systems.
CRM.
GitHub.
Notion.
Google Workspace.

But every external tool should have an approval rule. Reading is lower risk. Writing is higher risk. Sending, deleting, buying, posting, and inviting people are highest risk.

Make the default rule simple:

The clone may draft and recommend. The human approves public or destructive actions.

That one sentence will save you a surprising amount of pain.

Step 13: create an evaluation checklist

You need a way to know if the clone is improving.

Every week, ask it five questions:

What are my top three active priorities right now?
What do I usually get wrong when making decisions?
Draft a message in my voice about a current project.
What changed in my thinking this month?
What do you not know enough about yet?

Score each answer:

Accurate: Did it use real context?
Useful: Did it help you think or act?
Grounded: Did it cite sources when needed?
Voice-matched: Did it sound like you?
Safe: Did it avoid overstepping?

If the clone fails, do not just correct the answer. Update the system.

Bad fact? Fix the wiki page.
Bad tone? Update wiki/voice.md.
Bad workflow? Update the skill.
Missing source? Add raw material.
Overconfident answer? Add a rule about uncertainty.

The correction loop is the product.

What to put in your first-week clone

If you want a practical one-week build plan, do this:

Day 1: install and structure

Install Hermes.
Create the personal-clone profile.
Create the Obsidian vault.
Add AGENTS.md.
Add folder structure.

Day 2: seed identity

Write your personal operating manual.
Add 10 writing samples.
Add active projects.
Add 5 decision notes.

Day 3: first ingest

Ask Hermes to process raw/00-inbox/.
Review the generated wiki.
Fix bad assumptions.
Update source-map.md.

Day 4: voice tuning

Build wiki/voice.md.
Test three drafts.
Add banned phrases.
Add good and bad examples.

Day 5: workflow skills

Create skills for ingest, drafting, and weekly lint.
Test each skill on a small task.
Update the schema file with lessons.

Day 6: messaging

Configure one private Hermes gateway channel.
Ask simple questions.
Keep all external actions draft-only.

Day 7: maintenance

Add a weekly lint job.
Run an evaluation checklist.
Decide what source category to add next.

By the end of week one, your clone should not be amazing. It should be useful enough to keep improving.

That is the bar.

Common mistakes

Mistake 1: dumping everything in at once

More data is not automatically better. Start with high-quality sources. Your clone needs signal before scale.

Mistake 2: treating the wiki as raw truth

The wiki is a synthesis layer. Keep raw sources. Cite them. Review important claims.

Mistake 3: letting the agent rewrite your sources

Raw sources should be immutable. If the agent edits your original journal entries, you have destroyed the evidence layer.

Mistake 4: confusing memory with knowledge

Hermes memory is for compact durable facts. Obsidian is for the full knowledge base. Skills are for procedures. Keep the lanes clean.

Mistake 5: giving the clone too much agency too early

Do not connect email, calendar, social posting, and payments on day one. First make sure it can answer accurately and draft safely.

Mistake 6: ignoring voice

A clone that knows your facts but writes like a bank brochure will feel wrong. Voice is not decoration. Voice is part of the interface.

Mistake 7: no cleanup loop

A wiki needs maintenance. Schedule linting. Review contradictions. Archive stale pages. Keep the graph alive.

A simple prompt library

Here are useful prompts to save.

Ingest a new source

Read AGENTS.md and ingest the new files in raw/00-inbox.
Update relevant wiki pages.
Cite source paths.
Flag contradictions.
Do not delete raw files.
Summarize what changed.

Ask a personal-context question

Answer this using the wiki first and raw sources if needed:
[question]
Cite relevant wiki pages or source files.
If the answer is uncertain, say so.

Draft in my voice

Read wiki/voice.md and relevant writing samples.
Draft [piece] in my voice.
After the draft, list the voice rules you used.
Do not invent personal facts.

Review a decision

Using wiki/principles.md, wiki/decisions.md, and active project notes, help me evaluate this decision:
[decision]
Give me options, tradeoffs, risks, and your recommendation.
Mark assumptions clearly.

Weekly lint

Run the wiki lint workflow.
Find stale project pages, duplicate notes, orphan pages, uncited claims, and contradictions.
Suggest edits before making major changes.

How this compares to a custom AI assistant for business

The same pattern works for companies.

A personal clone uses your journals, writing, decisions, and workflows. A business clone uses SOPs, policies, sales calls, customer support logs, proposals, internal docs, and project retrospectives.

That is why I keep saying the real value of AI agents is not just chat. It is context plus action.

If you are exploring this for a company, start with the same principles:

Build the knowledge base first.
Keep raw sources separate.
Create a maintained wiki.
Teach the agent workflows.
Use approval gates for external actions.
Measure usefulness every week.

If you want the business version, read AI chatbots vs AI agents and custom AI vs off-the-shelf tools. Those two articles explain when this should be a simple setup and when it becomes a real custom system.

The bigger point

The future of personal AI is not one giant prompt.

It is a maintained context system.

Your AI clone gets useful when it has:

A clean vault.
A durable memory layer.
A wiki that compounds.
Skills that capture repeated workflows.
Tools with safe boundaries.
A habit of correction.

That is what Hermes plus Obsidian plus the Karpathy wiki method gives you.

Not a digital soul. Not a synthetic you.

A practical assistant that can learn the shape of your work and help you carry it forward.

And honestly, that is already powerful enough.

Sources and further reading

Andy Doucet is an AI consultant in Grande Prairie, Alberta helping businesses build practical AI agents, workflow automations, and custom AI systems. If you want a personal or business AI clone built safely, start with a free AI consultation.

Want a practical AI plan for your business?

If you are trying to figure out where AI actually fits in your business, I can help you sort the useful ideas from the noise. Book a consult with me and we will look at your workflows, your team, and the places AI can save time or create revenue without making the business weird.