How to Build a 24/7 Quant Trading Desk with Opus 5.5 (FULL GUIDE)

here's how to build an AI quant research desk with Opus 5.5, step by step.

one place to research companies, test trading ideas, and inspect the evidence behind each result.

use the prompts, annotated screenshots, and checks below to build your own version.

we'll start with a working Minara pilot, then build the data and research pipeline the full desk needs.

ask an AI chat for every AI stock worldwide and you'll probably get a list. first, define AI exposure, eligible listings, and the evidence each company needs.

skip that and the list can mix customers with suppliers, count one company three times, and leak future disclosures into past decisions.

each tool gets one job in the proposed setup:

Minara organizes research and the pilot. Codex runs reproducible calculations. Jev checks typed evidence after hard tests pass. Dots coordinates bounded tasks once its handoff is verified.

before asking for a model, i want evidence i can inspect.

which listed issuers qualify, why are they included, and what can the data answer?

the planned core covers listed common equity and ADRs where named sources provide country coverage. i'll map each issuer's AI exposure across the value chain.

momentum, quality, and the investment cycle get separate tests after their inputs pass review.

“global” needs documented coverage. every exchange and issuer won’t appear automatically.

this is research with no broker connection, order route, wallet, or live deployment.

raw captures may show account labels. they record current or saved UI; i haven't independently reproduced the results.

what Minara supports today

i walked through Minara to inspect its research tools. the global database still needs building.

the Factor Library showed 376 factors, including several ways to define momentum.

one Strategy Studio example held 31 current instruments, including ETFs and non-U.S. securities.

that works for an interface pilot. historical world equity membership still needs its own data.

the broad U.S. momentum memo returned “not calculated.” historical coverage, membership, data vintage, and executable prices were unverified.

i also found cost and setting mismatches in the backtest screens.

the current Minara memo and original request show the UI and research limits.

• left a pre-existing institutional research run with incomplete global coverage. the arrow marks completed NVDA roundtable phases.

• center an NVDA-only report with no global AI universe. the arrow marks its headline and hold statement.

• right the original request and saved memo describe an untested study. the arrow marks the conclusion and unsupported-data limit.

first define the investable universe

start with company identity. add the ticker after that.

a ticker identifies a listing. the study usually needs the issuer behind it.

one issuer can have multiple share classes, a local primary listing, and an ADR.

a broad search can also return ETFs, funds, warrants, and private firms.

count those as independent AI companies and the sample breaks before the first calculation.

i'll keep two linked tables:

the issuer master stores a stable internal issuer_id, legal name, domicile, and available external identifiers.

the listing master stores listing_id, issuer link, ticker, exchange, share class, instrument type, currency, calendar, active dates, and any ADR ratio or underlying security.

a legal entity and a security need separate identifiers, joined by a dated issuer-to-listing map.

an unresolved map keeps the entry out of the core sample.

the first core includes ordinary common shares and depositary receipts.

ETFs, funds, derivatives, tokenized assets, and private companies stay excluded or tracked separately.

an ADR and its underlying share count as one issuer, even when both have tickers.

before testing, i'll freeze the primary-listing rule or explicitly choose a listing-level study.

factor results cannot change that choice.

every “AI company” label needs evidence. an exchange checkbox won’t settle it.

i'll use three buckets:

• direct exposure: the issuer sells AI models, software, systems, or services backed by disclosed segment or product evidence.

• supplier or enabler: it sells identifiable chips, memory, fabrication equipment, networking, cloud capacity, data-center systems, power, cooling, or other AI deployment inputs.

• watchlist only: a management claim, broad positioning, or plausible link lacks enough detail for core inclusion.

each evidence record stores the claim, source passage, document period, publication timestamp, business segment, capture time, label rule, reviewer, and parent/subsidiary link.

an LLM can locate passages and flag conflicts. historical labels still require dated sources and human-reviewed records.

known_at stops me from putting a company's 2026 description into its 2018 record.

no evidence means unknown. that's a valid output.

count unknowns alongside each class so missing evidence stays visible.

“worldwide” needs a coverage ledger for every source.

record countries, exchanges, instrument types, history, delisted names, corporate actions, financial fields, licenses, and gaps.

mark each country/exchange pair included, partial, or unavailable. name the vendor's supported subset as the study's scope.

