Build the teammate you wish you had
There’s a moment, after using VDF AI Agents for a while, when you realize the agent you really want doesn’t quite exist yet. A specialist for your team’s onboarding-email format. A drafter that knows your team’s release-note structure cold. A summarizer that always uses your team’s three favorite headings.
That’s the moment to build one.
The good news: building an agent is much closer to “writing a clear job description” than it is to “configuring software.” If you can describe what you want a teammate to do, you can build an agent.
Start smaller than you think. The best first agent is one that does one job well — not one that handles ten things adequately. You can always expand.
Three paths to a new agent
You don’t have to start from a blank page. Pick the path that fits where you are.
Start from a template
Pick a pre-built agent from the library and customize it. Fastest path, lowest risk.
Start from scratch
You know exactly what you want. Set the instructions, pick the tools, and ship.
Let VDF AI guide you
Describe the kind of agent you want; VDF AI walks you through the choices conversationally and assembles the agent at the end.
Path 1 — Start from a template
The fastest way to a working agent. Open the agent library, find one that’s close to what you want, click Customize, and you have your own copy.
From there, you can:
- Change the instructions. Adjust how the agent introduces itself, how it asks for context, how it shapes output.
- Swap or add tools. Add a knowledge source from VDF AI Data. Remove a tool you don’t need.
- Update the audience. Maybe the template is generic; your team has a specific audience in mind.
- Save under a new name. The original template stays untouched.
This path works best when you have a rough idea of what you want and the library has something nearby. Most teams’ first three or four agents are forks of templates.
Path 2 — Start from scratch
When you know exactly what the agent should do — the job, the audience, the output, the tone — start from scratch is the right path.
You’ll fill in a short form:
- Name and description. “Release-note drafter for the platform team.”
- Instructions. The agent’s job, in plain language. This is the most important field; spend time on it.
- Knowledge sources. Optional. Connect a folder, a vector index, a connected app.
- Tools. Which tools the agent can use mid-conversation.
- Model preference. Auto, or pin a specific model. See Choosing a model.
Start from scratch is the right path when:
- You have a clear sense of the exact deliverable.
- The library doesn’t have a close starting point.
- You want to capture a team-specific way of doing things from the first version.
A useful starting structure for instructions
The instructions field is where most of the work goes. A pattern that produces strong agents:
- Identity. “You are a release-note drafter for the platform team.”
- Goal. “Your job is to turn a list of merged pull requests into a release note our customers can read.”
- Audience. “Customers reading the release note are technical, but not in our codebase. Aim for clarity over jargon.”
- Format. “Always use three sections: New, Improved, Fixed. Two-to-three lines per item. No marketing language.”
- Constraints. “Skip any internal-only changes. If a change doesn’t affect customers, don’t mention it.”
That’s it. Most great agents fit on a short page.
Path 3 — Let VDF AI guide you
If you have a sense of what you want but find a blank instructions field intimidating, the guided path takes you there conversationally.
You describe what the agent is for in your own words. VDF AI asks clarifying questions:
- “Who’s the audience?”
- “What does the output look like?”
- “Are there things the agent should never do?”
- “Where should the agent get its source material from?”
As you answer, VDF AI assembles the instructions, suggests tools and knowledge sources, and proposes a model preference. At the end you see the full agent definition and can edit anything before saving.
This path is great when:
- You’re new to building agents.
- You have a clear job but find writing instructions stressful.
- You want a sanity check on your instructions from a colleague — even an AI one.
The guided path produces editable agents. Whatever VDF AI proposes is a starting point. You can tweak every field afterward, exactly like an agent you built from scratch.
What to decide as you build
Whichever path you take, the same handful of decisions show up.
What’s the job?
The most important decision and the one most often skipped. “Help with marketing” is too broad. “Draft the headline and three bullets for our weekly customer email” is sharp.
A useful test: could someone else, reading only the instructions, run this agent and get a similar result to what you’d get? If yes, the instructions are clear. If no, tighten them.
Who’s the audience?
A draft for an exec reads differently than a draft for an engineer than a draft for a customer. State the audience explicitly. It’s the single tweak that produces the biggest jump in output quality.
What format does the output take?
Bullets? Paragraphs? A table? Headings? Be specific. Vague instructions produce vague output.
What sources should the agent know about?
A great agent without context is still pretty good. A great agent with the right knowledge source is dramatically better. If your team’s voice or facts live somewhere — a Confluence space, a vector index, a folder in Data — connect it. See Tools and knowledge.
What tools should the agent be allowed to use?
Most agents need only one or two tools. Web search if the agent should look things up. Document generation if it should produce files. Knowledge search if it should look in your team’s material. See Tool catalog for the full list.
Should the agent feel formal or casual?
State the tone in the instructions. “Direct, friendly, no emoji” is enough. The model picks up tone from short cues.
A short build flow that works
If you’ve never built an agent, this sequence usually produces a good first one inside half an hour.
-
Pick a recurring deliverable your team produces.
The Monday update. The release note. The customer summary. The intake form.
-
Write the instructions in one short paragraph.
Identity, goal, audience, format, constraints. A page max.
-
Connect one knowledge source.
If the deliverable depends on context — past examples, a style guide — connect it.
-
Test with a real input.
Run the agent on a real recent example. Read the output critically.
-
Tighten the instructions based on what you saw.
Where did the output drift? Add a constraint that prevents it.
-
Save and use it for a week.
The best refinement comes from real use, not from imagined use.
-
Share with your team.
See [Sharing and publishing](/docs/products/vdf-ai-agents/sharing-and-publishing) for how.
A few patterns that work
Name the agent by the deliverable, not the topic
“Weekly customer digest writer” is better than “Customer success agent.” Future teammates will pick the right agent faster.
Keep the instructions short
A page of clear instructions beats five pages of comprehensive instructions. Long instructions often contradict themselves and produce muddier output.
Constrain explicitly
“Never include speculative claims.” “Always cite the source for any number.” “Stop after three paragraphs.” Constraints sharpen output more than expansive context does.
Test on the hardest input, not the easiest
A new agent that handles your hardest recurring input well will handle the easy ones effortlessly. Don’t tune on easy cases — they’ll work no matter what.
Don't make one agent that does everything. The temptation to keep adding capabilities is real. Resist it. Two sharp agents beat one fuzzy one. If the second job is genuinely different — different audience, different output, different sources — make a second agent.
Where to go next
- Agent library — the pre-built starting points.
- Choosing a model — pick the right model for your agent.
- Tools and knowledge — give your agent what it needs to do its job.
- Sharing and publishing — make your agent available to the rest of the team.