Meet Leo, the AI agent

Who Leo is

Leo is the AI agent inside Whisperer that works with your context and changes the state of your systems, rather than only answering in text. It listens to your calls, reads the transcripts, sees your tracker, calendar, files and knowledge base — and acts in the same places: creating tasks, scheduling events, writing notes, drafting emails.

The easiest way to tell an agent from a chatbot is the trace it leaves. Ask yourself what remains after the conversation. If it is only text that you then move by hand, it was a chatbot, however good the answer. If a calendar event exists, a task exists and a note is in the knowledge base, it was an agent.

That last row matters most, and we will come back to it. The ability to act creates a risk a chatbot simply does not have, and Leo is built around that risk as much as around its capabilities.

What Leo sees

Tools are marketed by number, but the number is not what works. An agent with twenty tools and access to your conversations is more useful than one with two hundred that asks, every time, what you are talking about.

The reason is simple. Creating a task requires more than the ability to create tasks — it requires knowing which task. The wording lives in the meeting: who promised what, by when, with which caveat. An assistant without access to the meeting will create a task with whatever text you dictate — handing the work back to you, with an extra step attached.

So Leo shares context with the rest of the platform rather than receiving a summary of it:

Hence the consequence the whole thing was built for: "create the tasks from this meeting" is a complete instruction, not the opening of a clarification dialogue.

What Leo can do

Leo's registry holds 107 tools: 63 writes, 42 reads and 2 executed by the interface itself — switch theme, navigate.

What it looks like in practice

A call becomes tasks nobody transcribed

The rules for phrasing those tasks are worked through separately in the piece on meeting minutes: Leo carries over the structure you defined rather than inventing one.

A follow-up, and a promise that returns on its own

You: Draft a follow-up from the client call and send it to their address.

Leo: [reads the transcript and the meeting map]
     [composes the email]
     ⚠ Sending an email is irreversible.
       To: client@example.com
       Subject: Follow-up from our call
       [full body of the email]
       Confirm sending?

You: Yes.

Leo: Sent. Shall I set a reminder to revisit pricing in a month?

You: Please do.

Leo: Errand created. It survives a restart of the system and fires even
     if you are offline at that moment.

A deferred errand does not live in process memory but in a separate durable-execution engine: anywhere from a minute to a year out, running whether or not your browser is open. Moving it takes words — "remind me in an hour", "push it to tomorrow".

A file that turned into a conclusion

You: There's an export in storage, sales-july.csv. What's happening
     with churn?

Leo: [parses the file] 1,240 rows, 8 columns.
     Churn: 18% of the total; 61% of it cites one reason — "too
     expensive". In June that reason accounted for 34%.

You: Save that as a note and create a task to look into it.

Leo: Note created in the knowledge base.
     Task "Investigate price-driven churn" created in the Sales project.

What matters is not the ability to parse a CSV but that the conclusion did not settle in a chat log: it became a note that search can find and a task that has an owner and a date. That is the difference between "answered" and "done".

What Leo notices on its own

Everything above rests on you remembering the promise and asking about it. The most expensive things are lost the other way — when nobody remembers.

So Leo extracts commitments from meetings by itself: what you agreed to do, for whom and by when, with a link to the meeting where it was said. The list of open commitments is available at any moment, and closing one takes words: "I already sent that" or "that promise is off".

Where Leo stops

This is the most important part of the story, and the part usually left out. There is no right to act without the risk of error, so the boundaries are set in code rather than in the interface, and no setting removes them.

What is confirmed, and what runs on its own

Twenty-one actions are marked irreversible, and none of them runs without an explicit yes. Sending email is among them: formally it creates rather than destroys, but a sent message cannot be recalled, so it sits in the same class as deletion.

The scope of bulk actions is computed by the server, not the model. The confirmation card used to show free text written by that same model: get the scope wrong, and a person confirmed blind. Now the number in the card comes from a query against the real arguments. Six tools carried such a preview; twenty do now — that list grew faster than the registry itself, and it is the one place where a growing number genuinely means something.

