VDF AI Agents

Chatting with agents

How day-to-day conversations with an agent actually work — attachments, citations, when the agent uses a tool, memory across sessions, voice input, and switching agents mid-conversation.

3 min read
On this page

The shape of a real conversation

Most agent use looks like this: you open a chat, brief the agent, get a draft, refine for a few turns, copy the result, move on. A great agent run usually takes five minutes.

This page is about the small mechanics of those five minutes — the things that make a conversation feel sharp rather than clunky.

The fastest way to learn an agent is to use it for one real task. Read the docs, sure. But ten minutes with a real input teaches more than an hour of theory.

Starting a conversation

Open an agent. Type your message. Send. That’s it.

A few small habits that make the first message produce a stronger first reply:

State the outcome first

“I need a release note for our customer email this week” is better than “Hey, what should we do about the release this week?” The agent shapes its response around what you said the outcome is.

Attach what matters

If your message references a file, a document, or a piece of source material, attach it now rather than describing it. Attachments process while the agent reads, so there’s no delay.

Name the audience

“For our enterprise customers.” “For internal engineers.” “For a partner.” Audience is the single change that produces the biggest jump in output quality.

State the format

Bullets, paragraphs, table, list, structured doc. Be specific.

Attachments

You can attach a wide range of things to a message:

  • Documents — PDF, DOCX, TXT, MD, transcripts.
  • Spreadsheets — XLSX, CSV.
  • Slides — PPTX.
  • Code files — for engineering and analysis work.
  • Images — when the agent is image-capable. See Choosing a model.
  • Saved sources from Data — a folder, a vector index, a connected app reference.

A few patterns:

  • One attachment per role. “The transcript” and “the style guide” — each plays a different role. The agent uses them differently.
  • Name attachments in your message. “Use the attached transcript for content; use the attached style guide for tone.” Removes ambiguity.
  • Don’t attach what’s already in the agent’s knowledge. If a style guide is already an attached knowledge source for the agent, you don’t need to attach it again.

Citations

When an agent answers from a knowledge source — your team’s docs, a vector index, an attached file — it cites the source. The citation links back to the original so you can verify.

A useful habit: for anything you’ll act on, click at least one citation. If the citation matches the claim, you can trust the rest. If it doesn’t, you’ve caught a paraphrase drift before it causes a problem.

A citation is a reference, not a proof. Open the cited source for anything that matters — especially numbers, names, dates, and policy language. The five seconds of verification compound into trustworthy outputs over time.

When the agent uses a tool

Some agents have tools available. When the conversation calls for one, the agent uses it — and the chat surface shows you what happened.

You’ll see something like:

  • The agent calling Web search for a specific query.
  • A short summary of what the search returned.
  • The agent integrating that information into its next reply.

For most tool calls, this is informational — you watch the agent work and trust the output. For some, you can interrupt: if the agent is about to do something you didn’t mean, stop the response, clarify what you want, and start again.

For the full set of tools agents can use, see Tool catalog.

Multi-turn refinement

Most useful work happens after the first reply, not in it.

A pattern that works on almost every agent:

  1. Read the first reply. Don’t refine yet. Just read.
  2. Pick one thing to change. Tone, length, audience, format, a missing element.
  3. Ask for that change specifically. “Make it shorter.” “Use the customer’s name in the opening.” “Drop the second bullet.”
  4. Read the next reply. Pick the next thing.

One change at a time produces the best results. Changing several things at once makes it harder to see what improved the output.

Asking for a specific format

A short list of refinement requests that almost always work:

  • “Convert this into a three-bullet list.”
  • “Rewrite as one paragraph, no headings.”
  • “Make this a table with these columns: Item, Owner, Due.”
  • “Use Given/When/Then format.”
  • “Make it shorter. Aim for half the length.”
  • “Tighten the opening. The first sentence is the most important.”

When the output drifts

If the agent’s replies start drifting — losing the thread, forgetting an earlier instruction, repeating itself — the conversation has gotten long. Two options:

  • Re-state the key constraints. A short message that restates the audience, format, and goal usually realigns the agent.
  • Start a new conversation. Carry the most important context with you (“audience is enterprise customers; format is a three-section release note”) and start fresh.

Memory across sessions

For most agents, each conversation starts fresh. The agent doesn’t remember what you talked about yesterday. This is usually a feature, not a limitation — your past conversations don’t leak into today’s.

A few patterns to bridge the gap:

  • Save successful briefs. When a brief produced a great result, save it. Next session, start from the saved brief instead of recomposing it.
  • Reference earlier work. “Use the same tone as the release note from last week” — if “last week” is somewhere the agent can read, this works.
  • Use a knowledge source for persistent context. Anything you want the agent to remember across sessions should live in an attached knowledge source, not in the conversation itself.

Some workspaces support long-term memory — an explicit setting where an agent can carry context across sessions. When this is enabled, the agent’s settings make it clear what it remembers and what it doesn’t. If memory matters to you, ask your workspace admin whether it’s on for your team.

Voice input

You can talk to most agents instead of typing. Voice input is great for:

  • Briefing fast. It’s faster to talk a paragraph than to type one.
  • Conversational refinement. Reading the output and reacting verbally is sometimes more natural than typing.
  • Mobile or on-the-go use. Hands-free briefing.

The agent transcribes your voice into the conversation and replies normally. You can switch between voice and typing at any point in a conversation.

Voice produces longer first messages. When you talk, you naturally include more context than you would when typing. That's usually a feature — longer first messages often produce stronger first replies — but if you find yourself rambling, try typing the first message and using voice for refinement.

Switching agents mid-conversation

Sometimes a conversation that started in one agent’s territory drifts into another’s. A drafting session needs a critique. A research session produces something that needs visualization.

You can switch agents mid-conversation. The new agent reads the existing thread and picks up from there.

Two patterns:

  • Switch when the job changes. Drafting → Critique → Polish. Each agent does its specialty.
  • Switch when you’ve identified the wrong starting agent. Pick a better-fit agent and continue.

The original conversation history stays intact — switching agents adds to the thread rather than replacing it.

For multi-stage work that always follows the same shape, consider a Network instead. Networks formalize the “switch agents at each stage” pattern.

Conversation history

Every conversation is saved to your history. You can:

  • Reopen an old conversation and continue refining.
  • Search across your history to find a previous answer.
  • Delete any conversation when you no longer need it.

Two useful habits:

  • Star the conversations that produced great outputs. They become reference examples.
  • Delete the conversations that drifted into nothing. A clean history is a faster history.

A few patterns that compound

Read the first reply critically

The temptation is to read for “is it good enough?” The better question is “what would make this clearly better?” The second question produces the next refinement that matters.

Don’t apologize to the agent

Conversational habits sneak in. You don’t need to say “sorry, can you” or “would you mind.” The agent does the same thing whether you’re polite or terse. Save your typing for the actual change you want.

Pin the output before you keep refining

When a reply is “good enough to ship if I need to,” copy it somewhere safe before you ask for more. A future refinement might overshoot — and you’ll want the previous version back.

End with what you’ll do next

A short habit at the end of a conversation: write a one-line note about what the output got used for. Future-you, scrolling history, will know which conversations are worth reopening.

Where to go next