a global heading can't fix incomplete coverage.

build the master without duplicates or time leakage

freeze the universe manifest: as-of date, countries, venues, instrument types, exposure rules, identifier-map snapshot, quality filters, delisting treatment, source vintages, and exclusions.

report counts at every step: candidates, mapped issuers and listings, duplicates, rejected instruments, unknown labels, and final members.

a reviewer must be able to trace the source list through to final membership.

tickers change. identity history must survive.

companies change names, venues, and share classes. listings can be suspended, merged, or delisted.

keep dated aliases, mapping sources, and the reason for each change.

ADR links and ratios also need effective dates.

today's exchange directory helps identify current listings. it doesn't establish historical membership or when AI evidence became public.

filings may offer publication dates but not total returns or delisting data.

unavailable or unlicensed required history means not calculated.

each listing has a currency, calendar, daylight-saving rules, and close time.

i'll use unhedged returns in one base currency, probably USD, with a named FX source and timestamp.

define the total-return method, corporate-action and dividend policy, delisting treatment, and execution time.

same-date closes don't prove availability. check the actual Tokyo and later-closing exchange timestamps.

record the decision time and next executable local session in the manifest.

keep local-currency returns for diagnostics. document USD translation because FX can change the ranks.

align holidays and non-overlapping sessions with exchange calendars. a blanket month-end join can hide timing errors.

when consistent timing isn't supported, use the alignable subset and state the limit.

three hypotheses. three failure modes.

an agent shouldn't try thousands of factors until a pretty chart appears.

freeze three simple hypotheses, limit variants, and test one at a time.

momentum comes first. its definitions are inspectable in Minara today.

quality and the investment cycle stay design-only until historical inputs pass the audit.

1. momentum. compare plain 12-month total return, compounding t−12 through t−1, with 12–2 momentum, compounding t−12 through t−2 and skipping t−1.

freeze the point-in-time issuer/listing universe, rebalance calendar, selection rule, weights, benchmark, and costs.

change only the signal window.

the test shows whether definitions select different names. it doesn't explain what caused their returns.

2. quality. freeze a small cross-country definition before ranking.

one candidate combines profitability, balance-sheet resilience, and earnings stability.

define each input's units, fiscal period, restatement policy, publication timestamp, and treatment of incomparable or missing fields.

accounting standards, currencies, industries, and fiscal calendars can break a naive global score.

show coverage for each component beside the combined score. missing fields stay visible.

3. investment cycle. use disclosed capital spending tied to AI segments in the evidence ledger.

separate realized cash capex, guidance, announced commitments, construction in progress, and management targets. each has different meanings and dates.

a multi-year data-center announcement isn't completed capex.

freeze the measure and lag before testing. returns can't rewrite them.

record expected direction, inputs, timing, eligible sample, controls, benchmark, variants, rejection rule, and holdout in each manifest.

keep “design only” status until the data dictionary and publication-time rules pass review.

published momentum research can inspire the question. its historical results don't transfer to this universe.

i'll use French Mom as a construction reference. this sample gets its own definition.

• top left the Factor Library catalog doesn't validate signals. the arrow marks catalog tabs and counts.

• top right universe preset names don't establish historical membership. the arrow marks the Tradfi 30 choice.

• bottom left this generic Factor Library view doesn't show a matched momentum pair. the arrow marks the category/count header.

• bottom right the strategy form shows available controls, with no new strategy submitted. the arrow marks asset and portfolio controls.

start with a bounded Minara pilot

before building a world-scale dataset, ask Minara for a matched plain-versus-skip-month test on a named supported subset.

request the availability report first: exact assets, identifiers, factor definitions, rebalance rules, dates, costs, and export fields.

an unconfirmed required item blocks the backtest.

the Factor Library showed plain 12-month, 3- and 6-month skip-one-month, and intermediate 7–12-month definitions.

a matched plain 12-month and 12–2 pair still needs verification.

inspect factor IDs and code to establish that.

the current momentum code wrapper is inspectable.

a 12-month versus 6-month test can't substitute for a missing 12–2 pair.

a custom signal needs a supported route, inspectable code, and reproducible inputs. otherwise, calculate the pair offline.

the observed TradFi 30 basket showed 31 current instruments, including ETFs and non-U.S. listings.

