VDF AI Agents

Tools and knowledge

Teach your agent your world — give it knowledge sources to draw from and tools to act with, so it stops guessing and starts contributing.

3 min read
On this page

Why an agent without context is half an agent

A great agent runs on three things: clear instructions, the right knowledge, and the right tools.

Most teams nail the instructions. They write a sharp brief, describe the audience, and pick a format. Then they wonder why the agent’s output is still generic.

The missing pieces are knowledge and tools. Knowledge is what the agent knows — your team’s documents, your standards, your past examples. Tools are what the agent can do — look something up, generate a file, search a specific source.

This page is about both.

A small amount of the right knowledge beats a lot of generic context. An agent with access to your team's style guide and past 20 examples will outperform an agent with access to your entire wiki — every time.

What “knowledge” means for an agent

Knowledge is the source material an agent can pull from during a conversation. You decide what counts as knowledge for each agent.

The most useful knowledge to give an agent:

Your team's voice

A folder of well-written past examples. The agent learns what "good" looks like in your team's terms.

Your team's facts

A vector index over your product docs, customer records, or past decisions. The agent stops guessing and starts citing.

Your team's standards

A style guide, a checklist, a "things we always include." The agent applies the standard automatically.

The current moment

A connected app — Confluence, Jira, Slack — so the agent sees what your team is doing right now, not what it was doing a year ago.

Where knowledge comes from

You can attach four kinds of knowledge to an agent. Most agents use one or two.

A connection from VDF AI Data

The most common. You’ve already connected a source — files, a Confluence space, a database. Point the agent at it.

The agent can now read that source whenever a conversation calls for it.

A vector index

The sharpest. You’ve already built a vector index over a focused dataset. Point the agent at the index.

A vector index narrows what the agent can see. That narrowness is usually a feature, not a limitation — the agent’s answers stay grounded in the source you curated.

A document folder

A simple folder of files. Useful when the knowledge is straightforward — a handful of style guides, a few past examples, a few templates.

The agent reads the files in the folder as part of its context.

A live connected app

A Confluence space, a Jira project, a folder in Drive. The agent reads the current state of the app whenever a conversation needs it.

Good for agents that work with content that changes often.

How to think about scoping knowledge

The single biggest decision when attaching knowledge is how narrow to make it.

Three rules:

  • Narrow is better than wide. An agent attached to “all of Confluence” produces less reliable answers than one attached to “the customer success team’s onboarding space.”
  • Curated is better than comprehensive. A vector index over the 200 documents that matter beats raw access to the 2,000 documents that might.
  • Multiple narrow sources beat one wide source. It’s better to attach two focused indexes than one sprawling one.

Test what the agent actually pulls from. After attaching a knowledge source, ask the agent to cite which sources it used to answer a typical question. The citations tell you whether the scope is right.

What “tools” means for an agent

Tools are what an agent can do. An agent without tools can read, reason, and write. An agent with tools can also search the web, generate a PDF, look up a customer record, or send an email.

The full list of available tools is in the Tool catalog. The catalog is shared between Networks and Agents — the same tools, with the same actions.

Which tools to give your agent

A short rule: the tools the agent’s job actually requires, and nothing else.

A few patterns that work:

A research agent

Tools: Web search, Web crawler, Knowledge search.

The agent looks things up — externally and internally — and synthesizes what it finds.

A drafter

Tools: Knowledge search for past examples, Document generator for the final artifact.

The agent reads your team’s previous work, then produces the new piece.

A reviewer

Tools: Knowledge search for the standards, GitHub diff if the review is code.

The agent reads the standard, reads the work, and produces the review.

A summarizer

Tools: usually none. The agent’s job is to digest input, not to fetch new information.

A visual agent

Tools: Image generator or Chart generator or HTML mockup generator. See Visual agents.

What happens when an agent uses a tool

When an agent calls a tool, the chat surface shows it. You see:

  • Which tool the agent picked. “Web search for ‘EU AI Act timeline.’”
  • What the tool returned. A summary or the raw result.
  • What the agent did with it. The tool’s output flows into the agent’s next response.

This visibility matters. You can tell the difference between an agent that fetched a real source and an agent that made something up.

For deeper detail on how the chat surface shows tool use, see Chatting with agents.

When to use a tool vs. attach knowledge

A common question. The two overlap.

  • Attach knowledge when the source is stable and the agent should consult it often.
  • Use a tool when the source is dynamic or the agent should reach for it only when needed.

For example:

  • Your team’s style guide → attached knowledge. Always read.
  • The web → tool. Read only when the conversation calls for it.
  • A customer’s record → tool. Looked up by name when the conversation references the customer.
  • Your team’s past 100 release notes → attached knowledge (as a vector index). Always available.

In practice, most production agents use both: a small set of attached knowledge sources plus a handful of tools.

A few patterns that work

Start with knowledge before tools

A new agent’s first improvement should be a knowledge source, not a tool. Knowledge is where the agent’s identity comes from. Tools amplify a clear identity; they don’t create one.

Limit tools to the smallest useful set

Every tool the agent has access to is a tool it might use at the wrong moment. Three focused tools usually produce better behavior than ten available ones.

Document why each tool is attached

A one-line note in the agent’s description — “Web search is enabled so the agent can pull current competitor info” — saves a future editor an hour of guessing.

Re-test after knowledge changes

If the underlying knowledge source changes substantially — a Confluence space restructured, a vector index rebuilt — re-test the agent on a few real questions. The change usually doesn’t break the agent, but checking is cheap.

Sensitive knowledge needs deliberate scoping. An agent attached to a knowledge source containing customer data, financial details, or HR documents inherits the responsibility to handle that data carefully. Scope narrowly. Restrict sharing. Review who can use the agent. See [Privacy & Security](/docs/privacy-and-security).

Where to go next