I Built an AI Clone That Lives in the Cloud — for $0/month

01 · The Frame

The question that made it click

What is a clone? A copy of you.

So before we ask how to build one with AI, we have to ask the older question: who are you?

You have a brain. The brain thinks. The brain decides.

You have senses. You hear. You see. You speak back. The world doesn't reach you through a single port — it arrives through five.

You have hands. The hands act on what the brain decided, after the senses brought the news in.

You have a heart. The heart beats — even when you're not paying attention. It keeps you alive in the background.

A brain. Senses. Hands. A heart. That is what makes a human.

So an AI clone needs the same things. A brain that thinks like you. Senses that read the world the way you do. Hands that take action the way you would. A heart that keeps it alive when you're not watching. And a body somewhere — something housed, something reachable.

Once I had that frame, the architecture wrote itself.

02 · Motivation

Why I built it

I've spent more years than I'll admit moving data between systems that were never supposed to talk to each other. The ones that do talk usually break at 3 AM on a Friday.

I started using Claude Code about six months ago. It was good. It was also amnesiac.

Every conversation, the context resets. I'd explain my system. It would help. I'd come back the next day. It had forgotten me. I'd explain again. Help again. Forget again. The tenth conversation was as dumb as the first.

So I had a tool. I didn't have a clone.

A clone, by my own definition, has to:

• Remember — across sessions, across days, across topics
• Perceive — read incoming email, hear messages, see what's on the screen
• Act on its own — not wait for me to ask
• Search what I know — every meeting note, every decision, every spec
• Speak back — through whichever channel I'm on
• Survive me — my laptop being closed should not kill it

And one more constraint: cost zero dollars a month.

Every "AI assistant" I'd seen in the wild required a paid subscription, a hosted server, or a vendor lock-in. I wanted to know if I could build the thing I actually wanted using infrastructure I already had — for free. It turns out you can.

03 · The Map

The architecture: brain, senses, hands, heart, body

There are five layers. That's the whole thing.

Five layers. Multiple clients. One brain. Zero dollars.

Each organ exists to answer a different question. The brain answers "who is this and what do they know." The senses answer "what is happening right now and how do I respond." The hands answer "what should be done." The heart answers "what should run on its own without being asked." And the body answers "where does all this live so it stays reachable."

04 · Organ One

The brain — Claude + Memory + Wiki

The brain is the thinker. Raw cognition. For me that's Claude (Sonnet 4.6), the cheap workhorse.

But a brain isn't you. A brain wakes up every conversation knowing nothing about who you are. So we add two organs around it.

Memory

Small markdown files that persist across sessions. An index file (MEMORY.md) that points to individual entries: who you are, what you've decided, what feedback you've given, what projects you're running. The index loads automatically at the start of every session. The individual files are loaded on demand when relevant.

It's a librarian and a library. The librarian is always at the desk (the index, ~150 lines, always-on). The books are pulled when needed (individual memory files, fetched by Claude when a topic surfaces).

Wiki

Hundreds of markdown pages of accumulated knowledge. Meeting notes, technical specs, leadership intel, FHIR documentation, every research session ever run. Searched on-demand using sqlite-vec for semantic similarity and FTS5 for keyword recall — hybrid search, 70% semantic, 30% keyword. Fully local. No cloud calls.

Memory is identity. Wiki is knowledge. Together they make a brain that knows who it's talking to and what it knows.

05 · Organ Two

The senses — how the clone perceives and speaks

A brain alone can't reach the world. It needs senses. Mine has five.

• Inbox sense — Gmail API, read-only at first. The clone reads what arrives. It doesn't reply on its own.
• Calendar sense — Google Calendar API. It knows what's on my day before I do.
• Chat sense — signal-cli, iMessage bridge, Slack webhooks. It hears people talking to it on whatever channel.
• Voice — Kokoro TTS (am_adam, fully local). When something matters, the clone can speak. I listen to my morning brief on the drive in.
• Eyes (when needed) — vision via Claude itself, applied to screenshots and document images. Mostly I don't need this. When I do, it's there.