reuse it as a fixed-basket interface pilot. historical global AI membership needs separate data.

freeze long-only top five, equal weights, monthly rebalance, 1x, benchmark, and costs. change only the signal.

save settings, members, and outputs for both runs.

then test a one-way cost grid, for example 0, 10, 25, and 50 basis points.

the fee-off overview showed fill commissions. that mismatch remains unresolved; slippage hasn't been independently verified.

the fee switch doesn't establish the cost model.

Codex will calculate assumed turnover and deductions from exported holdings and returns. missing artifacts mean not calculated.

• top left the saved momentum draft and request show current construction. the arrow marks universe and portfolio controls.

• top right current momentum fee and slippage settings don't verify execution. the arrow marks the 10 bps fee and slippage settings.

• bottom left the current momentum overview records no new run. the arrow marks headline metrics.

• bottom right saved momentum fills haven't been independently reproduced. the arrow marks fills and commissions.

the inspected 2024–2026 window is development material. it can no longer serve as an untouched holdout.

reserve a historical block only with licensed point-in-time data. otherwise, start prospective validation after freezing definitions.

Minara organizes the experiment. every displayed performance number still needs supporting evidence.

• top left per-symbol results are product-reported evidence. the arrow marks realized and unrealized P&L.

• top right current momentum metrics differ from historical chat metrics. the arrow marks the current headline figures.

• bottom left current saved fills have no independent reproduction. the arrow marks the fills table.

• bottom right this per-symbol table shows the same saved evidence, with no new run. the arrow marks the table.

check one formula independently

start offline with a tiny check: rebuild Kenneth French's monthly Mom from the published six size-by-momentum portfolio legs.

this checks arithmetic. the global AI universe and proposed portfolio need separate validation.

check the parser, date alignment, return units, and long-short math.

1Mom[t] = 0.5 * (SmallHigh[t] + BigHigh[t])
2       - 0.5 * (SmallLow[t]  + BigLow[t])

French forms six value-weight portfolios using size and prior (2–12) return. Mom averages the two high prior-return portfolios and subtracts the average of the two low portfolios.

download the six legs and separately published Mom series. pin one archive vintage, join common months, and compare the four-leg reconstruction with the published line.

set the residual tolerance from published precision before calculating.

a match supports the formula plumbing.

it doesn't verify security-level inputs, global AI labels, Minara history, costs, or alpha.

the data library switched from CRSP FIZ to CIZ beginning with its January 2025 release. monthly dividend reinvestment timing differs between them.

don’t stitch those formats into a “continuous” series without a separate documented comparison.

keep each snapshot's URL, retrieval time, format, checksum, parser version, units, and license note.

check the Data Studio build before trusting its data

the builder shows Claude Opus 5.5 as the selected model. that's the model setting captured for this dashboard.

the global desk still needs building. i'll check its code and data independently before using an output.

Minara reports app version 1.2.1. dashboard versions have their own numbering.

the older Data Studio project said Version 1, but paired a Bitcoin preview with a Nvidia/Palantir plan.

• top left Data Studio home shows saved projects, not verified calculations. the arrow points to the natural-language input.

• top right the older Version 1 Bitcoin preview didn't match the later request. the arrow points to Version 1's empty panels.

• bottom left the older Nvidia/Palantir plan doesn't prove its preview worked. the arrow points to the equity goal mixed with Bitcoin requirements.

• bottom right the older data requests failed. the arrow points to FMP history and quote 504 errors.

• top left the older settings show configuration, not results. the arrow points to Financial Modeling Prep's Ready status.

• top right the older code view doesn't prove data retrieval worked. the arrow points to an equity title with Bitcoin components.

• bottom left earlier Bitcoin-project context, separate from the new comparison request. the arrow points to the research-only dashboard prompt before it was sent.

• bottom right the older Bitcoin preview shows a failed stock refinement. the arrow points to that failed request.

its Data tab showed four FMP requests with 504 errors. that didn't establish a working stock comparison.

• top left the older Data tab shows four FMP 504 errors. the arrow points to those 504 failures.

• top right the older saved stock-comparison plan didn't match the Bitcoin preview. the arrow points to the plan's goal.

• bottom left stock dashboard templates show available choices, not completed studies. the arrow points to stock and macro templates.

