How to turn a general-purpose AI agent into a personal assistant for your work — through projects with their own system prompt, Markdown skills, connecting your services, and memory of your preferences. A practical breakdown using Doka.

Out of the box, any AI agent is generic. It doesn't know what you're working on, what style of answers you like, or which services you use. So for the first couple of days, you're explaining the same things in every chat. That's normal, but not necessary: an agent can be set up so it adapts to you once and then remembers the context on its own. Here's what that's made of.

This is about Doka, a desktop agent, but the principles are general: a personal agent comes together from four things, and here's each one.

Projects: separate context for each task

The most important one is projects. A project in Doka is a named workspace with its own settings, holding related chats. Each project has:

its own instructions for the agent — essentially a personal system prompt: how to behave, what tone to answer in, what to keep in mind specifically for this work;
its own working folder — the agent works with this project's files by default;
its own color and name — so you don't visually mix up different areas of work.

The point is that "work coding project" and "personal documents" are different contexts, and it's awkward to keep them under the same settings. With projects, you describe the rules for each area once, and after that you just open the relevant chat, and the agent already knows which mode to work in.

◆

Start with one project for whatever you do most often. Write a couple of rules into the instructions that you usually repeat by hand — a preferred answer format, or task context, for instance. Expand from there.

Skills: repeatable procedures

The second layer is skills. If project instructions are about "how to behave in general," a skill is a specific procedure: a review checklist, formatting rules, a report-parsing sequence. You write a skill once, as a regular Markdown file, and the agent picks it up on its own whenever a task fits.

The difference from project instructions is subtle but matters. Instructions apply to everything happening in the project. A skill applies only when it's relevant to the request. So instructions are convenient for general rules of an area, and skills for specific, repeating operations.

Your own services through MCP

The third layer is connecting what you already use. Email, a task tracker, a database, a messenger connect through MCP, and after that the agent isn't working in a vacuum — it's working with your real data.

This is what turns a generic assistant into yours: it doesn't just reason, it pulls tasks from your tracker, reads your work channel, queries your database. Set it up once at the app level, and it's available across every project from there.

Memory of preferences

The fourth layer works on its own. As you talk, the agent remembers stable things about you and your environment — preferences, recurring facts — and factors them in going forward. This isn't a replacement for explicit instructions, but background that removes the need to repeat the truly obvious stuff.

Importantly, memory stays under your control: whatever the agent is about to remember gets shown to you, and you can correct it or reject it. Customizing an agent shouldn't mean the app silently accumulates data about you.

How this comes together

On its own, each layer is a small thing; together they make a real difference. Picture this: you open a "Contracts" project, whose instructions set the right tone and working folder, with an MCP server for your database connected to the agent, and a "contract review" skill describing your usual checking process. You write one sentence, and the agent does exactly what you'd normally spend ten minutes explaining.

That's the whole point of customization: not clicking through settings for its own sake, but no longer having to repeat context and rules in every new chat.

Where to start

Don't try to set everything up at once. A sensible order: set up one project first and write in a couple of rules you repeat most often. Work like that for a few days. When you notice a procedure you keep describing over and over, turn it into a skill. Connect services through MCP once you actually hit a wall where the agent lacks access to your data.

That way, customization grows from real friction, not a desire to "make it neat" — and the agent gradually becomes genuinely yours. Download Doka for free.

How to Customize an AI Agent to Fit You: Projects, Skills, and Your Own Rules