July 27th, 2026

Research Report Agent

Research

Tools

Briefs

Sources

6 min read

The problem

Most research workflows still look like a pile of open tabs. You ask a broad question, skim half a dozen pages, and try to remember which claim came from where. A Research Report Agent turns that into a repeatable loop: take a question, gather evidence with tools, and return a brief a human can actually use.

Success looks like a short report with a one-paragraph summary, 3–7 key findings, explicit open questions, and a source list grounded in what the tools returned — not a wall of unattributed prose.

Paste into Claude, Codex, Cursor, or another coding agent to scaffold this harness.

# Context: Vidbyte SDK

Vidbyte SDK is a Python package (import as `vidbyte`) for building agent workflows yourself.

Use it when you want to own the agent loop: system prompts, model/provider choice, tools, managed context, middleware, pipelines, tracing, evals, and multi-agent composition.

Core mental model:
1. Create an Agent or BaseAgent.
2. Attach a system prompt, provider/model, optional tools, context, middleware, and runtime choices.
3. Call run() or arun().
4. Let the SDK handle message assembly, tool schemas/calls, iteration limits, and optional pipelines.

Public package boundary: reusable local agent infrastructure. It does not ship private Vidbyte learning models or proprietary platform internals.

GitHub: https://github.com/cerredz/Vidbyte-SDK
Install: pip install vidbyte-sdk
Verify: python -c "from vidbyte import Agent, BaseAgent, tool; print(Agent, BaseAgent, callable(tool))"

# Install

Primary:
```bash
pip install vidbyte-sdk
```

From a checkout (pre-release / local development):
```bash
git clone https://github.com/cerredz/Vidbyte-SDK.git
cd Vidbyte-SDK
pip install -e .
```

# Task: Build a Research Report Agent

Build a Vidbyte SDK agent that researches a topic and returns a clear brief with sources.

Scenario: A founder asks "What are the main approaches teams use for AI code review in 2026?" The agent should gather notes, compare angles, and produce a short report a human can scan in under five minutes.

The harness should:
- Accept a research question as input
- Use tools (or stub tools) for search / fetch-style work
- Iterate until it has enough evidence or hits a limit
- Write a structured brief: summary, key findings, open questions, sources

Constraints:
- Use Agent or BaseAgent from the vidbyte package
- Keep the report scannable (short sections, bullet findings)
- Cite sources or tool results explicitly; do not invent URLs
- Prefer async arun() if the example is async

# Deliverable

Produce a small, runnable Python harness that uses the Vidbyte SDK (`vidbyte` package) to implement this agent. Prefer clear modules, a main entrypoint, and short comments that explain the control flow. Do not invent private Vidbyte backend APIs.

Build it step by step

Create the researcher agent

Start with an Agent that knows it is writing a short, sourced brief — not an essay. Keep the system prompt focused on evidence, uncertainty, and structure.

from vidbyte import Agent

agent = Agent(
    name="research-reporter",
    system_prompt=(
        "Research the question carefully. "
        "Return a brief with: summary, key findings, open questions, and sources. "
        "Cite tool results. Mark uncertainty explicitly."
    ),
    provider="openai",
    model_name="gpt-4.1",
)

Add search or fetch tools

Give the agent a way to gather notes. In a real harness these might call a search API or HTTP fetch; here a small @tool keeps the pattern clear.

from vidbyte import tool

@tool
def search_notes(query: str) -> list[dict]:
    """Return stub research notes for a query."""
    return [
        {"title": "Example source A", "snippet": f"Notes about {query}", "url": "https://example.com/a"},
        {"title": "Example source B", "snippet": "Contrasting viewpoint", "url": "https://example.com/b"},
    ]

agent = Agent(
    name="research-reporter",
    system_prompt="Use search_notes before writing findings.",
    provider="openai",
    model_name="gpt-4.1",
    tools=[search_notes],
)

03
Run the research question
Pass the user question into arun(). The SDK assembles messages, exposes tool schemas, and runs the tool loop until the agent answers or hits limits.
```
question = "What are common AI code review approaches in 2026?"
reply = await agent.arun(question)
print(reply.content)
```

Shape the brief format

Tighten the prompt so every run returns the same sections. Consistency is what makes the agent useful as a weekly research habit.

system_prompt = """
You write research briefs. Always use these headings:

## Summary
## Key findings
## Open questions
## Sources

Each finding should be one or two sentences and name its source.
If evidence is weak, say so under Open questions.
"""

Optional: split research and writing

For longer topics, use two agents — one that collects notes and one that synthesizes. Multi-agent or pipeline composition keeps each role simple.

from vidbyte import BaseAgent, MultiAgent, MultiAgentSettings

researcher = BaseAgent(
    name="collector",
    system_prompt="Collect evidence and return notes with sources.",
    provider="openai",
    model_name="gpt-4.1",
)
writer = BaseAgent(
    name="writer",
    system_prompt="Turn notes into a scannable research brief.",
    provider="openai",
    model_name="gpt-4.1",
)
# Wire MultiAgent or a pipeline so the writer only sees collected notes.