Meet Cody: How I Built a Personal AI Assistant That Actually Understands My Life and Acts on It

A guide to creating an AI assistant that knows your tasks, projects, and people — accessible from anywhere, even your phone based on OpenCode.

The Problem: AI That Can Talk But Can’t Act

Everyone uses AI assistants now. ChatGPT, Claude, Gemini — they’re everywhere. And honestly, they’re impressive. They remember your preferences. They know your writing style. They can have intelligent conversations about almost anything.

But here’s the problem: they can’t actually do much.

Think about it. You can ask ChatGPT to help you plan your week. It gives you a beautiful plan. Then what? You manually copy it into your calendar. You create tasks in your to-do app one by one. You write notes in your notebook yourself. The AI gave you advice, but you did all the work.

This is the disconnect between AI intelligence and real-world execution.

Your AI assistant might be brilliant, but it can’t:

  • Add a task to your actual task list
  • Update your notes when something changes
  • Check your calendar and prepare you for meetings
  • Send that follow-up email you keep forgetting
  • Connect to the tools where your real work happens

The AI lives in a chat window. Your life happens (in my case) in Obsidian, Google Calendar, email, Slack, and dozens of other tools. There’s a wall between them.

What Would Make It Actually Useful?

To go from “helpful chatbot” to “true personal assistant,” you need three things:

1. Execution Power — The AI needs to connect to your actual systems. Your note-taking app. Your task manager. Your calendar. Your email. Not just talk about them, but actually read and write to them.

2. Mobile Access — You’re not always at your computer. Ideas come while walking. Tasks pop up during commutes. If your AI assistant only works on your laptop, it’s useless half the time.

3. Customization — Your workflow is unique. You need the ability to add custom actions, connect to specific tools, define how things should work. One-size-fits-all doesn’t cut it when you’re trying to orchestrate your entire life.

I’ve tested pretty much every AI assistant setup out there:

  • ChatGPT with plugins — limited integrations, no local access
  • Claude Desktop — powerful, mobile is limited (only remote MCPs) when it connect to local tools
  • Goose AI - an open source local agent by Block, missing mobile
  • Coding assistants (Claude Code, Codex, Gemini) — great for code, isolated from personal systems, terminal is not for everyone
  • Various automation tools — complex setup, still missing the AI conversation piece

Each one had pieces of what I needed, but nothing complete. Nothing that could truly orchestrate my work and life the way I wanted.

Here’s the thing: you can achieve most of this workflow on desktop. Tools like Cursor, Claude Code, or even Claude Desktop with MCPs can connect to your systems and execute tasks. The desktop experience is actually quite good.

But the missing piece is mobile.

You can’t dictate when ideas hit you. You can’t control when you suddenly remember that follow-up you forgot, or when a thought about a project pops into your head. It rarely happens when you’re sitting at your desk. It happens when you’re walking, at the playground with your kids, in a meeting, at the store. And in that moment, you need to capture it — or it’s gone.

This is why I spent months looking for the right setup. I wasn’t just looking for an AI that can execute — I was looking for one I could put in my pocket.

What “The Perfect Setup” Means to Me

Before I show you what I built, let me be specific about what I was looking for:

Real Execution Power — Not just “AI can connect to tools” but actually being able to configure MCPs (Model Context Protocol servers) that let the AI read and write to my systems. My notes. My tasks. My calendar. With full control over what it can access.

Mobile That Actually Works — Many AI apps have mobile versions, but they’re crippled. Either no MCP support at all, or only cloud-based connections that don’t reach your local environment. I needed mobile access that has the same power as my desktop setup. Same tools. Same execution. Same capabilities.

True Customization — This was the dealbreaker for most solutions. I wanted to write my own MCPs. Add custom commands. Configure the AI’s behavior for my specific workflows. Define how it handles my tasks, my projects, my people. Cloud-based solutions don’t give you this control — you’re stuck with whatever they offer.

Most setups fail on at least one of these. They either can’t execute, don’t work on mobile, or lock you into their way of doing things.

I finally found a combination that checks all three boxes. But before I show you the technical setup, let me explain what I actually want to automate — because the tools only matter if they serve a real workflow.

The Three Pillars: Tasks, Projects, and People

My system is built around three simple concepts. Everything connects to these three ideas.

1. Tasks — Your Running To-Do List

Tasks are the small things you need to do. “Email Sarah about the budget.” “Review the proposal.” “Buy groceries.”

I keep all my tasks in a tool called Obsidian. Think of Obsidian as a digital notebook where everything is stored as simple text files. This is important because:

  • Simple text files never become outdated
  • Any program can read them
  • You own your data forever