• bottom right About reports Minara app 1.2.1. the small screenshot keeps its native size; the arrow points to the version line

i submitted a separate Nvidia versus Palantir research request asking for real observations, timestamps, and visible errors. the exact request and follow-ups are saved in separate prompt files.

the first build got stuck at step 3/5.

• left saved Version 1 had quotes; history and correlation were still pending. the arrow points to Version 1's quote values and source timestamps.

• center Version 1 quote calls returned HTTP 200. The arrow highlights two HTTP 200 quote calls.

• right the history extension was still running here. it later saved Version 2; the arrow points to the pending history panel.

the history extension saved Version 2. the app reports that build and preview checks passed.

the UI shows April 1–October 1, 2026 coverage: 127 valid closes out of 127 returned for each symbol. both price series start at 100 on the first common date.

the UI reports a Pearson correlation of 0.1421 across 126 paired daily returns. i haven't independently reproduced it.

it describes historical returns. it doesn't predict the next move.

• top left the final Version 2 UI shows quotes and historical prices. the arrow points to Version 2's daily-close charts.

• top right Version 2 reports 127 closes each and 126 paired returns. the arrow points to dates and 127/127 coverage rows.

• bottom left the request history shows six HTTP 403 failures before successful history responses. the arrow points to those HTTP 403 failures and later HTTP 200 responses.

• bottom right this shows the start of the comparison code, not the whole file. the arrow points to the parser and duplicate-date handling.

saved Version 2 shows indexed prices and UI-reported correlation. i haven't independently reproduced the calculation.

the preview took failed requests too. the cumulative Data tab shows 18 FMP calls and six errors.

six history attempts returned 403, then two returned HTTP 200. the final preview rendered with those failures still in the request history.

• left the final saved plan reports the build complete. the arrow points to its quote and history source contracts.

• right the final settings don't independently validate the data. the arrow points to FMP readiness and the one-load cadence.

the verified registered sources still don't provide commodity, supply-chain, or news-forecast inputs. the global pipeline remains a build plan.

inspect the saved strategy and import workflows

the saved BTC strategy and Pine examples show another workflow to inspect. those simulations and code don't establish the equity study's validity.

• top left this Pine example is separate from the global equity study. the arrow points to its sizing and cost explanation.

• top right current Pine cost inputs don't prove earlier run costs. the arrow points to the dialog's backtest cost values.

• bottom left the saved Pine overview reports a simulation i haven't reproduced. the arrow points to its headline results.

• bottom right the saved Pine fills are a separate simulation, not live orders. the arrow points to the first completed trade row.

• top left the code-import dialog shows an input surface, not a validated conversion. the arrow points to the Pine/code input area.

• top right this saved Pine overview is separate from the equity study. the arrow points to the example's headline metrics.

• bottom left the Pine source belongs to a separate saved example. the arrow points to its code.

• bottom right the saved trade list shows simulation output, not live orders. the arrow points to its rows.

pin the repository and data contract

i'll start small: Python, NumPy, pandas, PyArrow, Pydantic, pytest, Ruff, and a locked uv environment.

statsmodels and Matplotlib wait until a report needs them. scikit-learn waits for a defined modeling stage.

DuckDB can query Parquet if the panel grows.

six factor series don't need a server, vector database, or autonomous agent framework.

1quant-research-lab/
2  AGENTS.md  README.md  pyproject.toml  uv.lock
3  config/  schemas/  manifests/{sources,universes,hypotheses}/
4  src/qrlab/
5    data/{ingest,identifiers,calendar,fx,validate}.py
6    universe/{build,evidence,coverage}.py
7    factors/{momentum,quality,investment_cycle}.py
8    portfolio/{weights,returns,costs}.py
9    validation/{splits,metrics,review}.py
10    runner.py  registry.py  reporting.py
11  tests/fixtures/  tests/test_*.py
12  data/{raw,normalized}/     # ignored by Git
13  runs/                      # immutable run folders
14  reports/

Git gets code, schemas, synthetic fixtures, and non-sensitive manifests.

raw or licensed data stays outside Git.

i'll keep source archives byte-for-byte and hash the archive plus every entry.

each normalized Parquet snapshot carries its schema version, source snapshot, currency, unit, and transformation lineage.