Confirmation is server-side. Conversation state is held between requests, and the confirmation step is part of the execution graph. Closing a tab does not turn a pending action into a completed one.

When Leo stays quiet

The right to act has a second half: the right to speak first. An agent that finds commitments on its own and watches your connections will inevitably want to mention it — and this is exactly where most such systems break.

The asymmetry is simple. A missed notification is annoying; a superfluous one gets notifications switched off entirely — and along with the noise, the two cases a month the mechanism existed for are lost too. The second is worse, so every rule is written against sending: staying quiet is easy, speaking happens only once every check has passed.

That last row is where notification systems are usually built backwards: irritation is read as "they did not notice" and frequency goes up. Here displeasure does the only sensible thing — it lowers it.

What Leo cannot do

Four limits, better stated now.

It does not work outside your account. Every tool operates on the owner's data only: another person's meeting or task is neither visible nor modifiable.

It does not decide irreversible things for you. There is no autonomous mode for destructive actions and none can be switched on — that is a property of the registry, not a setting.

It does not receive secrets through the model. Tokens and passwords travel a separate channel into the secret store and never enter conversation state, so the agent can neither display nor forward them.

Some tools require a plan. Of the registry, 60 actions are available on the free tier, 38 require a paid plan, and 9 more belong to extended storage. Plan entitlement is checked separately from tool permission, and both must agree.

What Leo is made of

Leo is not a separate application but a layer over shared context, and three neighbouring mechanisms change its behaviour directly.

Memory removes repeated explanations. Facts about you, episodes of past conversations and learned procedures are stored with different lifespans and forgotten by rule rather than accumulated forever — otherwise, within a year, recall would consist of "the user said hello".

Skills supply method: an attached SKILL.md describes how a kind of work should be done, and Leo follows it instead of improvising.

MCP runs both ways. Outward, the same tools are available to Claude Desktop and Cursor — covered in the article on connecting meetings over MCP. Inward, you connect external MCP servers and their tools join the same registry, under the same confirmation rules.

Tone and role are yours to set in Prompt Studio, and the short text about you that is injected into every request lives in personal context.

Frequently asked questions

How is an AI agent different from an AI assistant?

An assistant answers; an agent executes. The practical test is the trace left behind: with an assistant it is text you move by hand, with an agent it is records in your systems — a task in the tracker, an event on the calendar, a note in the knowledge base.

Can Leo do something without my knowledge?

Ordinary actions, yes — that is the point: it can create a task or a note on its own. Irreversible ones, no: deletion, sending email or messages, erasing memory and disconnecting integrations always require confirmation, and that requirement cannot be switched off.

What if the model gets the scope wrong?

For bulk irreversible actions the server computes the scope and shows it in the confirmation card before the click. If the model said "deleting April" but the arguments carry no filter, you see the real number and decline.

Where do commitments come from, and can I check them?

From your meetings: Leo writes down what you agreed to do, for whom and by when. For any entry you can ask why it is there — the answer names the source meeting and the moment it was said. Closing an entry takes words.

Will it message me unprompted?

Only if you allowed it, and by default it is reserved: only things you would miss with real consequences get through. There are quiet hours, a cap of eight messages a day, and a rule where two "not useful" out of the last three mute that kind of prompt.

Do deferred errands run if I close my laptop?

Yes. Errands execute outside your session, survive a restart of the system and fire even when you are offline. The horizon runs from one minute to one year.

Is a subscription required?

Some actions are free — 60 of the 107. The rest require a paid plan, and extended storage work requires the corresponding tier.

What if a conversation should not be stored at all?

That is what no-logs mode is for: the transcript and the model's output exist only in memory during the meeting and are deleted when it ends. No memory and no commitments arise from such a conversation.

Getting to know Leo

The easiest way to feel the difference is one meeting. Hold a call, then ask Leo to create the tasks from it and schedule the follow-up. If the board and the calendar then look as though you transcribed everything by hand, you have just stopped transcribing by hand.

Create an account — the free minutes are enough to run that scenario end to end and decide whether this is how you want to work.