A small team. Each one yours.

One generalist is a start. A team is the point.

An agent is not a bot. Not an automation. A named, capable presence that knows its job, speaks in its own voice, and can be trusted with a corner of your life. Some agents are conversationalists — you talk to them when you need their particular lens on a problem. Others are workers — they handle a stage in a process, run on a schedule, and leave the results somewhere useful. Many are both.

Think of it less like configuring software and more like assembling a small team of people who are quietly, competently looking after different parts of your life.

Every agent is built from a handful of clear pieces. None of them are complicated. Together they give the agent its character, its capabilities, and its boundaries.

Name and identity

A name makes the agent real. The identity — a paragraph or two written in plain language — answers who is this, what do they believe, what are their rules? Identity is editable any time. The agent picks up changes on its next turn.

Voice (optional)

Some agents benefit from character: terse and decisive, warm and reflective, thorough and citation-heavy, playful. Voice is a separate document — transplantable between agents. A filing agent might not need one; a journal-keeper definitely does.

Skills

Skills are the things an agent knows how to do — reusable recipes written in plain language. Skills live in a shared library; you grant specific skills to specific agents. Edit a skill once and every agent that uses it gets the update.

Connectors and scope

Connectors are what the agent can reach — Gmail, Calendar, Drive, Notion, GitHub, Slack, LinkedIn, X, Strava, Google Health, the web, your local folders, your vault. Every agent can reach for any of them, but the first time one tries something consequential it stops and asks you to grant it — for that recipient, channel, or folder. Reading just happens. You never have to predict, up front, every door an agent might one day need.

Memory

Each agent has a dedicated workspace folder in your vault and its own slice of memory. You decide how much it shares: open to the other agents, private to it (it still reads the shared picture, but its own notes stay its own), or fully walled off. Facts about your world live in shared knowledge every agent can draw on.

What it is trusted to do

You do not set an "autonomy level" up front. Reading happens freely; the first time an agent tries something that leaves a mark on the world — sending an email, posting, writing to your Drive — it stops and asks, once, for that specific recipient or channel or folder. It remembers your answer, every grant is logged, and you can withdraw any of it from the Access tab. Nothing pushes you toward giving up control.

Most agents lean one way or the other. Some are both — a researcher you can talk to, but who also runs a Friday scan of new sources. The shape is yours to decide.

A workflow is an ordered set of stages, each handled by a specific agent, producing outputs that flow to the next stage. Workflows read like recipes, not flowcharts: one stage after another with clear handoffs.

Example — "Monday Morning Brief": your researcher pulls the week's calendar and finds context for each meeting. Your inbox-keeper scans the weekend's email for anything urgent. Presence assembles the brief into Daily/Monday.md and sends a summary notification. Runs every Monday at 06:30. If a decision is needed, the workflow pauses with an "over to you" card — you tap an answer, it carries on.

Workflows can run on a schedule, in response to an event (a new email, a calendar invite), or when you say so in chat.

Some people stop at one. Others build a small team of five or six, each handling a different part of their day. A few compose elaborate workflows with decision gates and scheduled runs. All of these are the right amount.

When you hand an agent a task, do not engineer the perfect prompt. Brief it the way you would brief a capable colleague — digressions included. There is a dictate button in the composer; tap it and just say it out loud.

This is counterintuitive, so it is worth stating plainly: agents do their best work on loose, chaotic, spoken-style input — not on a tightly synthesised instruction. When you compress a request into one clean sentence, you throw away the context that tells the agent what you actually care about: the doubts, the asides, the "oh, and make sure you don't…". Leave it in. The agent reads the texture, asks a sharp clarifying question if it needs one, and fills the gaps from everything it already knows about you.

So dictate a paragraph. Think out loud. Trust the agent to do the synthesising you were about to do yourself — that is exactly the work it is good at.

You do not fill out a form to create an agent. You describe what you need. Presence walks you through naming, voice, connectors and skills as a conversation, then sets the new agent up with you — named, styled, and equipped. The arc takes a couple of minutes.

Read more about how the conversational approach works in Conversational by design.

Everything above describes agents the way you experience them. For readers who want the precise version, here it is, kept plain.

Who controls the steps

There is a sharp line between two things that look alike. In one, you lay out the sequence of steps in advance and the model just fills each one in — the path is fixed, the model is a worker on a rail. In the other, the model decides its own next move: it looks at where things stand, chooses what to do, sees what comes back, and chooses again. The dividing question is not "does it use tools?" but "who decides the path — the fixed steps you wrote, or the model itself?" An agent is the second kind.

The loop

Mechanically, an agent is a model running in a loop: take in the current state, reason about the goal, do something (call a tool), look at what came back, then reason again — repeating until the job is done or a stop condition fires. That loop — reasoning and acting, turn after turn — is what separates an agent from a chatbot or a single scripted action.

This is why "an agent is an AI that can call tools" is incomplete. Using a tool is how a model affects the world, but a lone tool call inside a fixed pipeline is still just a fixed pipeline. What makes something an agent is deciding the sequence of actions for itself.

What it is made of

One useful way to break it down — a reasoning core, plus memory, planning, and the means to act, all held together by the loop while it runs:

• The model — the reasoning core that chooses each next action.
• Tools — the means of acting on the world: reading email, searching, writing a file, handing off to another agent.
• Memory — what it carries across steps and across sessions, so it is not starting cold each turn.
• Planning — breaking a big goal into steps, then revising the plan as real results come back.

Agency is a spectrum, not a switch

How agentic something is comes by degree — how much it acts without step-by-step input, how much it pursues a goal rather than answering a single prompt, how far it reaches into real tools, how much it improves its own output as feedback arrives. The more of the path the model decides for itself, versus the more fixed in advance, the more agentic it is.

The honest tradeoff

Letting the model decide buys flexibility at the cost of speed, expense, and predictability. The right instinct is to reach for the simplest thing that works — often a fixed sequence, sometimes nothing fancy at all — and to add self-direction only where it genuinely earns its place. More autonomy is a cost to justify, not a default to chase.

Where 1Presence sits

In these terms: a conversationalist is usually a short loop — reason, maybe call a tool or two, respond. A worker runs a longer loop against a goal. A workflow is the fixed-path layer on top, with a capable agent deciding how to handle each individual stage. And the consent gate decides how much of what an agent chooses to do is allowed to reach the outside world without checking with you first.