a run needs a pinned input. it won't read latest.csv.

four records make the chain inspectable.

1. DataManifest records the source, license, format, retrieval timestamp, hash, coverage, parser, and vintage.
2. UniverseManifest freezes membership rules, evidence labels, issuer-listing maps, counts, exclusions, and as-of rules.
3. ExperimentSpec defines the hypothesis, inputs, signal, dates, portfolio mapping, benchmarks, costs, and rejection rules.
4. RunManifest records the code commit, lockfile, input hashes, command, environment, output hashes, external calls, and status.

a separate ReviewResult cites the artifacts and lists unresolved issues.

1. for each universe member, i need issuer_id, listing_id, valid_from, valid_to, known_at, instrument_type, country, exchange, currency, and source_snapshot_id.
2. each evidence claim also needs publication and capture timestamps, claim text, evidence source, classification rule, and reviewer.
3. financial values need period start/end, available_at, original currency, unit, reported value, restatement state, and source.
4. returns need a price or total-return method, corporate-action policy, delisting treatment, base-currency conversion, and FX timestamp.

a period-end date doesn't tell me when the filing became available.

1. tests enforce available_at <= decision_at. the trade follows a knowable signal; the target return starts after execution.
2. i'll split dates before expanding rows into listings.
3. the same decision date stays in one fold. training labels are purged when their return intervals overlap validation.
4. one numeric gap won't cover different horizons or calendars.

freeze the calculation and failure rules before backtesting

each run separates signals, holdings, gross returns, and costs.

• signals rank eligible issuers using information available at decision time.
• ties follow a deterministic rule.
• portfolio construction selects the preset number of names, normalizes weights, handles missing or halted listings, and records rejected positions.
• the cost layer applies declared fees, turnover, spread, slippage, and FX assumptions.
• gross returns can't be labeled net performance.

the global-return spec fixes a base currency and conversion timestamp.

local total return and FX return combine multiplicatively: (1 + local_return) \ (1 + fx_return) - 1.*

i need actual total-return data or documented dividends and corporate actions. “adjusted close” alone doesn't explain the math.

missing delisting returns get a coverage warning. failed companies don't quietly disappear.

1. before using licensed data, synthetic fixtures test ADR deduplication, share-class mapping, point-in-time label changes, local holidays, asynchronous closes, FX conversion, delisting, duplicate observations, missing filings, and portfolio weights.
2. French Mom fixtures check sign, one-time percent conversion, common-month alignment, annual-section exclusion, and rounding bounds.
3. replay the same manifest, code, and inputs. the numeric artifacts must match.

if a hash changes, the run stops.

• a result can be verified_reconstruction, not_reproduced, not_calculated, or blocked.
• blocked needs a reason. examples include unsupported country history, unresolved issuer mapping, unknown currency timing, or a missing matched Minara factor pair.
• the agent can't guess its way past a missing field.
• coverage counts and missingness go beside the return table.

give every idea a trial-ledger entry

before calculation, each idea gets a versioned hypothesis manifest: economic rationale, exact formula, required fields, availability lag, eligible universe, horizon, formation and execution time, benchmark, costs, development window, holdout, planned variants, and rejection criteria.

the ledger records every run, including parser failures and negative results.

• changing the formula after seeing output creates a new manifest version. the old record stays.
• the registry may use states such as proposed, design_only, data_audited, implemented, challenged, independently_reviewed, research_qualified, rejected, and paper_research.

these status names are proposals. the registry isn't built yet.

1. matching French arithmetic can earn verified_reconstruction. qualifying a stock model needs separate evidence.
2. research_qualified requires source lineage, deterministic calculations, point-in-time checks, frozen validation, cost treatment, and a reviewer who can reproduce the result.
3. that earns a paper-research step. it doesn't authorize capital.
4. for inference, keep same-date names together. report cross-sectional rank correlation by date; don't treat every stock-day as independent.

portfolio Sharpe estimates need uncertainty intervals and a method that handles serial dependence.

• pick the statistic before viewing the holdout. report how many hypotheses and variants were tried.
• Two Sigma’s discussion of Sharpe estimation and hypothesis testing is a useful methods reference.

a statistically significant result can still have survivorship, stale-label, coverage, or execution problems.

give each tool a job it can do

