Give a CrewAI Agent Fresh Web Context 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

CrewAI works well when the roles are clear: one agent plans, another researches, and another writes. But the research role still needs a live source of truth. Without that, the workflow degenerates into plausible-sounding summaries of stale assumptions.

Prismfy is a clean way to supply that research step. It gives a CrewAI agent a runtime search call to the public web, which means the workflow can fetch current pages, compare sources, and pass concrete evidence to the rest of the team.

Why this matters now

The more specialized your agent team becomes, the more likely one role will be responsible for the latest facts. That role cannot depend on a frozen embedding store if the task is about current pricing, product pages, documentation updates, or launch signals.

Prismfy keeps the research role focused. It does not replace the team structure. It just gives the research agent a direct path to fresh public context when the task calls for it.

Step-by-step solution

1. Define a research tool that wraps POST /v1/search.
2. Let the planner agent decide when the research tool should be used.
3. Query by intent, not by raw keywords. Search for the question the user is actually asking.
4. Pass the result snippets to the writer or analyst agent in a compact format.
5. Keep the final output grounded in URLs and short evidence snippets, not in generic web summaries.

Code example

This example shows a simple CrewAI-friendly research tool in Python. The tool can be passed to whichever role needs current public-web evidence.

import os
import requests
from crewai import Agent, Task, Crew

def prismfy_web_search(query: str, domain: str | None = None):
    payload = {
        "query": query,
        "page": 1,
        "timeRange": "month",
    }
    if domain:
        payload["domain"] = domain

    response = requests.post(
        "https://api.prismfy.io/v1/search",
        headers={
            "Authorization": f"Bearer {os.environ['PRISMFY_API_KEY']}",
            "Content-Type": "application/json",
        },
        json=payload,
        timeout=30,
    )
    response.raise_for_status()
    data = response.json()

    return [
        {
            "title": item["title"],
            "url": item["url"],
            "snippet": item["content"][:250],
            "engine": item["engine"],
        }
        for item in data["results"][:5]
    ]

researcher = Agent(
    role="Researcher",
    goal="Collect fresh public-web evidence for the task",
    backstory="You verify current claims with live search before handing off to the writer.",
)

task = Task(
    description=(
        "Research the latest public information about the topic. "
        "Use the search tool when the question depends on current web data."
    ),
    agent=researcher,
)

crew = Crew(
    agents=[researcher],
    tasks=[task],
)

In practice, the research agent can call prismfy_web_search() with a scoped query such as company name pricing page, docs domain changelog, or feature launch public announcement. The output is already structured for downstream use: title, URL, snippet, and engine.

If you want a more explicit handoff, keep the writer agent's prompt simple: it should only use the evidence supplied by the researcher and should mention when the evidence is incomplete. That pattern prevents the crew from inflating weak search results into a strong conclusion.

Practical notes and caveats

CrewAI workflows can become noisy when tools are too permissive. Resist the urge to make the search tool a catch-all research universe. It should do one thing well: return current public sources that your agents can reason over.

Scope matters. Use domain when the question is about a known site, and use timeRange when recent public changes matter. That keeps the evidence set relevant and shortens the path from search to answer.

Also, treat caching as an implementation detail, not a truth claim. Cached results may be useful for repeated workflows, but the agent should still reason from the retrieved evidence and not assume that every earlier answer is still valid.

Why Prismfy fits this workflow

Prismfy fits CrewAI because it adds fresh public-web context at the exact point the research role needs it. The planner can stay high-level, the researcher can stay evidence-focused, and the writer can stay grounded.

That division of labor is the real value: Prismfy gives the research step a public search API, which keeps the entire crew aligned with current sources instead of stale assumptions.

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

• Add Real-Time Web Search to an OpenAI Agent Workflow with Prismfy
• Build a ReAct Search Agent in Python 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.