Atlas — Autonomous Research Agent

Motivation

Most "AI research" demos are a single search call wrapped around an LLM — they answer fast but can't tell you how they got there, and they happily hallucinate. I wanted to build something that works like a careful analyst: break the question down, gather real evidence, challenge its own conclusions, and cite every claim.

The goal was an agentic system — multiple specialized agents collaborating through an orchestration layer — that a startup founder could look at and think "this person understands how to build production AI, not just call an API." And it had to run for free, so anyone can reproduce it.

Demo

A full run on the query "What is a multi-agent workflow and how can anyone build one for free?" — watch the agents plan, search, self-critique, and stream a cited report in real time.

2-minute end-to-end walkthrough: plan → research → critique → cited report.

Architecture

Atlas is a linear multi-agent pipeline. Each agent has one job, and a critic loop lets the system send itself back to do more research when coverage is thin — the behavior that makes it "agentic" rather than a one-shot chain.

• Web search via Brave API with an automatic DuckDuckGo fallback (no key needed).
• Content extraction via Jina Reader → clean Markdown, with a BeautifulSoup fallback.
• Provider-agnostic LLM layer (Gemini / Groq / OpenAI) behind one client, with per-model failover and rate-limit-aware pacing to survive free-tier quotas.

What I built

• A Planner agent that turns a broad question into focused, independently-researchable sub-questions, each with concrete search queries.
• A Researcher agent that searches, reads top sources, and extracts source-attributed facts — it can only cite pages it actually read, so it can't invent references.
• A Critic agent that reviews coverage, flags gaps and conflicts, and triggers follow-up research — a genuine self-correction loop.
• A Synthesizer agent that streams a structured, inline-cited Markdown report with a confidence assessment.
• An evaluation harness scoring citation quality, an LLM-as-judge rubric (accuracy / completeness / coherence), and speed across a curated query suite.
• A polished Streamlit UI with live agent-stage updates, a source-credibility view, and per-run telemetry (tokens, calls, latency, production-equivalent cost).

Results

A representative run produced a fully-cited, multi-section report with conflicting-source handling — for a fraction of a cent in production-equivalent cost, and $0 on free tiers.

Challenges

• Free-tier rate limits: bursting calls to one model tripped per-minute quotas. I added request pacing, retry-delay parsing, and cross-model failover so the pipeline degrades gracefully instead of failing.
• Hallucinated citations: solved by forcing the LLM to reference only numbered sources it was handed, then mapping each fact back to a real URL.
• Corporate TLS interception: HTTPS calls failed behind a TLS-inspecting proxy; routing verification through the OS trust store fixed it without weakening security.
• Perceived hangs: a blocked endpoint stalled on the SDK's long default timeout — tightened timeouts plus live progress so the UI always shows what's happening.

Learnings

• Orchestration beats model choice. The structure — decompose, gather, critique, synthesize — mattered far more than which LLM sat underneath.
• Self-critique is cheap and powerful. One critic loop measurably improved coverage for a couple of extra calls.
• Production-mindedness is a feature. Surfacing cost, latency, and source credibility makes the system legible — and signals real engineering, not a toy.
• Design for the free tier. Pacing and failover turned an unreliable demo into something anyone can run for $0.