Every day, I have a “daily note” — a file for that specific day. I add tasks there as they come up. The tasks have dates attached to them, so I know when things are due.

Here’s what makes this powerful: my AI assistant can see all these tasks. When I ask “What’s on my plate today?”, it actually knows the answer because it can read my files.

2. Projects — The Bigger Picture

Some things are too big for a simple task. When I’m working on a new feature, planning a major decision, or exploring a complex idea, I create a project.

A project is just a note where I collect everything related to one topic:

  • Notes from meetings about it
  • Ideas that came up in conversations
  • Decisions we made along the way
  • Links to related documents

When I ask my assistant “What about Project X?”, it goes to this file and brings back all the context. This means I never lose track of where we are on something, even if I haven’t looked at it for weeks.

3. People — Your Personal CRM

You work with people. You make promises to them. They ask you things. You need to follow up.

For each person in my work life, I have a simple file. It contains:

  • Basic information about them
  • Notes from our conversations
  • Things I need to discuss with them next time
  • Follow-ups I promised

Before a meeting, I can say: “Prepare me for my call with Sarah.” My assistant pulls up everything we’ve discussed, what’s pending, and what I should bring up. After the meeting, I tell the assistant what we talked about, and it updates the file.

This is like having a personal secretary who remembers every conversation you’ve ever had.

The Magic: Connecting Everything

Here’s where it gets interesting. These three concepts connect to each other:

  • A task can link to a project: “Review the proposal” connects to “Product Launch Project”
  • A task can link to a person: “Follow up with Sarah” connects to Sarah’s file
  • A project can involve multiple people: The project file mentions everyone involved

My AI assistant understands these connections. When I’m preparing for a one-on-one meeting, it can find:

  1. All tasks related to that person
  2. All projects we’re both involved in
  3. Our conversation history
  4. Things I promised to do or follow up on

This creates a complete picture without me having to remember anything.

The Setup: How It Actually Works

Let me explain the technical side in simple terms.

The Brain: OpenCode

I use a tool called OpenCode. It’s an AI assistant that runs on my computer in terminal (not in the cloud). This means:

  • It has access to my local files (with certain limitations)
  • I control what it can see and do
  • It’s always available when my computer is on
  • I can use any LLMs I want - from local to frontier

But here’s the key feature that made me choose OpenCode: it can be accessed remotely. Most local AI assistants only work when you’re sitting at your computer. OpenCode has a “server mode” that lets you connect to it from anywhere.

The Toolbox: MCP Servers

