Add Real-Time Web Search to an OpenAI Agent Workflow with Prismfy

This guide shows a practical way to use Prismfy as a live web search API inside an agent workflow so your assistant can fetch fresh public evidence instead of relying on stale model memory.

Problem framing

An agent that only reasons over static prompts or a frozen knowledge base will drift the moment the task depends on current facts. Product pages change, docs get updated, and launch announcements land after your model was trained. The result is a familiar failure mode: the agent sounds confident, but its evidence is stale.

Prismfy solves the retrieval side of that problem by giving your agent a simple public-web search step. Your workflow can ask Prismfy for live results, extract the relevant snippets, and feed them back into the model as evidence. That keeps the agent grounded without making you build a crawler, an index, or a custom search backend.

Why this matters now

Agent workflows are moving from demos to production. That changes the bar. A useful agent is not just one that can call tools; it is one that knows when to call them and how to handle time-sensitive questions.

If the question is about current pricing, a docs update, a launch note, or a competitor's public page, the right pattern is usually:

• detect that the answer depends on current public information,
• query live search,
• pass a compact evidence set to the model,
• answer with citations or source-aware reasoning.

That is a much better fit than stuffing every possible source into a retriever and hoping the index stays fresh.

Step-by-step solution

1. Keep the agent's core instructions narrow. Tell it that Prismfy is the tool for public-web lookup, not the answer source itself.
2. Normalize the question into a search query. Remove filler, keep the entities, and add a domain if the request is scoped to a known site.
3. Call POST /v1/search at runtime. Use timeRange when freshness matters, and use domain when you want to constrain the result set to a docs site or product page.
4. Trim the response before giving it to the model. Agents work better when they see a small set of high-signal snippets instead of a wall of HTML-ish text.
5. Ask the model to answer from evidence, not memory. If the search results are weak, have the agent say so and try a better query rather than inventing details.

Code example

The example below uses TypeScript because OpenAI agent workflows are commonly built in Node, and Prismfy also exposes a straightforward HTTP API. The search call is the only Prismfy dependency here.

type PrismfyResult = {
  results: Array<{
    title: string
    url: string
    content: string
    engine: string
  }>
  cached: boolean
  query: string
}

async function prismfySearch(query: string, domain?: string) {
  const response = await fetch('https://api.prismfy.io/v1/search', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.PRISMFY_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      query,
      domain,
      timeRange: 'month',
      page: 1,
    }),
  })

  if (!response.ok) {
    throw new Error(`Prismfy search failed: ${response.status}`)
  }

  return (await response.json()) as PrismfyResult
}

function formatEvidence(results: PrismfyResult) {
  return results.results.slice(0, 5).map((item, index) => ({
    id: index + 1,
    title: item.title,
    url: item.url,
    snippet: item.content.slice(0, 280),
    engine: item.engine,
  }))
}

async function answerWithSearch(question: string) {
  const query = `latest public info about ${question}`
  const search = await prismfySearch(query)
  const evidence = formatEvidence(search)

  // Send evidence to your OpenAI model here.
  // Keep the answer constrained to the retrieved sources.
  return {
    question,
    evidence,
    instruction:
      'Answer only from the evidence. If evidence is weak, say what is missing.',
  }
}

If you want the same pattern in a tighter loop, call Prismfy only after the model decides it needs current information. That keeps cost down and makes the agent's behavior easier to reason about. For a docs-scoped assistant, pass domain: 'docs.example.com' or the relevant public docs host. For a competitor watch workflow, use timeRange: 'week' or timeRange: 'month' so the agent prefers recent public pages.

Practical notes and caveats

Prismfy is a web search API, so treat it like a live evidence source, not a memory layer. The model still needs a prompt that tells it how to weigh search snippets, how to handle conflicting sources, and when to admit uncertainty.

Do not overstuff the model context with every result. The best pattern is usually one query, a few strong results, and a final answer that cites the most relevant source URLs.

If the workflow is domain-specific, add a domain filter early. It reduces noise and gives the agent a better chance of extracting exactly the page you care about. If you are looking for current public changes, pair that with a freshness filter rather than relying on generic search terms.

Why Prismfy fits this workflow

Prismfy fits because it stays close to the problem agent builders actually have: they need live public-web context at runtime, not another general-purpose orchestration layer. You send POST /v1/search, receive structured results back, and decide how to fold them into your agent.

That makes Prismfy easy to place in an OpenAI workflow as a retrieval step, a routing step, or a fallback when the model needs up-to-date public evidence.

FAQ

When should an agent call web search instead of answering from memory?

Use live search when the task depends on current public information such as pricing pages, release notes, launch posts, or documentation updates. That is the safest time to route the agent workflow through Prismfy instead of relying on model memory alone.

Can Prismfy work as a tool inside an agent loop?

Yes. Prismfy is easiest to use as a runtime search step: the agent decides a question is time-sensitive, calls POST /v1/search, trims the returned evidence, and answers from those public sources.

Related Prismfy guides

• Build a ReAct Search Agent in Python with Prismfy
• Add Live Web Search to a LangGraph Agent with Prismfy
• Prismfy + LangChain: When to Use Web Search Instead of a Retriever

Try Prismfy

Create a Prismfy key, test POST /v1/search, and wire the search step into the workflow you care about first.