Deep Research Tamus AI Agent

Fast configuration

Four steps: name a project, add source documents, pick a format, and start. Everything else uses the free ensemble and tuned defaults. Need more control?

Create a new project

Name the project first — a fresh workspace is scaffolded and the tuned knowledge context is replicated in. Everything below is stored in this project.

Rename anytime → papers-vince/<project>

Task / North Star *

Required. Written to topic-input.txt + generates 00-NORTH-STAR.txt; search keywords are derived from it.

Upload or source documents

Files are uploaded into this project's RawInput/; the pipeline preprocesses them into knowledge, then writes a new paper.

↑ Drag or browse source documents · any format (.pdf .docx .txt .md .html …)

Other formats are extracted to structured text during preprocessing. The knowledge files stay human-readable structured text (no heavy JSON).

Select the output format

HTML is always produced; DOCX/PDF are derived from it.

HTML DOCX PDF

Start the process

Runs in papers-vince/<project> · free ensemble (Laguna + Devstral + Gemma) · $0 spend

Include web research (Tavily) ?Off = build knowledge only from your uploaded documents (private, faster). On = also search the web on your topic to enrich the corpus (needs WARP + Tavily; slower, more sources).

Advanced run configuration

Paper workspace

Mode

Workspace directory

Engine (shared, in place)

Source documents → RawInput

Upload raw source documents into RawInput/ (any format — extracted to structured text during preprocessing). These feed acquisition + knowledge building; they are NOT the rendered paper. Adding sources (re)runs the whole pipeline on the new corpus.

Task / North Star

Include web research (Tavily) ?Off = knowledge only from uploaded RawInput docs (local, private). On = also Tavily-search the topic (needs WARP; slower).

Output format

HTML (primary) DOCX PDF

Ensemble (TAMU gateway)

Model pool / jury

Free multi-model separation of powers: Laguna drafts → Devstral-2-123B reviews (critic) → Gemma-4-31B breaks ties (jury). Laguna-only falls back to single-judge.

Draft refine rounds ?--max-rounds (build_research.py). The DRAFT self-improvement loop that builds 10-PAPER.txt: evaluate → guideline → revise → gate, using the ensemble; converges when the gain stays below ε for K rounds. This is loop ① — separate from render QC.

Render QC rounds ?--qc-rounds is a PER-APPLICATION cap, NOT cumulative. The same value independently bounds ② the body-QC prose loop (once over the paper) and ③ each figure's geometry-QC fix loop. Worst-case figure-fix calls ≈ figures × this value. See the Architecture tab.

Daily $ cap

Min figures

Max figures

QC viewpoint temperatures

Rotated per round for "different points of view".

Figure temperatures

Toggles

Skip body QC ?Body QC is the judge→correct loop that runs on a working copy of the paper's PROSE: the critic scores it against the rubric, the synthesist rewrites the weakest sections, and a revision is accepted ONLY if it improves without regressing (never adds notation, never drops a section). Skipping it renders the draft as-is — faster, but no prose polishing. (--no-qc) Skip figures (--no-figures) Dry run ?Dry run parses the paper and renders a text-only skeleton with NO model calls and NO spend — it just reports the checks (sections parsed, citations resolved, HTML skeleton size). Use it to validate the config before a real run. (no spend)

Equivalent command

The console posts this to the backend POST /api/runs; the same command runs from a terminal.

Idle Elapsed 0.0s · ETA to finish — · healthy

0% · idle — the bar/ETA track the live SSE heartbeat; if no progress arrives for >4s it flags a possible stall/crash.

Preprocess

acquire + build knowledge

✓

Parse

read drafted paper

✓

Resolve cites

source map

✓

Body QC loop

loop ② · multi-viewpoint

✓

Figures

loop ③ · author + geometry QC

✓

Assemble HTML

cite-style + gate

✓

Ensemble

Laguna·Devstral·Gemma

free jury · 3 models

Sections

enforced from config

Figures kept

— / 19

large fonts, 0 hard defects

Citations

—

author-year, STM-only

GPT spend

$0.00

Laguna = free

Status

Idle

—

Press Run pipeline to simulate a full pass. Stages animate through the same A→E flow the backend executes; the QC, Figures, Citations and Audit tabs fill in as it runs. Your finished paper appears in the 📄 Preview & download tab.

Full front-to-back data flow. Stages 0-1 build the KNOWLEDGE from RawInput: an LLM-planned, Tavily-backed search engine acquires the corpus and reads how each source relates, then topology / direction / refinement scripts distil it into KnowledgeRepresentation (source maps, topology, LTM + STM). Stages 2-4 (run by this web backend) draft → render → export. Amber ⟲ = bounded self-improvement / QC loops. Stages 0-1 are run offline via CLI (Tavily cost / long); the web UI operates on the already-built knowledge.

