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:
- Assistant
Inside it, keep a few simple files:
-
profile — your preferences, timezone, recurring projects
-
contacts — the people you talk to + what matters about each
-
rules — constraints (“never email anyone without asking”)
-
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 profile and state.json
-
Check today’s calendar
-
List 3 priorities, 3 risks, and 3 suggested next actions
-
Update 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 state.json and append a log entry to log."
-
-
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 rules.
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 <date>-email
-
create a to-do list in todos
Step 6.5: Make it private (run a local model)
If “personal AI assistant” means private AI assistant to you, the cleanest upgrade is to run a local LLM on your Zo and use it for sensitive work.
The difference is simple:
-
Hosted models: fastest to start, but your prompts leave your server.
-
Local models: lower marginal cost and more privacy, but you manage the model runtime.
Zo can host the model runtime as an always-on service, and your assistant can then treat it like another tool it can call.
If you want the step-by-step setup, follow: https://www.zo.computer/tutorials/how-to-run-a-local-llm-on-zo-computer-ollama
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.