Minara organizes the research desk. i'll use it to organize questions, inspect factor and strategy surfaces, and record supported assets.

1. the first handoffs are manual.
2. a later adapter can use the documented chat API after i test account entitlement, authentication, billing, rate limits, response format, and a research-only prompt.
3. the current docs describe POST /v1/developer/chat and a status route.
4. they specify background: true only with stream: false, document requestId idempotency, and retain completed status for 24 hours.

i'll cache an accepted response before that status expires.

1. the documented route still needs an account test. its answers need checking before they become point-in-time market data.
2. Codex handles deterministic work. each task gets one output, repository, manifest ID, approved inputs, forbidden side effects, and acceptance checks.
3. Codex can write parsers, known-answer tests, data validators, reports, and experiment code.
4. a weak result can't change the frozen factor. an unrun check can't become a pass. prose can't make a candidate eligible.

each change becomes a code diff attached to a new run.

Jev checks typed evidence. source hashes, units, publication timing, missing-data rules, return type, and independent tests go through hard gates first.

a failed gate returns blocked. Jev can't override it.

1. if the artifact passes, Jev may triage it as needs_evidence, schema_issue, or ready_for_human_review.
2. the existing 0.65 threshold is a proposed routing setting, not a calibrated safety boundary.
3. lower confidence means abstain. higher confidence still needs a person's review.
4. Jev can't rank securities, compute returns, override failed tests, or approve a model.

Dots coordinates the work. once an approved cloud project exists, it can track status, maintain the checklist, and prepare bounded task briefs.

Codex still runs the code.

1. until a supported handoff is tested and saved, i'll start Codex tasks manually and compare the returned commit, manifest, run ID, and evidence links.
2. i'll test that with a hostile note trying to redirect the agent. it must stay inside the evidence field.

build it one checkpoint at a time

0. freeze the question. Pick target listing types, AI exposure classes, candidate countries, base currency, and minimum source evidence.

the output is a scope document.

returns wait.

1. audit coverage. Inventory Minara's available stock universe and every proposed external data source.

• produce the country/exchange/date/field matrix, license note, and gaps.
• Minara counts as a supported subset only when its surface and export are verifiable.
• missing historical membership or total returns means not calculated for the affected study.

2. build identity and evidence tables.

• Map issuers and listings with dated aliases, ADR links, calendars, currencies, and evidence labels.
• test duplicate prevention and historical known_at logic on hand-checked examples.
• the check: a reviewer can explain why each entity was included or excluded on a chosen date.

3. create the offline core.

• Add schemas, a lockfile, immutable run folders, hashes, fixture datasets, and proposed CLI commands: qrlab universe-audit, qrlab validate-data, qrlab run, and qrlab report.
• those command names are proposals. they don't work yet.
• the check: a clean checkout validates synthetic data without a product API key.

4. validate the arithmetic.

• Reconstruct one pinned French Mom vintage and run the global-data fixture tests.
• set the tolerance before seeing the result.
• the check: no mixed vintages or silent alignment, bounded residuals, and reproducible files.
• if it fails, record not_reproduced. don't move the bound to force a pass.

5. run the Minara pilot. Request an availability manifest first.

• if the exact same-universe plain/skip pair and required settings are inspectable, freeze them and compare.
• otherwise, Minara keeps organizing research. the mismatched comparison stays unrun.
• before publishing, remove account identifiers and caption exactly what each screenshot shows.

6. preregister the three studies.

• Freeze momentum, quality, and investment-cycle definitions separately.
• start only with the study whose universe, inputs, timestamps, delisted-member coverage, and costs pass review.
• the other two stay in design_only. their outcomes can't steer the first test.

7. add integrations last.

• Verify the API key and cost with one research-only request.
• measure Jev's false-pass and abstention behavior on hand-labeled cases.
• configure Dots after cloud permissions and a narrow task contract are clear.
• the offline core must keep working if an integration fails.

what the first win looks like

the first win is a universe audit i can inspect.

1. it shows what's covered, why each issuer qualifies, and where the history runs out.
2. a formula check and small product pilot then show which parts i can reproduce.
3. after that, momentum, quality, and the investment cycle get their own studies.

the lab gets stronger when it can explain a refusal. missing data leaves a gap in the report, never a confident guess.

more app features to inspect

