Personal AI Assistant: How to Build One on Zo Computer

If you’ve searched “personal AI assistant”, you probably want something concrete: an AI that can do work on your behalf—not just chat.

Zo Computer is a good fit for this because your assistant runs on a real server that has:

your files (for memory and state)
a browser it can use when needed
integrations (email, calendar, Drive, Notion, etc.)
Agents (scheduled tasks) that run automatically

This tutorial walks you through building a practical personal assistant you can extend over time.

What we’re building

A “personal AI assistant” is usually three things:

A reliable place to store context (files and notes)
Tools it can use to take action (apps + web + code)
Automations so it works while you’re not watching (Agents)

We’ll build a minimal version first, then add “memory” and automation.

Prerequisites

A Zo Computer workspace (where your files live and your assistant runs)
Optional (but recommended): connect apps in Zo settings (Gmail, Google Calendar, Google Drive, Notion, etc.)

If you don’t connect any apps, you can still build a useful assistant that:

reads and writes files
browses public webpages
runs scripts and services

Step 1: Pick one assistant job (don’t start broad)

Most “personal assistants” fail because they start with: “be my life copilot.”

Pick one job with a clear output. Examples:

“Every morning, send me a daily briefing.”
“When I paste a URL, save it and extract action items.”
“Every weekday, summarize new important emails.”

A good rule: if you can’t describe success in one sentence, it’s too broad.

Step 2: Create a dedicated folder for assistant memory

Create a folder in your workspace for the assistant’s state. For example:

file 'Assistant'

Inside it, keep a few simple files:

file 'Assistant/profile.md' — your preferences, timezone, recurring projects
file 'Assistant/contacts.md' — the people you talk to + what matters about each
file 'Assistant/rules.md' — constraints (“never email anyone without asking”)
file 'Assistant/state.json' — machine-readable state (counters, last run timestamps)

Why this works: scheduled Agents need persistent state between runs, and files are the simplest form of memory.

Step 3: Write a reusable “assistant prompt”

Create a prompt that defines how your assistant should behave. Prompts are reusable instructions you can run again later.

Your prompt should:

state the assistant’s job
list the files it should treat as memory
specify output format
define what it must never do

A good pattern:

Inputs: where it reads from (files, inbox, URLs)
Actions: what tools it can use (web, calendar, email, file edits)
Output: what it writes (email, file, summary)

You can start with a daily briefing prompt like:

Read file 'Assistant/profile.md' and file 'Assistant/state.json'
Check today’s calendar
List 3 priorities, 3 risks, and 3 suggested next actions
Update file 'Assistant/state.json' with last-run timestamp

(You’ll connect the calendar in the next step.)

Step 4: Connect your tools (apps + web + files)

A personal assistant is only as useful as the tools it can use.

On Zo, the most common “assistant tools” are:

Agents (scheduled runs) ^1
Web browsing tools (fast extraction vs full browser) ^2
App integrations (Gmail, Calendar, Drive, Notion)
File edits (notes, plans, logs)

If your goal is “daily briefing”, connect Google Calendar.

If your goal is “inbox triage”, connect Gmail.

If your goal is “research assistant”, connect Drive/Notion for saving outputs.

Step 5: Turn it into an Agent (so it runs on its own)

Now convert your assistant job into an Agent that runs on a schedule.

Example: Daily briefing agent

Schedule: weekdays at 7:30am
Output: email (best for something you’ll search later) or SMS (best for urgent)
Instruction (high-level):
- “Check today’s meetings. Create a short briefing. Include:
  - top 3 meetings + why they matter
  - 3 follow-ups I should not miss
  - 3 suggested tasks for today
  - any conflicts or travel time issues Update file 'Assistant/state.json' and append a log entry to file 'Assistant/log.md'."

The Agent page is the core feature that makes a “personal assistant” feel real: it keeps working without you remembering to ask.

Step 6: Add guardrails (so it’s safe)

Give your assistant explicit boundaries in file 'Assistant/rules.md'.

Useful guardrails:

Never send an email to anyone except me.
Never spend money.
Never delete files.
If unsure, write a draft to a file instead of taking action.

A practical pattern is “draft-first”:

draft emails to file 'Assistant/drafts/<date>-email.md'
create a to-do list in file 'Assistant/todos.md'

Step 7: Extend gradually (memory + more jobs)

Once your first job is working reliably, add a second job.

Good second jobs:

Weekly review: summarize what happened + what to change next week
Inbox follow-up checker: find threads you haven’t replied to
“Watch this page” monitor: check a URL daily and report changes

The key is that each job gets:

a clear input
a clear output
a place to store state (files)

Common pitfalls

Too broad: “manage my life” → start with one job.
No persistent memory: if you don’t write state to files, every run starts from zero.
No boundaries: assistants without guardrails will eventually do something you didn’t want.

Summary

A real personal AI assistant is a workflow that runs on infrastructure you control:

store context in files
connect tools (apps + web)
automate with Agents

Once you have one assistant job working end-to-end, you can grow it into a full “assistant system” without rewriting everything.