How you brief it
The knowledge base is how you brief the agent. Each organization has its own, organized into fixed areas: persona, voice and tone, policies, glossary, knowledge, procedures, channels and skills. Your agent’s context explains what each one governs. The agent reads from this knowledge base to answer in your voice and stay inside your rules, no matter which initiative the conversation is part of. Once your agent is set up, you change what it knows and how it behaves in Agent Studio, or from an AI tool connected over MCP: see your agent’s context. Every change goes through a draft and a review before customers see it. To prepare the first version from scratch, thebuild-knowledge-base skill runs a guided interview: it asks what it
needs, researches your own site, and hands you a structured bundle to pass to
Boom.
On top of the knowledge base, each initiative carries its own per-initiative
context and guiding questions, the specifics of that one mission. The
knowledge base is the constant across every conversation; the per-initiative
layer is what changes from mission to mission.
What it knows about the person it is talking to
An initiative’scontext is a briefing, not a template. Nothing in it is
interpolated, so writing a placeholder there gets you the literal text and no
value. Facts about the individual reach the conversation two different ways, and
the difference matters when you are designing around them.
Pushed in, on every turn. Whatever you supplied when you enrolled that
person, plus anything the trigger carried, is part of the agent’s context from
the first message onward. This is the dependable path: no lookup, no decision,
nothing to enable. Use it for anything that should shape how the conversation
opens.
Fetched, if the agent decides to. The agent can also read live data from your
CDP mid-conversation, which is what makes it useful for
questions that only come up because the conversation went there. Three things
gate it, so do not design an opener around it: the CDP read tools are entitled
per organization and are not on by default, only the first few person
attributes are listed for the agent up front, and naming a field in your briefing
does not compel the agent to go look it up.
Fetched from your own systems. Your CDP is not the only live source. You can
give the agent a tool that calls one of your own HTTP endpoints — an order lookup,
an account status — and it will call it mid-conversation when the question calls for
it. You define the endpoint, the arguments the agent may fill in, and, importantly,
exactly which fields of the response the agent is allowed to see: everything
else is discarded before it reads the answer, so a record carrying an email and a
phone number does not put them in front of the agent because you needed a status.
Authentication belongs in a stored credential rather than a header you type: a
credential is encrypted, resolved per environment when the tool runs, and its value
is never shown back to you or to the agent.
When your organization has more than one environment, the tool uses the org’s
default environment until per-conversation environments are enabled for your
organization (ask your Boom contact). Once they are, the tool calls the
environment that belongs to the conversation, so a conversation from a registered
test number can reach your staging system while customers keep reaching
production. If the tool needs a variable or credential that environment does not
have, the agent is told the action is not set up and hands off instead of
guessing. Saving a tool warns you about those gaps up front, and the tool’s
Test lets you pick the environment to run against.
The same screen runs the tool against your real endpoint before any customer sees
it, and lets you save a canned response for testing — including a failure response,
which is the one worth writing. It is how you check the agent says it could not look
something up instead of inventing an answer.
Fields that must ride along with a search hit
A CDP search answers which object matched — id, display name, type, relevance — and nothing about it. That is usually right: the agent reads the object when it needs details. But some attributes are ones an answer cannot be assembled without, and the classic case is a URL slug. Given a product’s name and no slug, a model can produce a link that looks plausible and resolves to the wrong page, or to nothing. Name those attributes and every search hit carries them:attributes object with just those keys. The
selection is replaced on each call, and {"attributeKeys":[]} clears it.
Keep the list to two or three. Every named key is fetched for every result, so
this is a way to close a specific gap — not a projection API for pulling a whole
record through search. Keys must already exist in the type’s attribute catalog,
which is built from data you have actually sent; a key you have never upserted is
rejected rather than silently ignored.
This changes what the agent is given, not what it is told. It is the more
reliable of the two: an instruction to look a field up can be skipped, whereas a
field present in the result cannot be missed.
How it improves from feedback
When someone on your team gives a thumbs-down to an agent message and says what was wrong, that feedback reaches Boom with the conversation it came from. We look at what the agent was given and why it answered that way, and fix the right layer: often the agent’s context, sometimes an initiative’s setup, sometimes a defect on our side. When the fix is a change to the agent’s context, it comes with a test: a short conversation based on the one you flagged, plus what the reply must do instead. Every change to your agent is checked against its tests before it goes live, so a fix that would break an earlier one is caught in review. You can make these changes yourself too, with a test for each one: see your agent’s context.When it hands off to a person
The agent handles a conversation end to end when it can, and escalates the ones it shouldn’t handle. Escalated conversations land in a shared inbox where a person can take one over: reply, leave internal notes, and send or receive files. The customer’s attributes sit alongside the conversation, so whoever picks it up has context without asking the customer to repeat themselves.Guardrails while it talks
Before the agent responds, the conversation is checked for prompt injection. Before a response goes out, it’s reviewed to stop it from sharing personal data it shouldn’t.Reliability
Messages are queued and retried with spacing rather than sent in a burst. If the primary model provider goes down, Boom falls back to another one so conversations don’t stall.Related
Journeys
The workflow behind an initiative, and how you author and publish one.
Extraction
The typed fields the agent pulls out of a conversation, and how you read
them back.
Customer Data Platform
The people, objects, and events behind the data schemas in the
knowledge base.
Use MCP
Connect an AI tool to the same organization and capabilities.