If you do project work for a living — freelancer, consultant, agency-of-one — the part that wears you down isn't the work itself. It's the context-switching. Five clients, five sets of background docs, five sets of past calls, five running commitments, five inboxes' worth of email threads where the actual brief is buried in message six.
By Wednesday you can't remember what you promised the second client on Monday. Not because you're disorganized — because the system is asking you to hold all of it in your head. This guide is about putting the context outside your head, into a place an agent can read.
The actual problem with project-based work
The trouble isn't notes. You probably take notes. The trouble is that the notes for one client aren't in conversation with the notes for the same client from three months ago, let alone with the contract, the original brief, the latest call recording, and the half-written deliverable.
When a client texts on Friday asking "did we agree to include the analytics piece?", here's what usually happens. You open Slack. You open Gmail. You open Drive. You open whatever notes app the meeting got typed into. You skim three things, find an answer that sort of fits, and reply with cautious hedging. Twenty minutes spent on a question that should have taken thirty seconds.
What's missing is a single place where every artifact for that client lives, in a form that an agent can search and quote from. Not a fancy CRM. A workspace. The notes go in, the contracts go in, the call recordings go in, the past deliverables go in. When the question lands on Friday, you ask the agent and it answers from the actual record. The same shape works whether you're a one-person agency, a coach scaling a practice, or a freelance consultant juggling five engagements.
One page per client, nested forever
The shape that holds up across many clients and many years is dead simple: one top-level page per client, with sub-pages underneath for everything that pertains to them. There's no depth limit, so the structure can grow as the relationship grows.
A typical client page might look like this in your sidebar:
- Acme Corp
- Discovery and brief
- Contract (PDF)
- Calls
- 2026-02-14 kickoff
- 2026-03-08 mid-project sync
- Deliverables
- Phase 1 audit
- Phase 2 strategy doc
- Pipeline (database)
- Invoices and payments
The benefit isn't visual neatness — it's that the agent can scope its work to one client by reading from one branch. "Read everything under Acme. Draft me a status update I can send tomorrow." The agent doesn't have to guess what's relevant; the structure tells it.
Plain markdown matters here. The pages aren't a database row with attachments hanging off; they're text files the agent can read end-to-end. That's why a "summarize where this engagement stands" prompt actually works.
Briefs and discovery: turning the messy intake into something workable
The intake phase of any client project is famously chaotic. A discovery call. Three follow-up emails. A shared folder of "everything we have." A loose Loom recording. By the time you write the brief, you've reviewed all of it twice, taken notes in three places, and probably forgotten one important constraint.
The agent helps with the synthesis pass. Drop the discovery call recording (transcribed with speaker labels so you know who said what), the email thread (saved as a markdown page), and any PDFs the client sent (auto-converted to markdown via docstrange so they're searchable text, not opaque files). Then ask: "Pull the five things the client said are non-negotiable. Pull the three constraints they mentioned around budget or timing. Draft a brief that covers scope, deliverables, and unknowns I should clarify before signing."
You get a draft. You spend twenty minutes editing it instead of two hours assembling it. The client gets a brief that quotes them back to themselves, which tends to land better than one written from scratch.
Calls: stop being the human transcription machine
The single biggest improvement to client-work-with-many-meetings is letting something else handle verbatim capture.
The pattern: you record the call (with the client's knowledge), drop the audio onto the relevant call page in your vault, and the transcription runs with speaker labels. You're now free during the call to actually be present. Afterward, you skim the transcript instead of straining to remember.
The transcript is searchable, which matters more than people expect. Three months later when the client asks "what did we say about the rollout timing?", you ask the agent: "Find every time we discussed rollout timing across the calls with this client." You get the moments back, with speaker labels, in plain text. No more "I think we said early Q3?"
For client work specifically, the speaker labels matter. You want to know what they committed to versus what you committed to. A wall of dialogue without speaker attribution is just dialogue. If most of your week is calls, our deeper guide on drafting emails and proposals inside your notes app covers the next step — turning the transcripts into the follow-up the client actually expects.
Deliverables, drafts, and the version question
Client deliverables go through revisions. The first draft. The version after their notes. The version after your second pass. The "final" that became "final-v2" two days later. Most freelancers manage this in a folder of files with increasingly desperate naming conventions.
In a markdown vault, every revision can be its own page under a "Deliverables" sub-page, with the dates in the title. The agent can compare them on demand: "Show me what changed between Draft 2 and Draft 3 of the strategy doc, in plain English." That's a question that's hard to answer fast in a folder of Word files.
For deliverables that involve a lot of structured information — content calendars, audit findings, recommendations with priorities — an inline database inside the deliverable page works better than a static table. The client's edits become row updates instead of "track changes" hell. The whole thing stays in one document.
Tracking projects, payments, and what you owe whom
Across many clients, you need a few small databases that the agent can read alongside everything else. Not a separate accounting tool — just a few embedded tables in pages you actually visit.
A project-tracker database with rows per active engagement: client, current phase, next deliverable, due date, status. An invoices database: client, amount, sent date, paid date, status. A "promises" database for the things you've committed to that aren't formal deliverables: small follow-ups, intro emails, decks you said you'd share.
Because all of these embed inline in markdown pages via the :::database::: directive, they're not in a separate tool. The agent can answer "what's overdue across all my active projects?" or "which clients haven't paid their last invoice?" in one query.
The Friday review and what to keep out of email
Once a week, scan the running databases. Anything finished gets marked done. Anything that slipped gets a new date. Anything you'd forgotten to put on the list gets added now. To shorten the review, ask the agent first: "What did I commit to this week across all clients? What's overdue? What's coming due in the next seven days?" The agent reads your databases and call transcripts and gives you a focused short list. Ten minutes — not the hour-long reckoning that a "catch up on everything" Friday tends to become.
A useful boundary, learned the hard way: try not to let email be the system of record. Email is a transport, not storage. The decisions, the briefs, the commitments belong in pages in your vault, even if the original message arrived as email. When something important lands, paste the relevant chunk into the right client's page with a date. Now it's findable, quotable, and indexed by the same agent that reads everything else. The original email can sit in your inbox forever; it's no longer load-bearing. The same commitment-capture move applies during meetings — see how to capture action items so they actually get done for the meeting-side workflow.
A calmer way to run a roster of clients
Client work doesn't have to feel like spinning plates. The plates are real, but most of what makes them feel precarious is the search-and-reassembly cost between them. Put everything for each client in one nested branch of a vault, let an agent that knows the whole vault answer questions across it, and the spinning slows down.
Try Docapybara free — sign up, pick one active client, drop in the brief, the contract, and the last two call recordings, and ask the agent for a one-page status summary. Decide for yourself whether the shape fits the way you actually work.