Where QC is applied — 4 bounded loops

#	Loop	Engine · script	Round cap	What it does
①	Draft REFINE	build_research.py	--max-rounds (3)	ensemble judge→correct on prose sections; converges when gain < ε for K rounds
②	Body QC	render_paper.py · run_qc	--qc-rounds (5)	ensemble judge→correct on the whole paper's prose; temperature-rotated (multi-viewpoint)
③	Figure geometry QC	render_paper.py · author_figures	--qc-rounds, per figure	deterministic geometry lint → LLM fix → re-lint, for EACH figure independently
④	Format conversion	to_format.py	--passes, per format	convert HTML→docx/pdf, diff against the HTML, fix, repeat

Is “QC rounds” cumulative? No. --qc-rounds is a per-application cap, not a total. The same value independently bounds ② the body-QC loop (once over the whole paper) and ③ each figure's geometry-QC loop. Worst-case figure-fix calls ≈ figures × qc-rounds (e.g. 19 × 5), though every loop stops early on convergence or an anti-thrash freeze, so actual rounds are usually fewer. Loop ① (draft) uses a separate --max-rounds; loop ④ (conversion) uses a separate --passes. These are three different knobs in the config.

Judge→correct loop on a working copy. The synthesist temperature rotates each round (0.2, 0.5, 0.8, 0.4, 0.7) for diverse revisions; a revision is rejected if it changes the section set or reintroduces symbolic notation.

QC log will stream here on run…

Each figure: draft (varied temperature) → safety/well-formedness gate → deterministic geometry lint (out-of-bounds = hard drop; small font <14px / text-collision = soft, auto-fixed).

Rendered inline as (Short name, year), external STM only (internal author corpus dropped). Keys are knowledge-driven from LTM-citation-style.txt [CITATION-KEYS].

Key	STM id	Year	In-text

These are the ACTUAL long-term knowledge nodes injected into the pipeline's LLM prompts (drafter, reviser, figure author, citation renderer). The backend serves the FULL file via GET /api/knowledge/:node; the boxes below show representative excerpts. Edits + PUT take effect next run and are replicated when you create a new workspace.

Where this fits. You provide the raw material by uploading source documents into RawInput/ (Fast step 1 / Advanced “Source documents”). Preprocessing (stages 0-1) distils that into the knowledge representation below. This tab is where you review and hand-tune that representation to steer generation before the paper is written. The knowledge files are always human-readable structured text (no heavy JSON).

Two knowledge layers. The 5 LTM nodes below are the distilled STYLE layer. The bulk CONTENT knowledge (source maps 02/04/06/09, topology concepts/relationships/themes/domains/directions, STM 08) is built from RawInput by the Tavily search engine + topology/direction/refinement scripts (see the Architecture tab, stages 0-1) — not hand-written. Verified populated: 63/64/24/60 source ids; render resolves ~73 sources every run.

Context package ?A context package bundles the long-term STYLE knowledge (writing / figure / citation style, and the rubric) injected into every prompt. Pick the tuned V. Kellen package, or a lighter general-purpose starting point. Custom packages (author your own) are coming.

The tuned package distilled from V. Kellen's corpus and the 10-PAPER-new.html optimization. Edits + PUT take effect next run and replicate to new workspaces.

Context injected into every draft / revise prompt 27,695 / 28,000 chars

5 LTM nodes are concatenated (hard cap 28,000). Each large-context prompt repeats the task ≥4× (task anchoring) so the model stays focused across this context. These files are the distilled result of the whole 10-PAPER-new.html optimization — not shallow summaries; the excerpts here are abridged for display only.

LTM-writing-style.txt 198 lines · 12.9 KB — voice, zero-notation, term discipline, section hygiene

Full file loaded via GET /api/knowledge/LTM-writing-style. Excerpt:

