Research & Development — Open Source

Open Deep
Research API

A modular, multi-agency framework for building sophisticated AI-powered research systems. Autonomous agents that plan, search, scrape, rank, and synthesize — streaming cited reports in real time.

Status
Live / Open Source
Core Framework
FastAPI + Pydantic V2
Streaming Protocol
WebSockets
License
Open Contribution
01What is ODR

Research that thinks,
not just retrieves

The Open Deep Research API is a production-grade framework built by Luminary AI Solutions for constructing autonomous research pipelines. Unlike naive RAG systems that retrieve and paste, ODR orchestrates a multi-agent workflow that plans its own research strategy, executes targeted web searches, scrapes and ranks content, and writes — then refines — a cited analytical report.

Built for extensibility: each "Agency" is a self-contained domain module. Ship the deep research agency today; plug in a financial analysis or legal review agency tomorrow — all sharing the same core services.

Multi-Agency Architecture
Distinct research domains organized as independent agencies, each with its own orchestration logic and specialized agents.
Iterative Refinement Loop
The Refiner agent processes only new information per cycle, preventing context bloat while progressively improving report quality.
Pydantic-Validated LLM Output
All agent inputs and outputs are validated against strict Pydantic schemas — no free-form parsing, no hallucinated structures.
Real-Time Streaming
WebSocket-based progress updates surface each pipeline step as it happens — planning, searching, writing, refining — live.
Advanced Content Processing
Crawl4AI scraping, semantic chunking, and Together AI reranking ensure only the highest-signal content reaches the LLM.
02Architecture

From query to
cited intelligence

01
Plan
Planner agent decomposes the query into a WritingPlan and discrete SearchTasks
LLM Agent
02
Search
Serper API executes each search task; results reranked by Together AI
Service
03
Scrape
Crawl4AI fetches full content; Summarizer agent or chunking pipeline extracts signal
Service + LLM
04
Write
Writer agent drafts report using processed context; flags gaps with SearchRequest tags
LLM Agent
05
Refine
Loop: new searches executed, Refiner integrates only fresh info into the draft
LLM Agent
06
Finalize
Citations formatted, reference list appended, report streamed over WebSocket
Service
API Layer
FastAPI
Async Python 3.10+, uvicorn
Validation
Pydantic V2
All agent I/O schema-validated
Web Scraping
Crawl4AI
JS rendering + PDF parsing
Search
Serper API
Swappable provider interface
Reranking
Together AI
Cross-encoder chunk ranking
Persistence
Firestore
Optional task state storage
03Live Demo

See it
in action

The ODR frontend is a working demonstration of the API running in production. Submit a research query and watch the multi-agent pipeline execute in real time — plan, search, scrape, write, refine, deliver.

Open Deep Research Demo
Liveodr.luminarysolutions.ai
Open Deep Research — Frontend
Submit any research query and observe the full autonomous pipeline: real-time WebSocket updates surface each agent step as it executes, culminating in a fully cited analytical report.
Launch demo →
WebSocket Protocol
Streaming Step Events
Each pipeline transition emits a typed event: PLANNING → SEARCHING → RANKING → PROCESSING → WRITING → REFINING → COMPLETE. Clients receive live status and can render progress as it happens.
Configurable
Per-Request LLM Overrides
Every agent's LLM config — model, temperature, max tokens — can be overridden at the request level. Mix Sonnet for writing, Haiku for summarizing, and any OpenRouter model for planning.
04Open Source

Built to be
extended

ODR is our commitment to advancing the agentic research ecosystem. The architecture is deliberately designed for contribution: add a new Agency directory, define your orchestrator and agents, wire up to shared services, and you have a domain-specific research system without reinventing the wheel.

Financial analysis, legal review, competitive intelligence, scientific literature — each is a new agency. The infrastructure is already there.

View Repository
ws_client.py
# Connect and submit a research query
import asyncio, websockets, json

async def research(query):
    uri = "wss://odr.luminarysolutions.ai"
    uri += "/deep_research/ws/research"

    async with websockets.connect(uri) as ws:
        await ws.send(json.dumps({
            "query": query,
            "max_search_tasks": 5
        }))

        async for msg in ws:
            event = json.loads(msg)
            print(f"[{event['step']}] {event['message']}")

            if event["step"] == "COMPLETE":
                break

asyncio.run(research("your query here"))
Python
Language
MIT
License
FastAPI
Framework
05Research Direction

Where we're
pushing next

ODR is active R&D infrastructure. These are the frontiers we're actively exploring as we expand the framework toward production-grade agentic research at scale.

I
Domain-Specific Agencies
Financial analysis, legal document review, and scientific literature synthesis — each requiring unique agent roles, specialized data sources, and domain-tuned ranking logic.
II
Pydantic-AI Tool Integration
The LLM tool directory is architected but intentionally empty — the next frontier is giving agents callable tools: calculators, code executors, structured data extractors.
III
Multi-Provider LLM Routing
Expanding beyond OpenRouter to native support for Anthropic, Gemini, and local models — each routable per-agent based on task type, latency requirements, and cost constraints.

Build your own
research agency

ODR is production-ready infrastructure. Fork it, add your agency, and deploy a custom AI research system in days — not months. Or engage Luminary AI Solutions to build a bespoke system around your workflows.