these panels show more app surfaces and intermediate build states. the global research system still needs building.

• left this coding interface belongs to another saved project. the arrow points to explore, build, review, and fix actions.

• right the import dialog shows an available surface, not a completed import. the arrow points to the image/video drop area.

start with the universe-audit prompt below. a return number gets interesting when someone else can rebuild it.

the first six requests i will give the lab

run these six prompts in order. each artifact constrains the next, with coverage and evidence checked before performance. i'll save every exact prompt with its manifest and run ID.

1. Universe audit

1Create a proposed universe scope for global listed AI equities. Do not return a bare ticker list.
2
3Separate issuer from listing and define the common-share/ADR core, excluded instrument types, country and exchange coverage questions, and the evidence needed to classify direct AI exposure, suppliers/enablers, and watchlist-only claims.
4
5List the sources and fields we would need for current and historical membership. Mark every unknown. Do not infer complete global coverage or assign historical labels from current descriptions.
6
7Output a versioned UniverseManifest draft and a coverage-audit checklist only; do not backtest.

2. Value-chain evidence

1Using only the supplied dated filings and source documents, map each candidate issuer to the proposed AI value-chain taxonomy.
2
3For every label, quote or locate the supporting evidence, record document date and publication timestamp, business segment, issuer/listing identifiers, source hash, label rule, and reviewer status.
4
5Distinguish disclosed direct AI revenue, identifiable suppliers/enablers, and management-claim-only or weak evidence.
6
7If evidence is absent or conflicts, use unknown/watchlist and explain why. Do not create historical labels before the document was public.

3. Three hypotheses

1Draft three separate, pre-registerable research specs for the audited universe: (a) plain 12-month vs 12–2 momentum, (b) a small quality composite with point-in-time accounting inputs, and (c) one AI investment-cycle measure that separates realized capex from guidance or commitments.
2
3For each, state formula, expected direction, availability lag, eligible sample, benchmark, horizon, controls, variants, costs, rejection rule, and holdout.
4
5Do not estimate performance or combine the hypotheses into one score. Mark any spec design_only when a required field or history is unavailable.

4. Minara supported-subset comparison

1Before running a strategy, report which global stock listings, factor definitions, dates, portfolio settings, cost settings, and export fields are actually supported in this Minara account.
2
3 Propose a matched plain-12-month vs 12–2 comparison only if both formulas use the same verified universe and every setting except the signal is identical.
4
5If a same-lookback pair, point-in-time membership, or required output is unavailable, stop and return not_calculated. Do not substitute another lookback or quote unverified performance as evidence.

5. Codex engineering task

1Implement only the approved offline universe-audit and data-validation milestone in the quant-research-lab repository.
2
3Start from the approved UniverseManifest and DataManifest.
4
5Use synthetic fixtures unless licensed source snapshots are explicitly provided. Add issuer/listing deduplication, dated AI evidence labels, coverage counts, timestamp and currency/calendar checks, deterministic tests, and immutable run outputs.
6
7Do not call external APIs, change frozen hypotheses, fetch licensed data, generate trades, or claim the global coverage is complete. Return the diff, command, test output, hashes, blocked fields, and next decision for human review.

6. Skeptical audit

1Review the frozen manifests, source files, code diff, test output, and run artifacts without relying on the summary.
2
3Try to falsify the universe mapping and any performance claim.
4
5Check duplicate issuers/ADRs, survivorship, AI-label lookahead, missing countries, unverified data rights, stale currencies, asynchronous closes, FX timing, corporate actions, delistings, cost assumptions, test leakage, and every change from the preregistered plan.
6
7Cite exact artifact paths and hashes.
8
9Do not repair or rerun anything. Return pass, blocked, or not_reproduced for each requirement, list counterexamples, and state what the result does not establish.

source notes

• Minara, Agent API overview and API-key endpoint reference. Product entitlement and account access remain untested.

• Kenneth French, Monthly Momentum Factor construction and Data Library vintage and CRSP FIZ/CIZ notes.

• AQR, Fact, Fiction, and Momentum Investing.

• Two Sigma, Sharpe ratio estimation and hypothesis testing.

• TypeSafe, Jev and typed decision outputs; OpenAI, Introducing Dots.

• DuckDB, Parquet documentation; pytest, documentation.