Senses are bidirectional. The clone reads inbox, calendar, and chat (input). It sends drafts, posts to Signal, generates audio, and emails me back (output). The same channels that bring the world in carry the clone's voice out.

Architecturally these are just API integrations. Metaphorically, they're sensory organs. The metaphor matters because it's how a non-engineer asks "wait — can it just send an email?" and the answer becomes obvious: yes. It has a mouth.

06 · Organ Three

The hands — Skills are markdown files

Here's the part that surprises engineers. A skill is a markdown file. That's it.

---
name: morning-brief
trigger: cron 06:30
tools: [calendar, gmail, tasks]
---

## steps
1. pull today's calendar events
2. read pending tasks, score by importance × urgency
3. pick top 3 priorities
4. compose email: events + priorities + things i've been avoiding
5. send via gmail api
6. append entry to heartbeat log

No Python. No API key. No framework. YAML on top. Plain English below. Claude reads it and executes the instructions.

I have 118 skills now. Autonomous ones (morning-brief, email-triage, weekly-review). Multi-agent ones (planning-team that spawns 10 expert sub-agents to argue a decision, code-review with three orthogonal lenses, deep-research). Platform ones (memory, wiki, deploy-mcp).

The bar to write a new skill is somewhere between "send a Slack message" and "write a recipe." Anyone who can write a clear email can write a skill.

This is also the moment where most engineers do a double-take. That's it? Yes. That's it. The abstraction does not get richer than this. Claude is the runtime. Markdown is the source code. You don't need any more layers.

07 · Organ Four

The heart — the heartbeat

A tool you call when you need it is not a clone. A clone has its own pulse.

Mine is 13 scheduled tasks. They fire on launchd (Mac) or cron (Linux). The longest one is fifteen lines of XML. There is no daemon. No Docker container. No server process spinning in the background.

00:00  log rotation
04:00  email-triage         ← while i sleep
06:30  morning-brief        ← arrives before i'm up
06:45  signal status check
11:30  midday-pulse         ← gentle mid-day nudge
17:00  end-of-day wrap
20:00  evening-planning     ← top 3 for tomorrow
22:00  daily reflection     ← promote facts to MEMORY.md
fri 17:00  weekly-review
sun 18:00  sunday-prep
... and a few quieter ones

Each one is just a scheduled invocation of Claude Code with a specific skill. The OS wakes a process. The process runs. The process logs what it did. The OS goes back to sleep.

This is what makes it a clone instead of a tool. The morning brief shows up in my inbox at 6:30 whether I'm at my desk or not. The email triage at 4 AM has already separated signal from noise by the time I wake up. The weekly review on Friday surfaces what I shipped, what I avoided, and what's drifting.

I didn't touch my laptop for any of it. That is the whole point.

08 · Organ Five

The body — MCP on GCP free tier

So far everything runs on my laptop. If my laptop is closed, the clone is dead. That's not a clone — that's a dependent.

The MCP server fixes that. MCP is the Model Context Protocol — the standard way AI clients talk to tools. Think of it as giving your clone a phone number. Once it has one, anything that speaks MCP can call it.

The server itself is thirty lines of FastMCP:

from fastmcp import FastMCP

mcp = FastMCP("clone")

@mcp.tool()
def get_memories(query: str) -> list[dict]:
    "Return memories matching the query."
    return search_memory_index(query)

@mcp.tool()
def search_wiki(query: str, k: int = 5) -> list[dict]:
    "Hybrid search across the wiki (semantic + keyword)."
    return wiki.hybrid_search(query, top_k=k)

@mcp.tool()
def get_tasks(portfolio: str | None = None) -> list[dict]:
    "Return tasks, optionally filtered by portfolio."
    return tasks.list(portfolio=portfolio)

@mcp.tool()
def add_memory(name: str, body: str, type: str) -> str:
    "Append a new memory file."
    return memory.write(name=name, body=body, type=type)

