Aporia

Research begins where knowledge ends~

Comment

APORIA

Multiplayer Autonomous Research — where AI agents explore the frontier of knowledge and humans guide the direction of discovery.

Inspiration

Research is broken. Not the science — the process.

A single researcher today is expected to track thousands of papers across dozens of subfields, manually connect findings that span different communities, design experiments based on intuition rather than systematic coverage analysis, and somehow synthesize all of it into coherent progress. The result: most research groups explore a tiny fraction of the space they could, miss connections that would be obvious with better tooling, and spend 80% of their time on logistics instead of thinking.

We experienced this firsthand working on 3D Gaussian Splatting. The field publishes 30+ papers per month. Every new method claims state-of-the-art on different benchmarks, with different training configurations, evaluated on different scenes. Comparing them requires reading each paper, extracting the relevant numbers, understanding which evaluation protocol they used, and mapping everything into a shared frame of reference. We spent more time tracking papers than doing actual research.

That experience crystallized a question: what if AI agents could handle the exploration — systematically reading papers, running experiments, testing hypotheses — while humans focused on the part only humans can do: deciding what matters?

We built Aporia to answer that question.

What It Does

Aporia is a collaborative autonomous research platform where AI agents and human researchers work together on shared research projects. The system has five core capabilities:

1. Interactive Knowledge Cosmos A custom WebGL2 3D visualization engine renders the research landscape as an explorable universe. Over 8,000 research papers appear as color-coded nodes clustered by topic — Computer Vision, Generative AI, Language Models, Robotics, Machine Learning, Systems, Optimization, and Theory. Users orbit, zoom, and click through the cosmos to explore connections between papers, discover citation patterns, and identify unexplored frontier regions. The visualization runs at 60fps with real-time glow effects, Bezier curve citation links, and perspective-correct depth rendering.

2. Autonomous Experiment Execution AI agents run experiments independently. In the Research Lab, agents place virtual cameras around 3D scenes, ray-trace visibility against point clouds, and compute coverage fractions using actual geometric computation — not approximations. Each experiment is logged with full metrics (coverage fraction, visible point count, camera parameters, timestamps) and stored in TimescaleDB for time-series analysis. When agents detect a gap — coverage below threshold, an unexplored parameter region — they autonomously generate hypotheses and queue follow-up experiments.

3. Classifier-Free Guidance for Research This is Aporia's core innovation. Borrowed from diffusion models, the formula s_g = s_u + w·(s_c - s_u) blends autonomous agent scores with human-conditioned scores using an adjustable guidance weight. At w=0, agents explore freely. At w=1, human priorities fully steer the direction. Anywhere in between, humans influence without micromanaging. The Judgments interface lets researchers submit free-text principles ("prioritize geometric coverage over visual appeal") that get compiled into scoring weights. A live distribution visualization shows exactly how guidance reshapes the candidate ranking.

4. PARALLAX Court — Adversarial Dispute Resolution When agents disagree — one claims a camera angle is optimal while another proposes an alternative — the PARALLAX Court resolves it through structured adversarial protocol. Claims are filed with supporting evidence, counterarguments are presented, discriminating experiments are proposed and executed, and a ruling is issued based on empirical results. Unresolvable disputes escalate to human PI review. This prevents the system from silently averaging over genuine disagreements.

5. Fork Explorer — Scientific Branching Different guidance weights produce different research trajectories. The Fork Explorer lets researchers branch an ongoing project with different w values (Autonomous, Light Guidance, Guided, Strong CFG), run them in parallel, and compare outcomes across metrics — PSNR, SSIM, LPIPS, training time, memory. A decision-path diff shows exactly where branches diverged and why, enabling systematic comparison of research strategies rather than gut-feel choices.

Beyond these five pillars, Aporia includes a Paper Library with search and provenance tracking (arXiv, OpenAlex, Papiers), a Portfolio page for budget allocation across research strategies, a Meta-experiments system for A/B testing research approaches, Team collaboration with real-time sessions and shareable project links, and a full event timeline powered by Server-Sent Events.

How We Built It

Aporia is architected as two independent layers — a Python backend and a React frontend — communicating through a typed OpenAPI contract that was defined before any code was written.

Backend — FastAPI + TimescaleDB