[UNIVERSAL] BANNED PHRASES — remove on sight, replace with the concrete thing ("leverage", "delve", "in today's world", … 25 entries incl. math tokens $$ \( \[ \pi \delta \rho \lambda \theta \frac \sum \times)
[UNIVERSAL] NO SYMBOLIC NOTATION, EVER — no LaTeX, $…$, greek, or backslash macros anywhere; name every quantity in plain English (Trace, Metaknowledge, Provenance, Decay, Policy, Utility). Confine nothing to "one place": there is no escape hatch.
[UNIVERSAL] TERM DISCIPLINE — reasoning trace = raw recorded path; action engram = a trace governance VALIDATED + PROMOTED into a reusable, routable unit. "Not every trace becomes an engram." Tie the engram to the metabolism of knowledge in the Abstract.
[UNIVERSAL] ABSTRACT CARRIES THE FRAME — fold thesis / key-distinction / contribution into the Abstract (no separate callouts).
[UNIVERSAL] SIMPLE SENTENCES — no long comma-run lists; one idea per sentence (anti-pattern example given).
[UNIVERSAL] LISTS AS BULLETS — bold lead + an explaining clause.
[UNIVERSAL] PARAGRAPH FLOW — connect with transitions; no paragraph-dumps.
[UNIVERSAL] MECHANISM HONESTY — a structure / topology / store cannot "decide" or "enforce"; name the ACTOR + the OPERATION.
[UNIVERSAL] DEFINE KEY MECHANISMS WHERE INTRODUCED (+ a figure if it is an algorithm).
[UNIVERSAL] HIGH-LEVEL → SCIENTIFIC gradient; WORKED EXAMPLES ("Example N" + a monospace record).
[UNIVERSAL] SELF-CONTAINED OUTPUT — no external CDNs / fonts / scripts (no MathJax); all notation renders as plain text; the renderer's OUTPUT GATE strips any residual notation.
[UNIVERSAL] BEFORE FINALIZING — 12-item checklist (…)

LTM-figure-style.txt 135 lines · 8.5 KB — visual-first, LARGE text, geometry QC, artifact hygiene

Full file via GET /api/knowledge/LTM-figure-style. Excerpt:

[UNIVERSAL] VISUAL-FIRST — prefer diagrams / architectures / worked examples over symbolic notation.
[UNIVERSAL] PLACEMENT-ORDER NUMBERING — figures numbered by document position; no section ends on a figure; none back-to-back.
[UNIVERSAL] DEPICT THE MECHANISM — inputs → operation → outputs; label every non-obvious element (X / blocked / colour named in text).
[UNIVERSAL] AVOID SIMPLISTIC PANELS — include the gate / mask / signal types / decay branch.
[UNIVERSAL] LARGE, READABLE TEXT — title >=22px, box labels >=18px, edge labels >=16px, never <14px; set font-size on every text element; enlarge the viewBox (~820-1040 wide) rather than shrink text; >=10px box padding; >=1.6x row spacing. The renderer's geometry lint flags any text <14px.
[UNIVERSAL] SELF-CONTAINED SVG — inline only; no external images/fonts/scripts; explicit viewBox; restrained palette (green=admit, amber=decay, red=quarantine).
[UNIVERSAL] NO BARE ARTIFACTS — prose around every figure/example/table.
[UNIVERSAL] ARTIFACT / RENDERING HYGIENE — no stray tokens (e.g. "D4-T1D5-T1"); no "RReferences".
[UNIVERSAL] GEOMETRY + SAFETY QC GATE — HARD (out-of-bounds / unsafe) → fix or DROP; SOFT (text-collision, <14px font) → tolerate + auto-fix.
Diagram vocabulary: hub / pipeline / FSM / flow / layered / matrix / timeline / contrast.

LTM-citation-style.txt 112 lines · 6.1 KB — author-year, STM-only, [CITATION-KEYS] (44)

Full file via GET /api/knowledge/LTM-citation-style. Excerpt:

[UNIVERSAL] IN-TEXT STYLE — (Short name, year); multiple (A, 2025; B, 2026). NO numeric superscripts.
[UNIVERSAL] WHICH SOURCES ARE CITEABLE — cite verifiable EXTERNAL scholarship only (the STM-### tier). Do NOT cite the internal author corpus (S-## / P-slug). Where a foundational concept comes from the corpus, cite its published counterpart.
[UNIVERSAL] REFERENCE LIST — unnumbered, alphabetical by key; only entries still cited after trimming.
[UNIVERSAL] BUILDING CITATION KEYS — never fabricate authors; key = system/short name from title + year from the arXiv id (25xx→2025, 26xx→2026); merge duplicate versions.
[CITATION-KEYS]  (machine-readable; the renderer parses these)
  STM-013 = MemOS | 2025      STM-014 = Memory as Metabolism | 2026
  STM-012 = ProcMEM | 2026    STM-031 = MemArchitect | 2026
  STM-032 = Governance by Design | 2026   STM-026 = TRACE | 2026
  … 44 entries total …
[UNIVERSAL] BEFORE FINALIZING — checklist (no numeric sups; no S-/P- cites; unnumbered alphabetical; no fabricated authors).

LTM-author-voice.txt 80 lines · 8.4 KB — thesis + voice from the internal corpus (informs, not cited)

Full file via GET /api/knowledge/LTM-author-voice. Excerpt:

LTM-paper-profile.txt 79 lines · 5.3 KB — descriptive target template (measured from 10-PAPER-new.html)

Full file via GET /api/knowledge/LTM-paper-profile. Excerpt:

rubrics/RUB-paper.txt 37 lines · 2.0 KB — K1-K6 criteria + house-style gates (regenerated each run)

Seeded from build_research._seed_criteria() each run. Excerpt:

Context injected into every draft / revise prompt ~9,400 / 28,000 chars

A lighter, generic style layer (4 nodes, no author-specific voice or paper profile). A neutral starting point you can edit into your own package.

writing-style.txt general — clarity, plain language, structure

figure-style.txt general — clear, readable, self-contained figures

citation-style.txt general — author-year, verifiable sources

RUB-paper.txt general — lightweight review gates

Custom packages (author your own) will be selectable here.

Your finished paper appears here. This tab is where you review the rendered output and download it. HTML is the primary, high-fidelity source; DOCX/PDF are derived from it over self-improving conversion passes. The file is written to <project>/KnowledgeRepresentation/10-PAPER.html.

Download:

Deterministic invariants checked on every render, compared against the hand-tuned target 10-PAPER-new.html.

Invariant / metric	This run	Target
Symbolic notation ($ / greek / LaTeX)	—	0
MathJax script present	—	no
"RReferences" artifact	—	none
Numeric superscript citations	—	0
Internal-corpus refs (P-/S-)	—	0
Author-year citations	—	~19
Figures	—	19
Section headings (h2)	—	8
Word count	—	~5276
Well-formed HTML	—	yes

REST endpoints (thin wrapper)

Method + path	Purpose
GET /api/health	WARP + gateway reachability, ensemble attribution
GET /api/config	read search_config.json (ensemble, paper, gate)
PUT /api/config	update pool / temperatures / rounds / min+max figures / budget
POST /api/workspaces	scaffold a NEW isolated project (own RawInput/KnowledgeRepresentation/search_config + generated North Star + STYLE package); engine stays shared
POST /api/uploads	save source documents (base64 JSON: files[{name,content_b64}]) into the project's RawInput/, extracted to text (pdf/docx/html)
POST /api/runs	orchestrate per-workspace: scaffold → uploads → (web?) acquire+curate → build_topology → (web?) build_directions → build_research → render_paper → to_format (sets AE_WORKSPACE; preprocessing folded in here)
GET /api/runs/:id/events	SSE stream: stage, %, ETA, heartbeat, QC rounds, figure results
POST /api/convert	HTML → docx/pdf, self-improving over N passes
GET /api/runs/:id/output?fmt=	rendered html / docx / pdf
GET /api/runs/:id/audit	deterministic invariant report
GET /api/knowledge/:node	FULL knowledge node text (writing/figure/citation/author/profile + rubric)
PUT /api/knowledge/:node	edit a knowledge node (takes effect next run; replicated to new workspaces)

POST /api/runs — request body

{
  "workspace": "papers-vince/my-project",
  "new_workspace": true,
  "task": "Write a paper on … (the required Task / North Star)",
  "package": "kellen",            // or "general" (STYLE context package)
  "web": false,                    // false = local sources only; true = + Tavily
  "uploads": [{"name":"survey.pdf","content_b64":"…"}],  // inline, saved to RawInput/
  "preprocess": true,      // build topology (+acquire/directions if web) then draft
  "in":  "KnowledgeRepresentation/10-PAPER.txt",      // drafted paper (internal)
  "out": "KnowledgeRepresentation/10-PAPER.html",
  "formats": ["html","docx"],
  "conversion_passes": 3,
  "pool":   ["poolside/Laguna-S-2.1","mistralai/Devstral-2-123B-Instruct-2512","google/gemma-4-31B-it"],
  "max_rounds": 3,        // ① draft REFINE (build_research)
  "qc_rounds": 5,         // ② body QC + ③ figure QC, per-application
  "min_figures": 12, "max_figures": 19,
  "daily_usd_cap": 0,
  "no_qc": false, "no_figures": false, "dry_run": false
}

SSE event shape (drives the progress bar / ETA / stall)

event: stage    data: {"stage":"preprocess","pct":8,"eta_s":180}
event: acquire  data: {"kept":124,"queries":22}
event: stage    data: {"stage":"qc","pct":42,"eta_s":95}
event: heartbeat data: {"t":1699,"alive":true}
event: qc       data: {"round":2,"temp":0.5,"accept":true,"gain":3}
event: figure   data: {"n":7,"title":"Anatomy…","kept":true,"soft":1}
event: convert  data: {"fmt":"docx","pass":2,"of":3}
event: done     data: {"audit":{"dollar":0,"figs":19,...}}

The client watches heartbeat; if none arrives for >4s it flags a stall/crash. The wrapper shells out to build_research.py + render_paper.py (and a to_format.py converter) and tails stdout + 12-QC-LOG.txt; no pipeline logic is duplicated.