mcp.run()

Four tools. Type hints become the schema. FastMCP generates the protocol layer for free.

I deployed this on a Google Cloud e2-micro instance. That's the free-tier VM — 2 vCPU, 1 GB RAM, 30 GB disk. It costs zero dollars a month. I've been running this for two months. Cost so far: zero.

Caddy is the reverse proxy in front. systemd keeps the service alive. That's the whole stack.

Now Claude.ai connects to it. Claude Code connects to it. an iMessage bridge connects to it. All three talk to the same brain.

Three clients. One brain. Zero dollars.

09 · The Engineering

CI/CD — what separates a hobby from a platform

This is where most "AI second brain" projects stop. They have skills. They have memory. It works. They ship a video. They go home.

I wanted something else. I wanted a platform — code that gets reviewed, tested, and deployed the way real software does.

Every push to main runs GitHub Actions:

• ruff for lint
• mypy for types
• pytest for the 30+ unit tests
• A custom skill-validator that checks every skill file has valid YAML, a defined trigger, no leaked API keys, no embedded personal data

Every merge to main builds an artifact, scp's it to the GCP VM, restarts the systemd service, and runs a health check. If the health check fails, it auto-rolls back to the previous artifact and pages me on Slack.

This is the part that separates "interesting weekend project" from "thing I can rely on at 3 AM." Every commit is tested. Every deploy is verified. Every failure is reverted.

10 · Design Choices

The choices that make this work

A few design decisions are doing most of the heavy lifting:

• The body metaphor — brain, senses, hands, heart, body. It's a teaching tool, not just an architecture diagram. It makes the system explainable to non-engineers.
• Senses as a first-class organ — I/O channels aren't plumbing here, they're an organ system. Naming them that way changes how you reason about permissions.
• 8 workspace files — IDENTITY · SOUL · AGENTS · TOOLS · USER · MEMORY · HEARTBEAT · CLAUDE — with a public/private security boundary baked in. The private files are gitignored and never reach a remote.
• MCP server on GCP free tier — multi-client and 24/7 uptime, $0/month. Localhost-only would have meant the clone dies whenever my laptop closes.
• CI/CD pipeline with auto-rollback — every commit tested, every deploy verified, every failure reverted. This is what separates a weekend project from something I can rely on at 3 AM.
• Multi-channel — Claude.ai, Claude Code, iMessage, Signal. Same brain, different mouths.

11 · The Path

How to start

Don't try to build ten skills this weekend. Don't try to deploy MCP. Don't try to set up CI/CD.

Build the one skill that saves you ten minutes tomorrow morning.

For me that was the morning brief. I was spending fifteen minutes every morning checking my calendar, reviewing my task list, figuring out what to focus on. Now my clone does it at 6:30 and emails me the answer. Fifteen minutes a day, every day, for as long as I live. That's the deal you make with the first skill.

Then the next one.

Start with three skills. Add memory when you're ready. Add the wiki when you have knowledge worth searching. Add the heartbeat when you want autonomy. Add the MCP server when you want a platform. Add CI/CD when you want to stop being scared of it.

I started with three. I have a hundred and eighteen.

The repo is at github.com/rajangupta/ai-clone-starter. Eight vanilla skills. Eight workspace files. MCP server scaffold. CI/CD template. A requirements.md and a create-clone-prd skill that walks you through scoping your own.

I'm not giving you my code. I'm giving you the foundation to build your own. The difference matters.

12 · The Loop

One last thing — the reinforcing loop

Every conversation makes the next one smarter.

Session ends → daily log written → daily reflection promotes facts to MEMORY.md → next session starts with that context loaded → conversation gets richer → ends → log → reflection → MEMORY.md grows → next session even richer.

It's a reinforcing loop. (+) sign in systems-thinking notation. The clone gets more "you" with use. The only way to make it stop is to never use it.

That's the part that doesn't fit on an architecture diagram. That's the part that took me six months to feel.