This is where the real power comes from. I have a collection of MCP servers — each one connects my AI assistant to a different tool or system:

  • Google Docs MCP — Creates and edits documents with my preferred styling and formatting
  • Obsidian MCP — Reads and writes to my knowledge base, creates structured notes
  • Tasks MCP — Manages my to-do list, pulls tasks by date or status
  • Search MCP — Finds information across my notes and projects (there is a built-in one but I also open-sourced one - https://github.com/sbarysiuk/ddgs-search-mcp)
  • Jira MCP — Connects to work project management (I built this one myself but you can use an official one)

And the list keeps growing. The beautiful thing is: if an MCP doesn’t exist for a tool I use, I can build it. Every tool with an API becomes accessible. I write the integration, define the behavior I want, and connect it to my assistant.

This is the customization that cloud-based solutions can’t offer. I’m not limited to what someone else decided to support. If I need it, I build it.

The Connection: Tailscale

My assistant runs on a Linux computer at home that’s always on. I use a tool called Tailscale to create a private network between all my devices:

  • My home computer (where the assistant runs)
  • My work laptop
  • My personal laptop
  • My phone

Tailscale makes all these devices act like they’re on the same local network, even when I’m traveling. It’s like having a private tunnel to my home computer from anywhere in the world in a secure way.

The Mobile App: OpenCody

This is the key piece that makes everything work together.

I searched for months for a mobile app that could connect to a local AI assistant with full MCP support. It doesn’t exist. Mobile apps either connect to cloud-only services, or they’re limited chat interfaces without real execution power. None of them could reach my local setup with all my custom MCPs.

So I built one. I call it OpenCody.

(Why Cody? I named the assistant Cody because OpenCode kind of twisted itself, added a “y,” and suddenly became OpenCody—which also happens to sound like coati, those cute, nosy little animals that poke around in everything. So the mascot became a coati, always exploring just like an AI assistant. And if your name is Cody—congrats, you’ve got the best name out there.)

Building a mobile app sounds complex, but modern AI tools make it surprisingly fast. I built a working app in one weekend using React Native and Expo. It connects to my OpenCode server and gives me:

  • Chat with my assistant using text
  • Voice commands for hands-free updates
  • Full conversation history
  • The same execution power as my desktop — all my MCPs, all my tools

This is what I was looking for all along. The same AI assistant that runs on my Linux box, now in my pocket. Same capabilities. Same access. Anywhere I go.

The Knowledge Base: Obsidian with MCP

Obsidian stores all my notes as simple text files. But how does my AI assistant read them?

I use something called MCP (Model Context Protocol). Think of MCP as a translator that lets AI assistants talk to other software. I have MCP “servers” that:

  • Let the assistant read and write Obsidian files
  • Pull tasks from my task management system
  • Create structured notes in the right format

This means when I say “Add a task for tomorrow to call the accountant,” the assistant:

  1. Understands what I want
  2. Finds tomorrow’s daily note
  3. Creates the task in the correct format
  4. Links it to the right person file if needed

All automatically. All with just a voice command.

A Day in My Life With Cody

Let me show you what this looks like in practice.

Morning. I grab my phone while making coffee and ask: “What’s on my plate today?” My assistant tells me I have 3 overdue tasks, 5 things scheduled for today, and 2 meetings. I say “Move the budget review to Friday” and “Mark the email task done.” All through voice, while sipping coffee.

Not everything has to go through AI. When I’m at my computer on a call, I don’t want to switch context. I use a simple Raycast extension that lets me quickly add a note or task to my daily note with a keyboard shortcut. The AI picks it up later when I do my review.

Before my one-on-one with Sarah, I ask: “Prepare me for my meeting with Sarah.” The assistant pulls up when we last met, what we discussed, open tasks related to her, and things I promised to follow up on. I walk into the meeting prepared, without spending 30 minutes searching through emails and notes.

Later, I’m at the playground with my kids when I remember something important. I pull out my phone and say: “Create a task for Monday to follow up with the design team about the new landing page.” Done. The thought is captured exactly where it needs to be.

At the end of the day, I review overdue tasks with Cody, going through each one, marking things done, moving things around, adding notes. It’s a conversation, not data entry.

And it doesn’t have to be as simple as working with tasks. Since the system has full access to my knowledge base, Google Docs, and other tools, I can say: “Review this project for me. Pull all the documents and PRDs from the team. Create a summary highlighting things related to these questions I have, and save it as a note in Obsidian. In addition, make a research of how other competitors handle this.” And then I get a perfectly formatted note in my Obsidian, ready to use. And yes, it can be a Google Doc too ;)

Why This Changes Everything

The key insight is this: I don’t manage my tasks anymore. I have conversations about my life.

Traditional task management feels like data entry:

  • Open app
  • Find the right list
  • Click buttons
  • Type carefully
  • Remember to check it later

My approach feels like talking to a colleague:

  • “What’s happening with the product launch?”
  • “Add that to my list for when I meet John”
  • “What did I promise Sarah last week?”

The difference is huge. Because it’s so easy to capture and retrieve information, I actually use the system. Because I use it, it stays current. Because it’s current, I trust it. It becomes a virtuous cycle.

What’s Next

This is pretty much work in progress, I’m still improving this system. Here’s what I want to add:

Calendar Integration: Right now, my assistant doesn’t see my calendar. I want it to understand my schedule, know when meetings are, and help me prepare automatically.

Call Recording: I want to record my meetings (with permission) and have the assistant automatically create summaries and action items. Ideally locally and ideally integrate with Obsidian

Specialized Agents: Right now, I have one assistant that does everything. I want to create specialized “sub-agents” that are experts at specific tasks — one for meeting prep, one for task management, one for writing.

Better Voice: The voice interface works, but I want it to be more natural. Imagine having a real conversation about your week while driving.

Open sourcing OpenCody: Eventually I plan to open source OpenCody. Need to clean up some things but if you want to beta test it, let me know.

Local memory: I want to add a local memory provider that I can move between different assistants, machines, etc.

Final Thoughts

We’re at a special moment in technology. AI assistants are becoming genuinely useful, but only if they understand your context. The key is connecting them to your actual life — your tasks, your projects, your relationships.

The system I’ve built isn’t perfect. It takes some effort to set up. But once it’s running, it fundamentally changes how I manage my work and personal life. Instead of juggling tasks in my head or losing track of projects, I have a reliable partner who remembers everything. But more importantly it is so extensible and scalable that my “Ideas for Cody” is running very long!

← Back to all articles