The backend runs on FastAPI with SQLAlchemy 2.x ORM and a TimescaleDB (PostgreSQL) database deployed on TigerData.

Geometric Evaluator: The core experiment engine operates on real 3D geometry. A unit-cube point cloud with surface normals is generated, virtual cameras are placed at configurable positions, and a custom ray-tracing pipeline computes which points are visible from each viewpoint based on frustum culling, field-of-view constraints, surface normal orientation, and occlusion checks. The evaluator outputs a coverage fraction — the percentage of the scene geometry visible from a given camera configuration. This is genuine computational geometry, not a statistical proxy.

Policy Engine: Candidate camera placements are scored along multiple dimensions — visual appeal, geometric coverage, information gain, feasibility, and risk — using a weighted scoring system. The Classifier-Free Guidance formula blends unconditioned scores (pure agent assessment) with conditioned scores (human-weighted assessment) using the guidance weight w. Candidates are ranked by guided score, and the policy engine selects the optimal placement.

AI Hypothesis Generation: When coverage falls below a specified threshold, the system generates research sub-problems. With a Gemini API key configured, it synthesizes evidence from all prior experiment runs and generates structured hypotheses with proposed actions and rationale. Token usage and latency are logged for transparency. Without Gemini, the system falls back to template-based problem statements.

Event Sourcing: Every action — experiment started, metric recorded, problem discovered, agenda item queued — is captured as an immutable event with a sequence number, correlation ID, and typed payload. This produces a complete audit trail of the research process and powers the real-time SSE stream that the frontend subscribes to.

Data Model: Projects contain experiment runs (with parameters, metrics, status, timestamps), agenda items (prioritized task queue with completion criteria), research events (the event log), principles (human governance rules), forks (branched research trajectories), claims and disputes (PARALLAX Court), frontier nodes and edges (knowledge graph), and more — 15+ tables covering the full research lifecycle.

Frontend — React + TypeScript + WebGL2

Custom 3D Engine (cosmos.ts): A purpose-built WebGL2 renderer — no Three.js, no abstractions. Two custom GLSL 300 ES shaders handle vertex projection and fragment coloring with glow effects. The engine procedurally generates a research atlas: 5 core Gaussian clusters, 48 satellite clusters, ~3,800 solo dust particles, and 90 Bezier curve stream filaments connecting cluster centers. Points render in two passes (glow + solid) with perspective-correct depth-based alpha. The engine supports drag-to-orbit, scroll-to-zoom, click-to-pick, and hover detection, all running at native refresh rate.

State Architecture: 11 Zustand stores manage domain-specific state (projects, events, graph, policy, forks, runs, agenda, team, etc.) with the API layer built on openapi-fetch for type-safe requests generated from the backend's OpenAPI schema. Real-time updates flow through an SSE client with exponential backoff reconnection and event deduplication.

UI Framework: React 19 with TypeScript, Vite 7 for builds, React Router for navigation, CSS modules for styling. The application shell features a collapsible side rail, top header with search, a right-side inspector panel, and a bottom timeline dock. All page routes use lazy loading with Suspense boundaries.

Infrastructure

  • Frontend: Deployed on Vercel with automatic builds from GitHub
  • Backend: Deployed on Render (FastAPI + Uvicorn)
  • Database: TigerData (TimescaleDB) — chosen specifically for time-series experiment data
  • AI: Gemini API for hypothesis generation and sub-problem synthesis

Challenges We Ran Into

Bridging autonomous exploration with human control was our deepest design challenge. Pure autonomy produces unfocused results — agents explore everything without prioritizing what matters. Pure human control defeats the purpose — you're back to manual research. The Classifier-Free Guidance formulation solved this elegantly: the same mathematical framework that lets humans steer image generation without specifying every pixel lets researchers steer science without micromanaging every experiment.

Real-time 3D rendering at scale pushed WebGL2 hard. Our initial cosmos had ~20,000 particles with Bezier curve links, which lagged on load. We profiled the fragment shader, reduced particle count to ~8,700, optimized the glow pass, and added progressive rendering — the cosmos now loads in under 2 seconds and maintains 60fps during interaction. Writing custom GLSL instead of using Three.js gave us full control over the rendering pipeline but meant debugging shader compilation errors by reading raw WebGL error logs.

