Skip to main content

Gate content creation with ai_context

Left on its own, blobby will happily generate a new query, tile, or dashboard for a question your organization has already answered. This guide walks through a pattern for model-level ai_context that puts checks in front of that behavior: look for existing content first, reuse a saved skill instead of writing raw fields, and pause for a person to approve a plan before anything gets built or run. It also covers where to set a rough AI-credit estimate on that approval step, and how to tell whether the gates are actually holding once they’re live. This is especially relevant if:
  • Your organization is seeing AI credit costs climb because people are rebuilding dashboards and apps that already exist
  • You want blobby to check saved content and skills before it generates a new query, on every request rather than only when someone happens to ask
  • You want a plan-and-approve step in front of dashboard, app, or query creation, particularly for less experienced users

Why gate before you build

blobby already does some of this by default. Before it generates a new query, the Omni Agent searches dashboard names and tile titles for content that might already answer the question, and surfaces a highlighted card when it finds a direct match. That default search is a good baseline, but it only covers dashboards, and it’s a suggestion blobby weighs alongside everything else in its context — not a rule it’s forced to obey.

What ai_context adds on top

ai_context lets you turn that baseline behavior into an explicit, ordered sequence: check content, then check skills, then draft a plan and wait for approval before creating or modifying anything. None of the later steps — skill reuse, plan drafting, approval gates — exist as defaults. You have to ask for them.

What ai_context can’t guarantee

ai_context from the model, topic, and view levels is all passed to the LLM together, and the LLM decides how much weight to give each instruction. It can partially follow a gate, fully follow it, or occasionally skip it — especially when instructions are long or contradictory. Treat the pattern in this guide as a strong nudge that holds up well in practice, not as an enforcement mechanism. The last section covers how to pair it with settings that actually enforce a boundary.

Start with direct term-to-destination routing

The simplest version of this pattern doesn’t search at all - it routes known terms straight to the content that already answers them. If your organization already knows that any question about QBRs, your CRM pipeline, or your executive numbers has one canonical answer, tell blobby to stop and point there instead of reasoning about it:
Direct routing for known terms
This is a good starting point precisely because it’s so constrained: there’s no search step to skip and no plan for blobby to misjudge, just a short list of terms mapped to fixed destinations. The tradeoff is that it only covers the terms you list - anything outside that list falls through to blobby’s normal behavior, including the search-and-plan pattern below if you’ve also added it. Treat direct routing as a fast lane for your highest-traffic, most duplicated questions, and the search-first pattern as the fallback for everything else.
This is still ai_context, so the same limitation from the previous section applies: it’s a strong instruction, not a hard redirect. Confirm it’s actually firing with the workbook inspector before relying on it for your highest-traffic terms.

Write content-first gates in ai_context

For questions that aren’t on a fixed list, the next step up is asking blobby to search before it builds, rather than routing to a fixed destination. The instructions below come from testing this pattern against a live model. The first version described the checks in loose prose; the second tightened them into an ordered list and named the specific action to gate.

Order the gates as steps, and give blobby an exit

A single paragraph of guidance competes with everything else in the context window for attention. Numbering the checks, and telling blobby explicitly not to skip ahead, keeps the sequence intact:
First pass: plain-language steps
This version works, but it reads as a description of the desired outcome rather than a sequence blobby must follow in order. Numbering the steps and adding language like “do not skip ahead” and “only skip if” makes the sequence explicit and gives blobby a defined condition for leaving it:
Second pass: ordered gates with an exit condition

Name the exact action you want gated

Vague verbs like “check first” leave room for blobby to interpret what counts as checking. Naming the concrete action — content search, a specific tool, a specific setting — removes that ambiguity. Omni’s own documentation uses this same technique: the chain-of-thought example in Optimize models for Omni AI explicitly references the GenerateQuery tool by name so blobby knows exactly which action to pause before. If you want a gate to be unconditional rather than a strong suggestion, ai_context isn’t the right layer for it. The ai_settings.disabled_tools model parameter removes a tool entirely — for example, create_dashboard_from_chat turns off dashboard creation from chat outright, with no prompt-level workaround. Reach for ai_context when you want blobby to check first and ask; reach for disabled_tools when the answer needs to always be no.

Add a rough AI-credit estimate to the approval step

Once blobby is pausing for approval, that’s a natural place to also show a rough cost. One AI credit equals $1, and credit usage varies with task complexity, model tier, and how much context the model carries, so any number you generate before running the plan is necessarily an estimate.
Don’t ask blobby to state a single precise dollar figure as if it were a bill. A false-precise number is worse than a clearly labeled range, and actual usage can vary between runs of the same prompt.
Extend the plan step with language like the following:
Adding a credit estimate to the approval step
The estimate in chat is meant to set expectations before a build runs, not to replace tracked usage. The Credit Tracking dashboard in AI Hub shows actual consumption by feature and by user, and it’s the number to check after the fact rather than the range blobby quoted beforehand.

Check whether the gates are actually holding

Because ai_context is guidance rather than a strict rule, it’s worth confirming what blobby actually did with it before relying on the pattern in production.

Debug with the workbook inspector

The workbook inspector shows the context a given AI session actually received and the tool calls it made. Use it to confirm blobby is genuinely searching content and skills before generating a query, rather than skipping the check and generating anyway. If a gate isn’t holding, it’s usually because the model’s other context — sample queries, topic descriptions, a long conversation history — is competing for attention; trimming that context can help the gate surface more consistently.

Pair soft gates with hard controls

For anything that needs to hold every time, back the ai_context pattern with settings that don’t depend on the LLM choosing to follow them: ai_context steers what blobby chooses to do; these settings limit what it’s able to do at all. Use both together rather than treating one as a substitute for the other.

Next steps