Prism.ai

From dataset to research-ready project, an AI research copilot for computer vision.

Comment

Your AI Research Engineer for Computer Vision

Idea

Prism AI is the first AI Research Engineer that transforms a computer vision dataset into a complete, research-ready project starting from analysis and experiment design to code generation, evaluation, and paper drafting.

Inspiration

Every computer vision project starts the same slow way. You get a dataset, then spend hours just figuring out what you're looking at. Is it balanced? Any duplicates? What's already been tried on data like this? What architecture actually fits here? By the time those questions are answered, half the week is gone before any training code exists.

I wanted to compress that ramp-up into minutes, not by skipping the thinking, but by having an AI system actually do that thinking well, grounded in real data and real literature.

What it does

Prism.ai takes a computer vision dataset and turns it into a research-ready project through six connected stages:

  1. Dataset Analysis: Profiles class balance, duplicates, resolution, and image quality
  2. Literature Intelligence: Searches real papers on OpenAlex and surfaces ones relevant to your specific dataset
  3. Experiment Planner: Designs preprocessing, augmentation, architecture, optimizer, loss, and metrics, reasoned from the dataset stats and the literature found
  4. Code Generation: Writes a working PyTorch training pipeline that implements that plan
  5. Research Report: Compiles everything into one citation-backed report, downloadable as a PDF
  6. Research Assistant: A chatbot grounded in that run's full pipeline data, so you can ask it questions about your dataset, the literature, the plan, or the code directly

Each stage builds on the last. The architecture recommendation references the actual papers found earlier. The training code implements the actual decisions from the experiment plan. The chatbot assistant only answers from what's actually in that run's data, it won't invent papers, stats, or results it doesn't have. It's one connected pipeline, not separate tools bolted together.

How Codex and GPT-5.6 shined

Codex built Prism.ai end to end, not just scaffolding. Every stage, the auto-chaining logic, auth, the UI polish, all went through the same loop: I'd write a spec, Codex would implement it, I'd review and test before moving on. What actually impressed me was its reasoning. I originally planned seven agents, and Codex helped me see that wouldn't hold up in the time I had, so we cut it to six focused stages instead. What shipped actually worked, instead of looking impressive but falling apart under a demo.

GPT-5.6 handles the real thinking inside the product: ranking papers, designing the experiment plan, writing training code that matches it, answering questions grounded in a run's actual data. The dataset numbers themselves stay deterministic, computed with PyTorch and OpenCV, never guessed by the model. Between the two, a week of manual research setup turned into a pipeline that runs itself in minutes.

How I built it

Frontend: Next.js, TypeScript, Tailwind, shadcn/ui. Backend: FastAPI with SQLite, JWT auth plus Google OAuth. The agents run through a lightweight custom orchestrator passing a shared state object between stages. I skipped heavier agent frameworks on purpose, wanting full visibility into how data moved through the pipeline instead of debugging someone else's abstraction under a deadline.

Codex was used throughout the build, not just at the start. Every feature went through the same loop: write a detailed spec, let Codex implement it, review and test before moving on.

Challenges I ran into

The original plan had seven agents, including a full reviewer step. I cut it down to five core stages once it was clear that five built solidly beats seven built shallow, and added the chatbot afterward as a sixth once the core pipeline was solid.

The Experiment Planner hit a wall early on: GPT-5.6 kept timing out because I was sending too much context and asking for a large structured response in one shot. Fixing it meant trimming the input down to what the model actually needed and adding retry and timeout handling.

The hardest thing I held myself to was honesty in the output. It would've been easy to have the model generate plausible-looking accuracy numbers for the final report. I didn't want that, so the report frames evaluation as planned, not conducted, since no training run has actually been executed.

Accomplishments that I'm proud of

A pipeline that actually works end to end, not a mockup of one. Every stage produces real, dataset-specific output, real duplicate counts, real papers, real architecture reasoning, real code, auto-chaining from upload all the way to a downloadable report and a working chat assistant on top of it.

What I learned

A tightly scoped, fully working system beats an ambitious, half-working one. And treating an AI coding tool as a collaborator to review carefully, not a black box to trust blindly, is what let me ship something real under real time pressure.

What's next for Prism.ai

Deploying Prism.ai so it's live and usable beyond localhost, moving the database to PostgreSQL and hardening auth and file handling for production.

Built With

Share this project:

Updates