Database driver compatibility bit us during deployment. SQLAlchemy 2.x defaults to the psycopg (v3) driver when the URL starts with postgresql://, but our deployment only had psycopg2-binary installed. The fix was a two-line URL rewrite — postgres:// to postgresql+psycopg2:// — but finding it required tracing through SQLAlchemy's dialect resolution, Render's build logs, and TigerData's connection string format.

Coordinate system consistency across the evaluation pipeline required careful attention. Camera extrinsic matrices, point cloud coordinates, and coverage results all had to agree on orientation conventions. A single sign error in the look-at matrix construction caused cameras to face away from the scene — producing 0% coverage that looked like a bug in the ray tracer rather than a geometry error.

Accomplishments That We're Proud Of

We built a complete, functioning research platform — from a 3D knowledge cosmos you can fly through to a geometric evaluation engine that ray-traces real 3D scenes — in under 36 hours with a team of three.

The Classifier-Free Guidance formulation for research steering is, as far as we know, a novel application of the concept. CFG was invented for diffusion models; applying it to research prioritization required abstracting the core insight (blend unconditioned and conditioned signals using a single weight) away from its original pixel-space context and into decision space. The result feels natural: w=0 is "let the agents decide," w=2 is "I know exactly what I want," and everything in between is a meaningful collaboration.

The custom WebGL2 cosmos engine renders 8,000+ interactive nodes with glow effects, Bezier citation curves, topic filtering, and click-to-inspect — all without Three.js. Pure WebGL, two custom shaders, and ~600 lines of TypeScript. It's the most visually striking piece of the project and it loads in under 2 seconds.

The PARALLAX Court system introduces adversarial rigor into autonomous research. Instead of silently averaging over agent disagreements (which hides information), the court forces explicit claims, evidence, and discriminating tests. This is how real science resolves disputes — through experiments, not consensus.

What We Learned

The gap between "technically correct" and "scientifically useful" is where the actual product lives. A correct coverage number is useless if a researcher can't understand why it's low. An optimal camera placement is useless if no one can visualize where it points. Every layer of Aporia — the cosmos, the guidance slider, the fork comparison charts, the court protocol — exists to bridge computation and understanding.

We learned that autonomous agents without governance produce noise, not research. The first version of our pipeline generated hundreds of experiment runs with no prioritization. Adding the guidance weight, the agenda queue, and the dispute resolution system transformed random exploration into directed discovery. Structure isn't the enemy of autonomy — it's what makes autonomy productive.

We also learned that TimescaleDB is genuinely excellent for experiment tracking. Time-series queries over experiment runs — "show me all coverage measurements for this project over the last hour, bucketed by camera configuration" — are exactly what it's built for. The decision to use TigerData for the hackathon prize ended up being the architecturally correct choice regardless.

What's Next for APORIA

Paper ingestion pipeline: Connect to arXiv, Semantic Scholar, and OpenAlex APIs to automatically populate the knowledge cosmos with real papers in a researcher's field of interest. The frontier graph currently uses curated data; a live feed would make the cosmos a genuine research discovery tool.

Multi-agent orchestration: Currently agents run sequentially. We plan to implement parallel agent execution with a shared blackboard architecture — one agent exploring camera placements while another analyzes coverage gaps while a third synthesizes findings — with the guidance weight steering all of them simultaneously.

Longitudinal experiment tracking: Use TimescaleDB's native time-series capabilities to track metric trajectories across days and weeks, enabling trend detection (is coverage improving?) and anomaly alerts (why did SSIM drop after this configuration change?).

Export and reproducibility: Generate LaTeX-ready experiment reports with figures, tables, and methodology sections directly from the event log. Every experiment in Aporia is fully logged — the infrastructure for one-click paper generation is already in place.

Collaborative governance: Multiple researchers with different guidance weights, with the system negotiating a composite direction. This extends CFG from single-user steering to multi-stakeholder research governance — closer to how real research groups operate.

Built With

  • React 19
  • TypeScript
  • Vite 7
  • WebGL2 (custom shaders)
  • FastAPI
  • SQLAlchemy 2.x
  • TimescaleDB (TigerData)
  • Python
  • Gemini API
  • Zustand
  • Server-Sent Events

Try It Out

Built With

Share this project:

Updates

Submission history