Revisa Express
Professors are overloaded, so students wait weeks for feedback. My platform delivers an expert-level review in fifteen minutes.
Context & Constraints
Graduate students need expert feedback on their manuscripts. But professors are overloaded, so guidance arrives late, thin — or not at all.
Students were left to guess what was wrong with their own work. Expert human review exists, but it is slow, expensive and scarce: a proper first review takes a senior reviewer about six hours. Revisa Master needed a way to give every student an expert-level review, fast.
- The system runs on a small server (2 vCPUs / 8GB). The worker handles one analysis at a time, on purpose: two heavy pipelines at once could run the server out of memory.
- The student's manuscript is never embedded or indexed. It is extracted as plain text, cached briefly, and passed inside a sanitized prompt. Only the reference material is indexed: writing norms, the rubric, style guides.
- Every finding in the report must trace back to one of the 52 rubric questions. No unattributed claims.
“We wrote down every question our best reviewer asks. Then we taught each one to an agent.”
Architecture
A cheap triage model screens every upload before the expensive pipeline commits. It rejects non-academic or broken files early. Five pillar agents then review the manuscript against a 52-question rubric. The pillars: clarity, methodology, relevance, technical writing, and norms. Each agent looks up its criteria in a ChromaDB knowledge base of academic-writing references. A sixth agent checks the paper against the submission brief, when one is attached. A writer agent consolidates every finding into a six-section report. A copy-editing pass then corrects the text under a drift guard: if the correction changes the report's length by more than 25%, the system throws the correction away. Finally, a validator agent audits the report before it can publish. The agents run in a single sequential Celery chain — one task after another, never in parallel. This is deliberate. The API rate limits would allow parallel pillars now. The production server would not: it has 2 vCPUs, and each pipeline run imports CrewAI, LiteLLM and ChromaDB, which is heavy. Two analyses running their agents at once could exhaust memory. I protect that limit at the infrastructure layer, not with prompt workarounds.
- Manuscript, client upload — input. Leads to: Triage.
- Triage, nano · go/no-go — process. Leads to: Clarity, then Methodology, then Relevance, then Technical Writing, then Norms, then Brief Fit.
- Clarity, P1 agent — agent. Leads to: Writer.
- Methodology, P2 agent — agent. Leads to: Writer.
- Relevance, P3 agent — agent. Leads to: Writer.
- Technical Writing, P4 agent — agent. Leads to: Writer.
- Norms, P5 agent — agent. Leads to: Writer.
- Brief Fit, EA · if attached — agent. Leads to: Writer.
- Writer, A6 · consolidation — agent. Leads to: Copy Editor.
- Copy Editor, P6 · drift guard — process. Leads to: Validator.
- Validator, A7 · QA gate — agent. Leads to: Diagnostic Report.
- Diagnostic Report, WeasyPrint PDF — output.
Revisa Express — 8-agent review pipeline (sequential)
Decisions & Trade-offs
Sequential, not parallel, agent execution
One Celery chain. The five pillar agents run one after another, never as a parallel group.
Considered: Parallel fan-out via Celery group/chord · An explicit graph (e.g. LangGraph) with a fan-in node
Rate limits are not the constraint anymore — the account tier could handle parallel pillars. The server is the constraint. It has 2 vCPUs, and every pipeline run imports CrewAI, LiteLLM and ChromaDB, which is heavy. Parallel agents inside one analysis could starve a second user's analysis of memory. So concurrency stays at 1 until the server grows. A chosen trade-off, not an oversight.
RAG indexes the rubric, not the student's work
ChromaDB stores only the reference material: writing norms, the grading rubric, style guides. The manuscript is extracted as plain text, cached briefly, and passed inside a sanitized prompt.
Embedding a student's unpublished work would create a data-handling liability with no benefit. The agents don't need to search the student's text. They need to look up the grading criteria and apply them to the text in front of them.
Eight narrow agents, not one long prompt
Five pillar reviewers plus a writer, a copy editor and a validator. Each agent has its own role and its own temperature.
Considered: One large prompt covering every evaluation criterion
The rubric has 52 discrete questions, and every finding must trace back to one of them. That granularity dies inside a single giant prompt. Separate agents also get the right temperature per task: a strict 0.0 for norms-checking, a looser 0.3 for clarity feedback. And failure stays contained — one pillar can error without taking down the other four.
- I migrated model providers in production (Anthropic → OpenAI) without touching business logic. An abstraction layer keeps the provider behind an environment variable, so the switch was a config change, not a rewrite.
- I kept CrewAI pinned to an older version on purpose. The next major version needs dependencies the rest of the stack can't use yet. This is tracked, deliberate technical debt.
- The pipeline has no explicit graph orchestration, even though it now has a conditional branch and a fan-in step that a graph would model better. The current abstraction fit the pipeline when it was simpler. Revisiting it is on the list.
My Role
I co-founded the company and I am its only engineer. I turned our best reviewer's tacit criteria into explicit agents. I built the orchestration and the backend (Python, Django, CrewAI, ChromaDB, Celery, Docker), and I operate it in production. When it breaks, I am the one who fixes it.
Results & Validation
In production, a report takes about 13.7 minutes and costs about $1.78 in model usage. Across 210 traced calls, zero failed. The lesson: write down what your expert actually checks. Once the rubric is explicit, agents can apply it — and rigor stops being a bottleneck.
Stack
Building AI that has to work every time?
I design, ship and operate systems like this one.
Let's talk