---
title: "Brain Emulation Guesstimator — AI Edition"
document_id: sobe-2025-guesstimator-ai
language: en
document_type: interactive_model
edition_version: "1.0"
artifact_url: https://brainemulation.mxschons.com/ai/guesstimator.md
interactive_authority: https://brainemulation.mxschons.com/guesstimator/
manifest: manifest.json
---

# Brain Emulation Guesstimator — AI Edition

> This artifact exposes the Guesstimator's model structure, assumptions, exact input snapshots, and calculation code in a form an AI can read directly. Use it to inspect or compare scenarios. The [interactive Guesstimator](../guesstimator/) controls the current user-facing behavior, and the published report PDFs remain authoritative for report claims.

![Brain Emulation Guesstimator interface](../images/brain-emulation-guesstimator-preview.webp)

## What this model is

The Guesstimator is a scenario-exploration tool for rough cost, time, storage, and compute estimates for brain-emulation projects. It is not a forecast, procurement quote, feasibility determination, or claim that all scientific unknowns have been resolved. Its estimates change with the selected organism, recording plan, connectomics method, storage policy, simulation model, hardware, technology multiplier, risk buffer, and optional unknown-factor allowances.

For questions about the scientific report, use [`report.md`](report.md) or a file from the [`report-sections` index](report-sections/index.md). For a model calculation, use the exact inputs and JavaScript below; state every changed assumption and distinguish calculated output from published evidence.

## Suggested prompt

> Read the Brain Emulation Guesstimator AI artifact at https://brainemulation.mxschons.com/ai/guesstimator.md. Compare a mouse and a human scenario using the documented defaults. Explain the assumptions that dominate cost and time, cite the relevant input-table paths and calculation-function names, and label every result as a scenario estimate rather than a forecast. Ask me before choosing values that are not specified.

## Agent navigation

- **Run or share a scenario:** [interactive Guesstimator](../guesstimator/)
- **Exact runtime calculations:** [`code/guesstimator/calculations.js`](code/guesstimator/calculations.js)
- **App-local assumptions and presets:** [`code/guesstimator/constants.js`](code/guesstimator/constants.js)
- **Input loading and parsing:** [`code/guesstimator/data-loader.js`](code/guesstimator/data-loader.js)
- **Formula parser:** [`code/guesstimator/formula-engine.js`](code/guesstimator/formula-engine.js)
- **UI state, total aggregation, and output labels:** [`code/guesstimator/BrainEmulationCalculator.jsx`](code/guesstimator/BrainEmulationCalculator.jsx)
- **Machine-readable file hashes:** [`manifest.json`](manifest.json), document ID `sobe-2025-guesstimator-ai`

## Model map

| Stage | Principal inputs | Principal outputs | Behavioral source |
|---|---|---|---|
| Neural recording | organism neurons, samples, brain fraction, experiment duration, current recording capacity, technology multiplier, buffer | experiments, coverage, raw recording data, first and marginal cost/time | `calculateRecording` |
| Connectomics | brain volume, modality, effective resolution, channels, microscopes, GPUs, proofreading, technology multiplier | voxels, raw PB, imaging/processing/proofreading cost and bottleneck time | `calculateConnectomics` |
| Storage | raw connectomics PB, compression, replicas, retention, storage prices, buffer | active/archive PB and first/marginal storage cost | `calculateStorage` |
| Simulation | neuron/synapse counts and model costs, GPU memory/throughput/hourly cost, technology multiplier | memory, FLOP/s, GPU count, first and marginal simulation cost/time | `calculateSimulation` |
| Unknown factors | optional preset or custom cost/time allowances | additions to first and marginal totals | `BrainEmulationCalculator.jsx` |

The displayed **first project** total includes infrastructure and method-development assumptions. The **marginal project** total assumes substantial reuse. Overall time is the maximum of the modeled parallel stage times, not their sum. Optional unknown-factor costs are reduced by `1 / sqrt(techMultiplier)`; their time contribution is the maximum selected factor time.

## Source-of-truth boundary

The deployed source snapshot loads the TSV files reproduced below and supplements them with assumptions in `constants.js`. The runtime constructs formula-engine objects from the formula TSVs, but in this source snapshot the four output functions use direct JavaScript arithmetic rather than invoking those engines. Therefore:

1. Treat `calculations.js` plus the total-aggregation excerpt as the behavioral authority for numeric outputs.
2. Treat the formula TSVs as explicit methodology/reference catalogs unless code is changed to call the engines.
3. Treat the live interactive page as authoritative if its deployed behavior differs from this committed snapshot.
4. Treat report PDFs—not this calculator—as authoritative for claims made by the report.

## Total aggregation

The stage outputs and optional unknown factors are combined by the UI as follows:

```javascript
// Total costs and times for first project vs marginal
  const totalCostFirst = recording.totalCostFirst + reconstructionCostFirst + storageCostFirst + unknownsCostFirst + simulation.totalCostFirst;
  const totalCostMarginal = recording.totalCostMarginal + reconstructionCostMarginal + storageCostMarginal + unknownsCostMarginal + simulation.totalCostMarginal;
  const totalTimeFirst = Math.max(recording.totalTimeYearsFirst, conn.totalYearsFirst, unknownsTimeFirst, simulation.totalTimeYearsFirst);
  const totalTimeMarginal = Math.max(recording.totalTimeYearsMarginal, conn.totalYearsMarginal, unknownsTimeMarginal, simulation.totalTimeYearsMarginal);
```

## Calculation functions

These are the exact exported functions used by the current source snapshot. Data-building helpers and URL-state logic remain available in the linked complete source.

### `calculateRecording`

```javascript
export function calculateRecording(organismData, organismKey, samples, sampleLengthSeconds, brainFraction, techMultiplier, buffer) {
  const org = organismData;
  // Prefer repo data, fall back to constants
  const spec = RECORDING_SPECS_REPO[organismKey] || RECORDING_SPECS[organismKey] || RECORDING_SPECS.custom;
  const expDurationMinutes = EXPERIMENT_DURATION_MINUTES_REPO || EXPERIMENT_DURATION_MINUTES;

  const maxNeuronsPerExperiment = Math.ceil(spec.maxNeurons * techMultiplier);
  const neuronsToRecord = Math.ceil(org.neurons * brainFraction);

  const experimentsForCoverage = Math.ceil(neuronsToRecord / maxNeuronsPerExperiment);

  const experimentDurationSeconds = expDurationMinutes * 60;
  const samplesPerExperiment = Math.floor(experimentDurationSeconds / sampleLengthSeconds);

  const experimentsForSamples = Math.ceil(samples / Math.max(samplesPerExperiment, 1));

  const totalExperiments = Math.max(experimentsForCoverage, experimentsForSamples);

  const actualSamples = totalExperiments * samplesPerExperiment;

  const totalRecordingHours = (totalExperiments * expDurationMinutes) / 60;
  const totalRecordingSeconds = totalExperiments * experimentDurationSeconds;

  const imagingGBps = spec.imagingGBps / techMultiplier;
  const totalImagingDataGB = imagingGBps * totalRecordingSeconds;
  const totalImagingDataTB = totalImagingDataGB / 1000;
  const totalImagingDataPB = totalImagingDataTB / 1000;

  const neuronsActuallyCovered = Math.min(totalExperiments * maxNeuronsPerExperiment, org.neurons);
  const coveragePercent = (neuronsActuallyCovered / org.neurons) * 100;

  const setupCostPerExperiment = spec.setupCost / techMultiplier;
  const recordingCostPerExperiment = (maxNeuronsPerExperiment * (expDurationMinutes / 60) * spec.costPerNeuronHour) / techMultiplier;
  const costPerExperiment = setupCostPerExperiment + recordingCostPerExperiment;

  const infrastructureCost = 500000 / techMultiplier;
  const experimentTimeHours = totalExperiments * (expDurationMinutes / 60 + 0.5);
  const personnelCostFirst = 5 * 150000 * Math.min(experimentTimeHours / (24 * 365), 3);
  const totalCostFirst = (costPerExperiment * totalExperiments + infrastructureCost + personnelCostFirst) * (1 + buffer);
  const totalTimeYearsFirst = (experimentTimeHours / (24 * 365)) * (1 + buffer);

  const marginalCostPerExperiment = (setupCostPerExperiment * 0.2 + recordingCostPerExperiment) * 0.8;
  const totalCostMarginal = marginalCostPerExperiment * totalExperiments * (1 + buffer * 0.25);
  const totalTimeYearsMarginal = (experimentTimeHours * 0.7 / (24 * 365)) * (1 + buffer * 0.25);

  return {
    maxNeuronsPerExperiment,
    neuronsToRecord,
    experimentsForCoverage,
    experimentsForSamples,
    totalExperiments,
    samplesPerExperiment,
    actualSamples,
    experimentDurationMinutes: EXPERIMENT_DURATION_MINUTES,
    totalRecordingHours,
    totalRecordingSeconds,
    neuronsActuallyCovered,
    coveragePercent,
    imagingGBps: spec.imagingGBps,
    totalImagingDataGB,
    totalImagingDataTB,
    totalImagingDataPB,
    costPerExperiment,
    infrastructureCost,
    personnelCostFirst,
    totalCostFirst,
    totalTimeYearsFirst,
    marginalCostPerExperiment,
    totalCostMarginal,
    totalTimeYearsMarginal,
  };
}
```

### `calculateConnectomics`

```javascript
export function calculateConnectomics(organismData, modality, proofreadingHours, molecularAnnotations, params, techMultiplier, buffer, effectiveResolution) {
  const mod = MODALITIES[modality];
  const org = organismData;
  const volume = org.volume;
  const neurons = org.neurons;

  const effectiveVoxelX = effectiveResolution;
  const effectiveVoxelY = effectiveResolution;
  const effectiveVoxelZ = effectiveResolution;

  const volumeNm3 = volume * 1e18;
  const voxelVolumeNm3 = effectiveVoxelX * effectiveVoxelY * effectiveVoxelZ;
  const totalVoxels = volumeNm3 / voxelVolumeNm3;
  const totalPetavoxels = totalVoxels / 1e15;

  const totalChannels = molecularAnnotations > 0 ? mod.channels : 1;
  const imagingRounds = Math.ceil(totalChannels / mod.parallelChannels);
  const totalVoxelsWithChannels = totalVoxels * imagingRounds;

  const rawBytes = totalVoxelsWithChannels * STORAGE_SPECS.bytesPerVoxel;
  const rawPetabytes = rawBytes / 1e15;

  const imagingRateBytesPerSec = mod.imagingRate * 1e6 * techMultiplier;
  const imagingSeconds = rawBytes / imagingRateBytesPerSec;
  const imagingDays = imagingSeconds / (24 * 3600);
  const imagingYears = imagingDays / 365;

  const numMicroscopes = params.microscopes;
  const imagingYearsFirst = (imagingDays + mod.preparationDays) / 365 / numMicroscopes;

  // Imaging cost - Capital purchase model
  // Capital cost: full purchase price for all microscopes (first project only)
  const capitalCost = numMicroscopes * mod.scopeCost;
  // Operating cost per year (service + technician)
  const operatingCostPerYear = mod.servicePerYear + mod.techSalary / mod.techRatio;
  // Volume-based costs (consumables, antibodies, labor)
  const volumeCostFirst = volume * (mod.consumablesPerMm3 + mod.antibodyPerMm3 + mod.laborPerMm3);
  const volumeCostMarginal = volume * (mod.consumablesPerMm3 + mod.antibodyPerMm3 + mod.laborPerMm3 * 0.5);
  // First project: capital + operating + volume (capital scales with microscope count!)
  const imagingCostFirst = capitalCost + operatingCostPerYear * numMicroscopes * imagingYearsFirst + volumeCostFirst;
  // Marginal project: NO capital (already own microscopes) + operating + volume
  const imagingCostMarginal = operatingCostPerYear * numMicroscopes * (imagingDays / 365 / numMicroscopes) + volumeCostMarginal;

  const tilesTotal = totalVoxelsWithChannels / (mod.tileX * mod.tileY * mod.sampleDepth * (1 - mod.tileOverlap) ** 2);
  const registrationTflops = tilesTotal * PROCESSING_SPECS.registrationTflopsPerTile;
  const segmentationTflops = totalVoxels * PROCESSING_SPECS.segmentationTflopsPerVoxel;
  const totalProcessingTflops = registrationTflops + segmentationTflops;

  const gpuTflopsPerSec = PROCESSING_SPECS.gpuPeakTflops * PROCESSING_SPECS.gpuUtilization * techMultiplier;
  const processingSeconds = (totalProcessingTflops * 1e12) / (gpuTflopsPerSec * 1e12);
  const processingHours = processingSeconds / 3600;
  const numGPUs = params.gpus;
  const processingYears = processingHours / (24 * 365 * numGPUs);
  // Cost = numGPUs × time running × hourly rate per GPU
  // This equals processingHours × rate (total GPU-hours × rate) but makes resource dependency explicit
  const processingCost = numGPUs * processingYears * 24 * 365 * PROCESSING_SPECS.gpuCostPerHour / techMultiplier;

  const proofreadingTotalHours = neurons * proofreadingHours / techMultiplier;
  const numProofreaders = params.proofreaders;
  const proofreadingDays = proofreadingTotalHours / (PROCESSING_SPECS.proofreaderHoursPerDay * numProofreaders);
  const proofreadingYears = proofreadingDays / 365;
  // Cost = numProofreaders × days × hours/day × hourly rate
  // This equals proofreadingTotalHours × rate (total person-hours × rate) but makes resource dependency explicit
  const proofreadingCost = numProofreaders * proofreadingDays * PROCESSING_SPECS.proofreaderHoursPerDay * PROCESSING_SPECS.proofreaderHourlyRate;

  const subtotalFirst = imagingCostFirst + processingCost + proofreadingCost;
  const subtotalMarginal = imagingCostMarginal + processingCost + proofreadingCost;
  const totalYearsFirst = Math.max(imagingYearsFirst, processingYears, proofreadingYears);
  const totalYearsMarginal = Math.max(imagingDays / 365 / numMicroscopes, processingYears, proofreadingYears);

  return {
    effectiveVoxelX,
    effectiveVoxelY,
    effectiveVoxelZ,
    totalVoxels,
    totalPetavoxels,
    totalChannels,
    imagingRounds,
    rawBytes,
    rawPetabytes,
    imagingSeconds,
    imagingDays,
    imagingYears,
    imagingYearsFirst,
    imagingCostFirst,
    imagingCostMarginal,
    processingHours,
    processingYears,
    processingCost,
    proofreadingTotalHours,
    proofreadingDays,
    proofreadingYears,
    proofreadingCost,
    subtotalFirst,
    subtotalMarginal,
    totalYearsFirst,
    totalYearsMarginal,
    neurons,
  };
}
```

### `calculateStorage`

```javascript
export function calculateStorage(rawPetabytes, storageParams, buffer, techMultiplier = 1) {
  const {
    lossyCompression,
    losslessCompression,
    activeReplicas,
    archiveReplicas,
    activeRetentionYears,
    archiveRetentionYears,
  } = storageParams;

  const labelOverhead = 1 + STORAGE_SPECS.structureLabelOverhead;

  const rawPB = rawPetabytes;
  const activePB = (rawPB / lossyCompression) * labelOverhead;
  const archivePB = (rawPB / losslessCompression) * labelOverhead;

  const activeCostPerPBYear = STORAGE_SPECS.activeStorageCostPerPBYear / techMultiplier;
  const archiveCostPerPBYear = STORAGE_SPECS.archiveStorageCostPerPBYear / techMultiplier;

  const activeCostFirst = activePB * activeReplicas * activeCostPerPBYear * activeRetentionYears;
  const archiveCostFirst = archivePB * archiveReplicas * archiveCostPerPBYear * archiveRetentionYears;
  const totalCostFirst = (activeCostFirst + archiveCostFirst) * (1 + buffer);

  const marginalActiveReplicas = Math.min(activeReplicas, STORAGE_SPECS.marginalActiveReplicas);
  const marginalArchiveReplicas = Math.min(archiveReplicas, STORAGE_SPECS.marginalArchiveReplicas);
  const activeCostMarginal = activePB * marginalActiveReplicas * activeCostPerPBYear * activeRetentionYears;
  const archiveCostMarginal = archivePB * marginalArchiveReplicas * archiveCostPerPBYear * archiveRetentionYears;
  const totalCostMarginal = (activeCostMarginal + archiveCostMarginal) * (1 + buffer * 0.25);

  return {
    rawPB,
    activePB,
    archivePB,
    activeCostFirst,
    archiveCostFirst,
    totalCostFirst,
    activeCostMarginal,
    archiveCostMarginal,
    totalCostMarginal,
  };
}
```

### `calculateSimulation`

```javascript
export function calculateSimulation(organismData, modelParams, techMultiplier, gpuSpecs) {
  const org = organismData;
  const { neuronBytes, neuronFlopsPerSec, synapseBytes, synapseFlopsPerSec } = modelParams;

  const FIRING_RATE_HZ = 10;
  const SIMULATION_HOURS = 1000;
  const TRAINING_INFRASTRUCTURE_COST = 10000000;
  const TRAINING_COMPUTE_FACTOR = 0.1;
  const VALIDATION_FACTOR = 0.05;
  const BUFFER = 0.2;
  const MARGINAL_RETRAINING_FACTOR = 0.1;
  const MARGINAL_FINETUNING_FACTOR = 0.02;

  const neuronMemoryBytes = org.neurons * neuronBytes;
  const synapseMemoryBytes = org.synapses * synapseBytes;
  const totalMemoryBytes = neuronMemoryBytes + synapseMemoryBytes;
  const totalMemoryGB = totalMemoryBytes / 1e9;
  const neuronMemoryGB = neuronMemoryBytes / 1e9;
  const synapseMemoryGB = synapseMemoryBytes / 1e9;

  const neuronFlopsTotal = org.neurons * neuronFlopsPerSec;
  const synapseFlopsTotal = org.synapses * synapseFlopsPerSec;
  const flopsPerSecTimeBased = neuronFlopsTotal + synapseFlopsTotal;

  const spikesPerSec = org.neurons * FIRING_RATE_HZ;
  const flopsPerSecEventDriven = spikesPerSec * (neuronFlopsPerSec / FIRING_RATE_HZ + org.synapses / org.neurons * synapseFlopsPerSec / FIRING_RATE_HZ);

  const gpuMemory = gpuSpecs.memory;
  const gpuTflops = gpuSpecs.tflops * techMultiplier;
  const gpuCost = gpuSpecs.cost / techMultiplier;

  const gpusForMemory = Math.ceil(totalMemoryGB / gpuMemory);
  const gpusForCompute = Math.ceil(flopsPerSecTimeBased / (gpuTflops * 1e12));
  const totalGpus = Math.max(gpusForMemory, gpusForCompute);

  const simulationHoursTotal = SIMULATION_HOURS;
  const simulationCost = totalGpus * gpuCost * simulationHoursTotal;
  const trainingInfrastructureCost = TRAINING_INFRASTRUCTURE_COST / techMultiplier;
  const trainingComputeCost = simulationCost * TRAINING_COMPUTE_FACTOR;
  const validationCost = simulationCost * VALIDATION_FACTOR;

  const totalCostFirst = (simulationCost + trainingInfrastructureCost + trainingComputeCost + validationCost) * (1 + BUFFER);
  const totalTimeYearsFirst = (simulationHoursTotal / (24 * 365)) * (1 + BUFFER);

  const retrainingCost = trainingComputeCost * MARGINAL_RETRAINING_FACTOR;
  const finetuningCost = validationCost * MARGINAL_FINETUNING_FACTOR;
  const totalCostMarginal = simulationCost + retrainingCost + finetuningCost;
  const totalTimeYearsMarginal = simulationHoursTotal / (24 * 365);

  return {
    neuronMemoryBytes,
    synapseMemoryBytes,
    totalMemoryBytes,
    totalMemoryGB,
    neuronMemoryGB,
    synapseMemoryGB,
    flopsPerSecTimeBased,
    flopsPerSecEventDriven,
    gpusForMemory,
    gpusForCompute,
    totalGpus,
    simulationCost,
    trainingInfrastructureCost,
    trainingComputeCost,
    validationCost,
    totalCostFirst,
    totalTimeYearsFirst,
    retrainingCost,
    finetuningCost,
    totalCostMarginal,
    totalTimeYearsMarginal,
  };
}
```

## App-local assumptions and presets

These values are not all repository-backed. They include fallbacks, unknown-factor allowances, storage and resolution presets, hardware hourly-cost supplements, and baseline/per-organism defaults. The exact file is reproduced inline so an agent does not silently omit these assumptions.

```javascript
/**
 * App-Local Constants
 *
 * These constants are NOT sourced from the data repository.
 * They include:
 * - Unknown factors (subjective estimates)
 * - Recording specifications (until repo is updated)
 * - Additional neuron/synapse models (until repo is updated)
 * - Storage presets (until repo is updated)
 * - UI-specific constants
 */

// ============================================================================
// ORGANISM ICONS (UI-only, not in repo)
// ============================================================================

export const ORGANISM_ICONS = {
  c_elegans: '🪱',
  drosophila: '🪰',
  zebrafish_larva: '🐟',
  mouse: '🐭',
  macaque: '🐒',
  human: '🧬',
  custom: '⚙️',
};

// ============================================================================
// UNKNOWN FACTORS (Subjective estimates - not in repo)
// ============================================================================

// These represent end-to-end costs and timelines for factors not explicitly modeled
export const UNKNOWN_FACTOR_PRESETS = {
  nonNeuronal: {
    id: 'nonNeuronal',
    name: 'Non-Neuronal Factors',
    description: 'Glial cells, vasculature, extracellular matrix mapping and modeling',
    costFirst: 50000000,      // $50M - significant additional imaging and analysis
    costMarginal: 10000000,   // $10M - reuse methods but still need per-brain analysis
    timeFirst: 2,             // 2 years - method development + execution
    timeMarginal: 0.5,        // 6 months - apply established methods
  },
  neuroplasticity: {
    id: 'neuroplasticity',
    name: 'Neuroplasticity',
    description: 'Synaptic plasticity rules, learning dynamics, longitudinal studies',
    costFirst: 100000000,     // $100M - extensive longitudinal experiments
    costMarginal: 20000000,   // $20M - validation studies
    timeFirst: 3,             // 3 years - long-term studies required
    timeMarginal: 1,          // 1 year - apply known plasticity rules
  },
  perturbation: {
    id: 'perturbation',
    name: 'Perturbation Experiments',
    description: 'Optogenetics, pharmacology, lesion studies for causal validation',
    costFirst: 75000000,      // $75M - extensive experimental campaigns
    costMarginal: 15000000,   // $15M - targeted validation
    timeFirst: 2.5,           // 2.5 years - experimental iteration
    timeMarginal: 0.5,        // 6 months - focused experiments
  },
  molecularDynamics: {
    id: 'molecularDynamics',
    name: 'Molecular Dynamics',
    description: 'Ion channel kinetics, receptor dynamics, neuromodulation',
    costFirst: 40000000,      // $40M - detailed biophysical characterization
    costMarginal: 8000000,    // $8M - species-specific calibration
    timeFirst: 2,             // 2 years - method development
    timeMarginal: 0.5,        // 6 months - apply established models
  },
  behavioralValidation: {
    id: 'behavioralValidation',
    name: 'Behavioral Validation',
    description: 'End-to-end behavioral testing, ethological benchmarks',
    costFirst: 30000000,      // $30M - comprehensive behavioral testing
    costMarginal: 10000000,   // $10M - validation suite
    timeFirst: 1.5,           // 1.5 years - develop and run benchmarks
    timeMarginal: 0.5,        // 6 months - run established tests
  },
};

// ============================================================================
// RECORDING SPECIFICATIONS (Until repo has recording-capabilities.tsv)
// ============================================================================

// Per-organism recording specifications
// maxNeurons: Maximum neurons recordable simultaneously with current technology
// costPerNeuronHour: Cost per neuron-hour of recording
// setupCost: One-time setup cost per recording session/animal
// imagingGBps: Data rate in GB/s for calcium imaging
export const RECORDING_SPECS = {
  c_elegans: { maxNeurons: 150, costPerNeuronHour: 0.01, setupCost: 10000, imagingGBps: 0.5 },
  drosophila: { maxNeurons: 2000, costPerNeuronHour: 0.1, setupCost: 100000, imagingGBps: 2 },
  zebrafish_larva: { maxNeurons: 10000, costPerNeuronHour: 0.05, setupCost: 50000, imagingGBps: 3 },
  mouse: { maxNeurons: 5000, costPerNeuronHour: 0.5, setupCost: 500000, imagingGBps: 5 },
  macaque: { maxNeurons: 2000, costPerNeuronHour: 2, setupCost: 2000000, imagingGBps: 5 },
  human: { maxNeurons: 1000, costPerNeuronHour: 10, setupCost: 5000000, imagingGBps: 2 },
  custom: { maxNeurons: 5000, costPerNeuronHour: 0.5, setupCost: 500000, imagingGBps: 5 },
};

export const EXPERIMENT_DURATION_MINUTES = 30;

// ============================================================================
// STORAGE PRESETS (Until repo has storage-presets.tsv)
// ============================================================================

export const STORAGE_PRESETS = {
  minimal: {
    name: 'Minimal',
    description: 'Single copy, lossy only',
    lossyCompression: 120,
    losslessCompression: 1.5,
    activeReplicas: 1,
    archiveReplicas: 0,
    activeRetentionYears: 3,
    archiveRetentionYears: 0,
  },
  standard: {
    name: 'Standard',
    description: '3 active + 2 archive copies',
    lossyCompression: 120,
    losslessCompression: 1.5,
    activeReplicas: 3,
    archiveReplicas: 2,
    activeRetentionYears: 5,
    archiveRetentionYears: 10,
  },
  archival: {
    name: 'Archival',
    description: 'Maximum redundancy, longer retention',
    lossyCompression: 120,
    losslessCompression: 1.5,
    activeReplicas: 3,
    archiveReplicas: 3,
    activeRetentionYears: 10,
    archiveRetentionYears: 20,
  },
};

// ============================================================================
// RESOLUTION PRESETS
// ============================================================================

export const RESOLUTION_PRESETS = {
  '5nm': {
    name: '5nm³',
    description: 'Ultra-high resolution',
    resolution: 5,
  },
  '10nm': {
    name: '10nm³ (Wellcome)',
    description: 'Wellcome standard, synaptic detail',
    resolution: 10,
  },
  '15nm': {
    name: '15nm³',
    description: 'Standard EM resolution',
    resolution: 15,
  },
  '20nm': {
    name: '20nm³',
    description: 'Good synaptic visibility',
    resolution: 20,
  },
  '30nm': {
    name: '30nm³',
    description: 'Lower resolution, faster imaging',
    resolution: 30,
  },
};

// ============================================================================
// ADDITIONAL NEURON/SYNAPSE MODELS (Until repo is updated)
// These supplement the models in the data repository
// ============================================================================

// Additional neuron models not yet in the repo
export const ADDITIONAL_NEURON_MODELS = {
  izhikevich: {
    name: 'Izhikevich',
    shortName: 'Izhikevich',
    flopsPerSec: 1.3e5,
    flopsPerSpike: 25,
    bytes: 16,
    description: 'Efficient spiking model capturing many firing patterns',
  },
  adex: {
    name: 'Adaptive Exponential',
    shortName: 'AdEx',
    flopsPerSec: 2e5,
    flopsPerSpike: 30,
    bytes: 24,
    description: 'Two-variable model with adaptation and exponential spike',
  },
};

// Additional synapse models not yet in the repo
export const ADDITIONAL_SYNAPSE_MODELS = {
  exponential: {
    name: 'Double Exponential',
    shortName: 'Exp2Syn',
    flopsPerSec: 6e4,
    flopsPerEvent: 30,
    bytes: 12,
    description: 'Rise and decay time constants',
  },
  stdp: {
    name: 'STDP Plastic',
    shortName: 'STDP',
    flopsPerSec: 1.2e5,
    flopsPerEvent: 80,
    bytes: 24,
    description: 'Spike-timing dependent plasticity',
  },
};

// ============================================================================
// GPU SYSTEMS (Supplemental - cost_per_hour until repo is updated)
// ============================================================================

// Keys must match normalized format from buildGPUSystems():
// name.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_|_$/g, '')
export const GPU_COST_PER_HOUR = {
  'macbook_pro_2024_m4_pro': 0.5,
  'mac_studio_m2_ultra': 0.8,
  'nvidia_a100_sxm_80gb': 2,
  'nvidia_h100_nvl': 3,
  'nvidia_dgx_gh200': 50,
  'nvidia_hgx_b200': 10,
  'nvidia_tesla_c870': 0.1,
};

// ============================================================================
// DEFAULT SETTINGS
// ============================================================================

export const BASELINE_DEFAULTS = {
  // Global
  techMultiplier: 1,
  globalBuffer: 0.2,

  // Recording
  recordingSamples: 1000000,
  recordingBrainFraction: 1,
  sampleLengthSeconds: 10,

  // Connectomics
  selectedModality: 'exm',
  effectiveResolution: 10,
  proofreadingHours: 5,
  molecularAnnotations: 0,
  numMicroscopes: 100,
  numGPUs: 1000,
  numProofreaders: 10000,

  // Storage
  storagePreset: 'standard',
  lossyCompression: 120,
  losslessCompression: 1.5,
  activeReplicas: 3,
  archiveReplicas: 2,
  activeRetentionYears: 5,
  archiveRetentionYears: 10,

  // Simulation
  neuronModel: 'lif',
  synapseModel: 'alpha',
  gpuSystem: 'nvidia_h100_nvl',
};

// Per-organism default overrides
export const ORGANISM_DEFAULTS = {
  c_elegans: {
    recordingSamples: 100000,
    recordingBrainFraction: 0.5,
    selectedModality: 'em',
    proofreadingHours: 0.1,
    numMicroscopes: 1,
    numGPUs: 10,
    numProofreaders: 10,
    neuronModel: 'lif',
    synapseModel: 'alpha',
  },
  drosophila: {
    recordingSamples: 100000,
    recordingBrainFraction: 0.014,
    selectedModality: 'em',
    proofreadingHours: 0.25,
    numMicroscopes: 5,
    numGPUs: 100,
    numProofreaders: 100,
    neuronModel: 'izhikevich',
    synapseModel: 'alpha',
  },
  zebrafish_larva: {
    recordingSamples: 50000,
    recordingBrainFraction: 0.1,
    selectedModality: 'exm',
    proofreadingHours: 0.25,
    numMicroscopes: 10,
    numGPUs: 200,
    numProofreaders: 500,
    neuronModel: 'izhikevich',
    synapseModel: 'alpha',
  },
  mouse: {
    recordingSamples: 1000000,
    recordingBrainFraction: 0.00007,
    selectedModality: 'exm',
    proofreadingHours: 5,
    numMicroscopes: 100,
    numGPUs: 1000,
    numProofreaders: 25000,
    neuronModel: 'adex',
    synapseModel: 'tsodyks',
  },
  macaque: {
    recordingSamples: 100000,
    recordingBrainFraction: 0.0000003,
    selectedModality: 'exm',
    proofreadingHours: 7.5,
    numMicroscopes: 200,
    numGPUs: 10000,
    numProofreaders: 100000,
    neuronModel: 'hh5',
    synapseModel: 'tsodyks',
  },
  human: {
    recordingSamples: 10000,
    recordingBrainFraction: 0.000000012,
    selectedModality: 'exm',
    proofreadingHours: 10,
    numMicroscopes: 500,
    numGPUs: 100000,
    numProofreaders: 25000,
    neuronModel: 'hh5',
    synapseModel: 'tsodyks',
  },
  custom: {},
};

// Helper to get defaults for an organism
export const getOrganismDefaults = (organismKey) => {
  return {
    ...BASELINE_DEFAULTS,
    ...(ORGANISM_DEFAULTS[organismKey] || {}),
  };
};

// ============================================================================
// SAMPLE DATASET REFERENCES (For comparison UI)
// ============================================================================

export const SAMPLE_REFERENCES = [
  { name: 'MNIST', samples: 60000, description: 'Handwritten digits' },
  { name: 'ImageNet', samples: 1000000, description: '1M labeled images' },
  { name: 'Whisper', samples: 20000000, description: '20M 30-sec audio clips' },
  { name: 'LAION-5B', samples: 100000000, description: '100M image-text pairs' },
];

// ============================================================================
// SPREADSHEET REFERENCE
// ============================================================================

export const SPREADSHEET_URL = 'https://docs.google.com/spreadsheets/d/1NcgB_vFjjsxET_r6Fy5LybJg_66vRq7-/edit?gid=1184134225#gid=1184134225';
```

## Exact runtime input snapshots

The following 14 TSV files are the inputs requested by `loadAllData()` in this source snapshot. They are copied from the website-synchronized data repository, provided inline, individually downloadable, and SHA-256 hashed in the manifest. Some source tables are ragged; their inline renderings only append empty trailing cells so every row is machine-parseable. The downloadable snapshots preserve the exact source bytes.

### `organisms/organisms.tsv`

[Download the exact TSV snapshot](data/guesstimator/organisms/organisms.tsv).

```tsv
id	name	neurons	volume_mm3	synapses	source	icon	ref_id	supporting_refs	ref_note	confidence	validated_by
c_elegans	C. elegans	302	0.001	7500	WormAtlas	🪱				none	none
drosophila	Drosophila (fruit fly)	135000	0.5	50000000	FlyWire	🪰				none	none
zebrafish_larva	Zebrafish larva	100000	0.1	10000000	Literature	🐟				none	none
mouse	Mouse	70000000	500	700000000000	Literature	🐭				none	none
macaque	Macaque	6400000000	87000	6.4e+13	Literature	🐒				none	none
human	Human	86000000000	1200000	1.5e+14	Literature	🧬				none	none
```

### `parameters/shared.tsv`

[Download the exact TSV snapshot](data/guesstimator/parameters/shared.tsv).

```tsv
id	name	definition	unit	value	ref_id	supporting_refs	ref_note	confidence	validated_by
biological_volume	Volume (biological)	Physical brain volume to be mapped	mm³	500	sobe_2025		Complete mouse brain volume	derived	human
neuron_count	Number of neurons	Number of neurons in the given volume	count	70000000	sobe_2025		Based on State of Brain Emulation report	derived	human
risk_buffer_first	Risk buffer first connectome	Budget and schedule contingency fraction	fraction	0.2			Standard range of risk buffers (20%); Internal estimate	assumed	human
risk_buffer_marginal	Risk buffer marginal connectomes	Budget and schedule contingency fraction	fraction	0.05			Standard range of risk buffers (5%); Internal estimate	assumed	human
years_until_start	Years until start	Years from now when initial purchases are made	years	0			Planning assumption; Internal estimate	assumed	human
project_duration	Project duration	Time span for overall project	years	5			Planning assumption; Internal estimate	assumed	human
microscope_budget	Microscope budget	Upfront investment in microscopes	$	50000000			Planning assumption; Internal estimate	assumed	human
max_parallel_gpus	Max parallel GPUs	Number of GPUs dedicated during processing	count	1000			Planning assumption; Internal estimate	assumed	human
facility_cost_per_year	Facility per year	Cleanroom, isolation, HVAC, racks	$/year	2000000			Planning assumption; Internal estimate	assumed	human
avg_staff_salary	Average staff salary	Average salary with all overheads	$/year	150000			Planning assumption; Internal estimate	assumed	human
project_mgmt_staff	Project management staff	Staff for project oversight	FTE	10			Planning assumption; Internal estimate	assumed	human
technical_staff	Technical staff	Beyond sample and microscope operations	FTE	15			Planning assumption; Internal estimate	assumed	human
misc_staff	Misc staff	Operations, assistants, PR, etc	FTE	10			Planning assumption; Internal estimate	assumed	human
other_costs_per_connectome	Other costs per connectome	Shipping, permits, biosafety, IP, pubs	$	250000			Miscellaneous project costs; Internal estimate	assumed	human
data_science_cost	Data science development	Pipelines, data mgmt, viewers, model training	$	2000000		tavakoli2024	LICONN: 30d×32 V100s≈$10k; plus semantic classifier 16 V100s×38h; 10x multiplier for multiple models; Internal estimate	estimated	human
capital_base	Capital base	Scopes + facility + core SW + initial training	$	55000000			Calculation: scopes + facility + development; Internal estimate	derived	human
peak_flops_gpu	Peak FLOPs/s GPU	Maximum FP16 FLOP/s for GPU	TFLOPs/s	1979	nvidia_h100_2024		H100 FP16 1,979 TFLOPs; current connectomics uses FP32 but FP16 reasonable at scale	measured	human
gpu_utilization	GPU utilization	Continuous GPU usage across time	fraction	0.8			Typical continuous utilization estimate; Internal estimate	estimated	human
gpu_cost_per_hour	GPU cost per hour	Costs for access to 1h of GPU	$/hour	2			At-scale pricing for cloud GPUs; Internal estimate	estimated	human
cost_drop_compute_per_year	Cost drop compute/year	Cost drop compute per year	fraction	0.1			Based on historical compute cost trends; Internal estimate	estimated	human
cost_drop_storage_per_year	Cost drop storage/year	Cost drop storage per year	fraction	0.05			Based on historical storage cost trends; Internal estimate	estimated	human
active_storage_cost_pb_month	Active storage cost	Storage for working files	$/PB-month	2625	aws_s3_pricing_2025		S3 Frequent Access $0.021/GB; on-prem assumed 8x cheaper at scale	derived	human
archive_storage_cost_pb_month	Archive storage cost	Storage for backup files	$/PB-month	2000	aws_s3_pricing_2025		S3 Archive Instant $0.004/GB; on-prem assumed 2x cheaper	derived	human
bytes_per_voxel	Bytes per voxel	Assuming 8-bits per voxel	bytes	1			Standard 8-bit grayscale; Internal estimate	assumed	human
lossless_compression	Lossless compression	Raw to lossless ratio	×	1.5	wellcome_connectomics_2024		Per Wellcome Trust Report; compression parallel to image acquisition	derived	human
lossy_compression	Lossy compression	Raw to lossy ratio	×	120			120x compression demonstrated for EM data; parallel to image acquisition; Internal estimate	estimated	human
label_overhead	Label overhead	Labels + meshes + skeletons + graphs	fraction	0.05			Estimate for image overlays and annotations; Internal estimate	estimated	human
replicas_active_first	Replicas active (first)	Hot copies lossless online first	count	3			Data redundancy assumption; Internal estimate	assumed	human
replicas_archive_first	Replicas archive (first)	Cold copies retained first	count	2			Data redundancy assumption; Internal estimate	assumed	human
replicas_active_marginal	Replicas active (marginal)	Hot copies lossless online marginal	count	1			Data redundancy assumption; Internal estimate	assumed	human
replicas_archive_marginal	Replicas archive (marginal)	Cold copies retained marginal	count	0			Data redundancy assumption; Internal estimate	assumed	human
active_retention_years	Active retention	How long active copies are kept	years	5			Data lifecycle assumption; Internal estimate	assumed	human
archive_retention_years	Archive retention	How long archive copies are kept	years	10			Data lifecycle assumption; Internal estimate	assumed	human
active_cost_pb_year	Active storage cost/PB-year	Online storage price	$/PB-year	31500	aws_s3_pricing_2025		Calculated: $2625/PB-month × 12	derived	human
archive_cost_pb_year	Archive storage cost/PB-year	Archive storage price	$/PB-year	24000	aws_s3_pricing_2025		Calculated: $2000/PB-month × 12	derived	human
flops_registration_per_tile	FLOPs registration/tile	FP32-equivalent per tile	TFLOP/tile	450	microns_2021		MICrONS: 230h×1200 T4s (6.5 TFLOPS)=6.46B TFLOPs for 14.4M tiles≈450/tile	derived	human
segmentation_flops_per_voxel	Segmentation FLOPs/voxel	FP32-equivalent per voxel	TFLOP/voxel	2.4e-06	januszewski2018	sheridan2022	LSDs: 2M FLOP/voxel (1/100 of FFN's 2.42×10⁸); see Nature Methods supplements	derived	human
registration_rate_pv_per_day	Registration rate	PV processed per day per GPU	PV/day/GPU	10			Processing rate estimate; Internal estimate	estimated	human
segmentation_rate_pv_per_day	Segmentation rate	PV processed per day per GPU	PV/day/GPU	5			Processing rate estimate; Internal estimate	estimated	human
sample_duration	Sample duration	Individual sample duration for recordings	seconds	0.1			Recording protocol assumption; Internal estimate	assumed	human
brain_area_repetitions	Brain area repetitions	How often experiments cover the same brain volume (different states)	count	1			Recording protocol assumption; Internal estimate	assumed	human
connectomics_scan_percentage	Connectomics scan percentage	Percent of recorded volume for aligned structural/functional datasets	fraction	0.1			Protocol assumption; Internal estimate	assumed	human
neurons_at_single_resolution	Neurons at single resolution	Number of individual neurons that can be recorded at single neuron resolution	count	5000			Current technology capability; Internal estimate	estimated	human
experiment_cost	Experiment cost	Total costs per experiment	$	500000			Typical neuroscience experiment budget; Internal estimate	estimated	human
simulation_hours	Simulation hours	Total hours of simulation to run	hours	1000			Simulation run time assumption; Internal estimate	assumed	human
storage_bytes_lower	Storage bytes lower bound	Simulation memory requirement lower bound	bytes	1.08e12			Calculated from model parameters; Internal estimate	derived	human
flops_time_based_lower	FLOPS time-based lower	FLOPS per second of sim lower bound	FLOPS	6.75e15			Calculated from model parameters; Internal estimate	derived	human
gpu_memory_gb	GPU memory	Memory per GPU in gigabytes	GB	80	nvidia_h100_2024		H100 HBM3 memory capacity	measured	human
gpu_tflops	GPU TFLOPs	GPU compute performance in TFLOPS	TFLOPS	310	nvidia_h100_2024		H100 FP32 tensor core performance	measured	human
experiment_length	Experiment length	Total duration of recording across multiple sessions	hours	0.5			Recording protocol assumption; Internal estimate	assumed	human
brain_volume_coverage	Brain volume coverage	Percentage of total brain volume to record	fraction	1.0			Full brain coverage target; Internal estimate	assumed	human
experiment_brain_volume	Experiment brain volume	Brain volume covered by recording	mm³	10			Recording setup assumption; Internal estimate	assumed	human
experiment_data_volume	Experiment data volume	Uncompressed raw data generated by experiment	TB	0.09			Calculated from recording parameters; Internal estimate	derived	human
```

### `costs/proofreading.tsv`

[Download the exact TSV snapshot](data/guesstimator/costs/proofreading.tsv).

```tsv
id	name	definition	unit	source	current	improved_1000x	ref_id	supporting_refs	ref_note	confidence	validated_by
hours_per_neuron	Human proofreading hours per neuron	Human proofreading hours per neuron	hours	FlyWire estimates, assumptions	5.0	0.005				none	none
hourly_rate	Hourly rate of proof-reader	Hourly rate of proofreader	$/hour	FlyWire estimates, assumptions	50.0	50.0				none	none
hours_per_day	Proofreading hours per day	Proofreading hours per day	hours/day	FlyWire estimates, assumptions	6.0	6.0				none	none
num_proofreaders	Number of proofreaders	Number of proofreaders	count	FlyWire estimates, assumptions	25000.0	1000.0				none	none
```

### `compute/hardware-characteristics.tsv`

[Download the exact TSV snapshot](data/guesstimator/compute/hardware-characteristics.tsv).

```tsv
System	Year	FP16_TFLOPs_Dense	Memory_GB	Interconnect_GB/s	Price_USD	cost_per_hour	description	References	Compute-limit (neurons)	Memory-limit (neurons)	Interconnect-limit (neurons)	Max neurons (all limits)	Neurons per $	ref_id	supporting_refs	ref_note	confidence	validated_by
MacBook Pro 2024 M4 Pro	2024	7.4	48.0	270.0	$2,499	0.5	Apple M4 Pro laptop, unified memory	https://www.apple.com/macbook-pro/specs/ https://www.cpu-monkey.com/en/igpu-apple_m4_pro_16_core				none	none	apple_specs_2026	cpu_monkey_igpu_apple_m4_pro_16_core_2026			
Mac Studio M2 Ultra	2023	27.0	190.0	800.0	$3,999	0.8	Apple M2 Ultra workstation	https://www.apple.com/shop/buy-mac/mac-studio/ https://www.cpu-monkey.com/en/igpu-apple_m2_ultra_76_core				none	none	apple_mac_studio_2026	cpu_monkey_igpu_apple_m2_ultra_76_core_2026			
NVIDIA A100 SXM 80GB	2020	310.0	80.0	600.0	$15,000	2	Single GPU, Tensor Core FP16 dense	https://www.nvidia.com/content/dam/en-zz/Solutions/Data-Center/a100/pdf/nvidia-a100-datasheet-nvidia-us-2188504-web.pdf				none	none	nvidia_nvidia_a100_datasheet_nvidia_u_2026				
NVIDIA H100 NVL	2023	840.0	94.0	900.0	$25,000	3	2-GPU pair, NVLink, Tensor Core FP16	https://www.pny.com/file%20library/company/support/product%20brochures/nvidia%20data%20center%20gpus/english/h100-nvl-datasheet.pdf				none	none	pny_h100_nvl_datasheet_pdf_2026				
NVIDIA DGX GH200	2023	250000.0	140000.0	120000.0	$500,000	50	Supercomputer node, 256 Grace Hopper	https://developer.nvidia.com/blog/announcing-nvidia-dgx-gh200-first-100-terabyte-gpu-memory-system/				none	none	developer_announcing_nvidia_dgx_gh200_fi_2026				
NVIDIA HGX B200	2024	18000.0	1400.0	14000.0	$350,000	10	8x Blackwell GPUs, NVLink 5.0	https://lenovopress.lenovo.com/lp2226-thinksystem-nvidia-b200-180gb-1000w-gpu				none	none	lenovopress_lp2226_thinksystem_nvidia_b200_2026				
NVIDIA Tesla C870	2007	0.35	1.5		$1,500	0.1	Historical reference GPU	https://www.techpowerup.com/gpu-specs/tesla-c870.c1542				none	none	techpowerup_tesla_c870_c1542_2026				
```

### `compute/neuron-models.tsv`

[Download the exact TSV snapshot](data/guesstimator/compute/neuron-models.tsv).

```tsv
id	name	short_name	flops_per_sec	flops_per_spike	bytes	description	source	ref_id	supporting_refs	ref_note	confidence	validated_by
lif	Leaky Integrate-and-Fire	LIF	40000	15	4	Simple point neuron with exponential leak	https://doi.org/10.1017/CBO9780511815706	gerstner2002		Chapter 4.1	derived	ai
hh5	5-Compartment Hodgkin-Huxley	5-comp HH	3450000	0	80	Biophysically detailed with soma, dendrites, and axon	https://doi.org/10.1113/jphysiol.1952.sp004764	hodgkin1952		Original model equations	measured	ai
izhikevich	Izhikevich	Izhikevich	130000	25	16	Efficient spiking model capturing many firing patterns	https://doi.org/10.1109/TNN.2003.820440	izhikevich2003		Section II	measured	ai
adex	Adaptive Exponential	AdEx	200000	30	24	Two-variable model with adaptation and exponential spike	https://doi.org/10.1152/jn.00686.2005	brette2005		Model equations	measured	ai
```

### `compute/synapse-models.tsv`

[Download the exact TSV snapshot](data/guesstimator/compute/synapse-models.tsv).

```tsv
id	name	short_name	flops_per_sec	flops_per_event	bytes	description	source	ref_id	supporting_refs	ref_note	confidence	validated_by
alpha	Alpha Synapse	Alpha	50000	20	8	Simple alpha-function conductance	https://doi.org/10.1152/jn.1967.30.5.1138	rall1967		Eq. for alpha function	derived	ai
tsodyks_markram	Tsodyks-Markram	TM	80000	51	16	Short-term plasticity with depression and facilitation	https://doi.org/10.1073/pnas.94.2.719	tsodyks1997		Model equations	measured	ai
exponential	Double Exponential	Exp2Syn	60000	30	12	Rise and decay time constants	https://doi.org/10.1007/BF00961734	destexhe1994		Kinetic synapse models	derived	ai
stdp	STDP Plastic	STDP	120000	80	24	Spike-timing dependent plasticity	https://doi.org/10.1523/JNEUROSCI.18-24-10464.1998	bi1998		STDP learning rule	measured	ai
```

### `parameters/recording-capabilities.tsv`

[Download the exact TSV snapshot](data/guesstimator/parameters/recording-capabilities.tsv).

```tsv
id	name	definition	unit	c_elegans	drosophila	zebrafish_larva	mouse	macaque	human	source	ref_id	supporting_refs	ref_note	confidence	validated_by
experiment_length	Experiment length	Total duration of recording across multiple sessions	hours	0.5	0.5	0.5	0.5	0.5	0.5	Standard protocol				none	none
neurons_at_single_resolution	Neurons at single neuron resolution	Number of individual neurons that can be recorded at single neuron resolution	count	150	2000	10000	5000	2000	1000	Literature estimates				none	none
sampling_rate	Sampling rate	Average frequency at which neurons are sampled	Hz	200	200	200	200	200	200	Typical calcium imaging				none	none
experiment_cost	Experiment cost	Total costs per experiment, including partial hardware, personnel and misc experimental costs; excluding storage costs	$	10000	100000	50000	500000	2000000	5000000	Literature estimates				none	none
experiment_brain_volume	Experiment brain volume	Brain volume covered by recording	mm³	0.002	0.04	0.08	10	100	100	Estimated from field of view				none	none
experiment_data_volume	Experiment data volume	Uncompressed raw data generated by experiment	TB	0.0018	0.036	0.054	0.09	0.09	0.036	Calculated from data rate × duration				none	none
```

### `parameters/recording-parameters.tsv`

[Download the exact TSV snapshot](data/guesstimator/parameters/recording-parameters.tsv).

```tsv
id	name	value	unit	definition	ref_id	supporting_refs	ref_note	confidence	validated_by
experiment_duration_minutes	Experiment Duration	30	minutes	Standard recording session length				none	none
```

### `parameters/organism-defaults.tsv`

[Download the exact TSV snapshot](data/guesstimator/parameters/organism-defaults.tsv).

```tsv
id	name	definition	unit	c_elegans	drosophila	zebrafish_larva	mouse	macaque	human	source	ref_id	supporting_refs	ref_note	confidence	validated_by
recording_samples	Recording samples	Number of recording experiments to run	count	10	20	20	50	100	200	Estimated from literature				none	none
brain_fraction	Brain fraction coverage	Percentage of total brain volume to record	fraction	1.0	1.0	1.0	0.1	0.01	0.001	Practical limits				none	none
microscope_fleet	Microscope fleet size	Number of microscopes in imaging fleet	count	1	2	2	10	50	100	Scaled by brain volume				none	none
gpu_cluster	GPU cluster size	Number of GPUs for processing	count	10	50	100	1000	5000	10000	Scaled by data volume				none	none
proofreading_team	Proofreading team size	Number of proofreaders for connectome reconstruction	FTE	2	10	20	100	500	1000	Scaled by synapse count				none	none
neuron_model	Default neuron model	Neuron simulation model complexity	id	lif	lif	izhikevich	izhikevich	adex	hh5	Model complexity scaling				none	none
synapse_model	Default synapse model	Synapse simulation model complexity	id	alpha	alpha	exponential	tsodyks_markram	tsodyks_markram	stdp	Model complexity scaling				none	none
imaging_modality	Default imaging modality	Imaging technology for connectomics	id	em	em	exm	exm	exm	exm	EM for small, ExM for large				none	none
storage_preset	Default storage preset	Storage configuration preset	id	minimal	standard	standard	standard	high_availability	high_availability	Scaled by data criticality				none	none
```

### `formulas/connectomics.tsv`

[Download the exact TSV snapshot](data/guesstimator/formulas/connectomics.tsv).

```tsv
id	formula	inputs	unit	section	row	description	ref_id	supporting_refs	ref_note	confidence	validated_by
voxels_per_mm3	1e18 / (voxel_x * voxel_y * voxel_z)	voxel_x,voxel_y,voxel_z	voxels/mm³	imaging	100	Number of voxels in one cubic millimeter at acquisition resolution			Standard volumetric calculation; Internal methodology	derived	human
effective_volume	biological_volume * expansion_factor^3 * (1 + reacquisition_rate)	biological_volume,expansion_factor,reacquisition_rate	mm³	imaging	99	Total volume to image after tissue expansion			Volume × expansion³ × (1 + reacq); Internal methodology	derived	human
petavoxels_per_mm3	voxels_per_mm3 / 1e15	voxels_per_mm3	PV/mm³	imaging	101	Petavoxels per cubic millimeter			Unit conversion; Internal methodology	derived	human
petavoxels_total	petavoxels_per_mm3 * effective_volume	petavoxels_per_mm3,effective_volume	PV	imaging	102	Total petavoxels to image			PV/mm³ × volume; Internal methodology	derived	human
net_imaging_rate	sustained_imaging_rate / (total_channels / parallel_channels) * microscope_uptime	sustained_imaging_rate,total_channels,parallel_channels,microscope_uptime	Mvox/s	imaging	72	Effective imaging speed accounting for channel rounds and uptime			Rate / channel rounds × uptime; Internal methodology	derived	human
mm3_per_day_per_scope	(net_imaging_rate * 1e6 * 86400) / voxels_per_mm3	net_imaging_rate,voxels_per_mm3	mm³/day	imaging	73	Volume one microscope can image per day			Voxels/day / voxels/mm³; Internal methodology	derived	human
num_microscopes	floor(microscope_budget / microscope_capital_cost)	microscope_budget,microscope_capital_cost	count	imaging	69	Number of microscopes affordable within budget			Budget / cost per scope; Internal methodology	derived	human
scope_operating_cost_per_year	technician_salary / microscope_technician_ratio + scope_annual_service	technician_salary,microscope_technician_ratio,scope_annual_service	$/year	imaging	70	Annual operating cost per microscope			Labor share + service costs; Internal methodology	derived	human
imaging_days	if(mm3_per_day_per_scope * num_microscopes == 0, 0, effective_volume / (mm3_per_day_per_scope * num_microscopes) + initial_prep_days)	effective_volume,mm3_per_day_per_scope,num_microscopes,initial_prep_days	days	timeline	121	Total days to complete all imaging			Volume / throughput + prep; Internal methodology	derived	human
imaging_years	imaging_days / 365	imaging_days	years	timeline	151	Imaging time in years			Unit conversion; Internal methodology	derived	human
registration_days	biological_volume / (registration_rate_pv_per_day * max_parallel_gpus)	biological_volume,registration_rate_pv_per_day,max_parallel_gpus	days	timeline	122	Days for image registration/alignment			Volume / (rate × GPUs); Internal methodology	derived	human
segmentation_days	biological_volume / (segmentation_rate_pv_per_day * max_parallel_gpus)	biological_volume,segmentation_rate_pv_per_day,max_parallel_gpus	days	timeline	123	Days for neural segmentation			Volume / (rate × GPUs); Internal methodology	derived	human
processing_days	registration_days + segmentation_days	registration_days,segmentation_days	days	timeline	124	Total GPU processing time			Sum of processing stages; Internal methodology	derived	human
processing_years	processing_days / 365	processing_days	years	timeline	152	Processing time in years			Unit conversion; Internal methodology	derived	human
proofreading_days	neuron_count * hours_per_neuron / (num_proofreaders * hours_per_day)	neuron_count,hours_per_neuron,num_proofreaders,hours_per_day	days	timeline	125	Total human proofreading time			Total hours / daily capacity; Internal methodology	derived	human
proofreading_years	proofreading_days / 365	proofreading_days	years	timeline	153	Proofreading time in years			Unit conversion; Internal methodology	derived	human
buffer_years	(imaging_years + processing_years + proofreading_years) * risk_buffer_first	imaging_years,processing_years,proofreading_years,risk_buffer_first	years	timeline	154	Risk buffer time for first connectome			Timeline × buffer fraction; Internal methodology	derived	human
time_to_first_years	imaging_years + processing_years + proofreading_years + buffer_years	imaging_years,processing_years,proofreading_years,buffer_years	years	timeline	155	Total years until first connectome complete			Sum of all phases; Internal methodology	derived	human
time_to_marginal_years	max(imaging_years, processing_years, proofreading_years)	imaging_years,processing_years,proofreading_years	years	timeline	156	Years between subsequent connectomes (bottleneck)			Bottleneck determines pace; Internal methodology	derived	human
total_connectomes	round(project_duration / max(time_to_first_years, time_to_marginal_years))	project_duration,time_to_first_years,time_to_marginal_years	count	summary	148	Number of connectomes achievable in project duration			Duration / pace; Internal methodology	derived	human
```

### `formulas/costs.tsv`

[Download the exact TSV snapshot](data/guesstimator/formulas/costs.tsv).

```tsv
id	formula	inputs	unit	section	row	description	ref_id	supporting_refs	ref_note	confidence	validated_by
consumables_cost	biological_volume * (consumables_per_mm3 + labor_cost_per_mm3 + antibody_cost_per_mm3 * (total_channels - 1))	biological_volume,consumables_per_mm3,labor_cost_per_mm3,antibody_cost_per_mm3,total_channels	$	costs	129	Sample preparation and consumables cost			Volume × per-mm³ costs; Internal methodology	derived	human
scanning_cost	scope_operating_cost_per_year * num_microscopes * imaging_years	scope_operating_cost_per_year,num_microscopes,imaging_years	$	costs	130	Microscope operating costs during imaging			Operating cost × scopes × time; Internal methodology	derived	human
imaging_cost_total	consumables_cost + scanning_cost	consumables_cost,scanning_cost	$	costs	131	Total imaging costs			Sum of sample prep and scanning; Internal methodology	derived	human
processing_cost_registration	max_parallel_gpus * registration_days * 24 * gpu_cost_per_hour / biological_volume	max_parallel_gpus,registration_days,gpu_cost_per_hour,biological_volume	$/PV	costs	117	Registration compute cost per petavoxel			GPU-hours × rate / volume; Internal methodology	derived	human
processing_cost_segmentation	max_parallel_gpus * segmentation_days * gpu_cost_per_hour * 24 / petavoxels_total	max_parallel_gpus,segmentation_days,gpu_cost_per_hour,petavoxels_total	$/PV	costs	118	Segmentation compute cost per petavoxel			GPU-hours × rate / volume; Internal methodology	derived	human
processing_cost_total	petavoxels_total * (processing_cost_registration + processing_cost_segmentation)	petavoxels_total,processing_cost_registration,processing_cost_segmentation	$	costs	140	Total processing compute cost			Volume × per-PV cost; Internal methodology	derived	human
proofreading_cost	neuron_count * hours_per_neuron * hourly_rate	neuron_count,hours_per_neuron,hourly_rate	$	costs	141	Total proofreading labor cost			Neurons × hours × rate; Internal methodology	derived	human
personnel_cost	(project_mgmt_staff + technical_staff + misc_staff) * avg_staff_salary * project_duration / total_connectomes	project_mgmt_staff,technical_staff,misc_staff,avg_staff_salary,project_duration,total_connectomes	$	costs	142	Personnel costs per connectome			FTE × salary × years / connectomes; Internal methodology	derived	human
other_costs	other_costs_per_connectome	other_costs_per_connectome	$	costs	143	Miscellaneous costs (shipping, permits, etc.)			Fixed per-connectome overhead; Internal methodology	derived	human
first_subtotal	imaging_cost_total + total_storage_cost_first + processing_cost_total + proofreading_cost + personnel_cost + other_costs + data_science_cost + capital_base	imaging_cost_total,total_storage_cost_first,processing_cost_total,proofreading_cost,personnel_cost,other_costs,data_science_cost,capital_base	$	costs	167-171	First connectome costs before buffer			Sum of all cost components; Internal methodology	derived	human
first_buffer	first_subtotal * risk_buffer_first	first_subtotal,risk_buffer_first	$	costs	172	Risk buffer for first connectome			Contingency as fraction of subtotal; Internal methodology	derived	human
first_total	first_subtotal + first_buffer	first_subtotal,first_buffer	$	costs	173	Total cost for first connectome			Subtotal + buffer; Internal methodology	derived	human
first_cost_per_neuron	first_total / neuron_count	first_total,neuron_count	$/neuron	costs	174	First connectome cost per neuron			Total cost / neuron count; Internal methodology	derived	human
marginal_subtotal	imaging_cost_total + total_storage_cost_marginal + processing_cost_total + proofreading_cost + personnel_cost + other_costs	imaging_cost_total,total_storage_cost_marginal,processing_cost_total,proofreading_cost,personnel_cost,other_costs	$	costs	176-180	Marginal connectome costs before buffer			Sum without capital base; Internal methodology	derived	human
marginal_buffer	marginal_subtotal * risk_buffer_marginal	marginal_subtotal,risk_buffer_marginal	$	costs	181	Risk buffer for marginal connectomes			Contingency as fraction of subtotal; Internal methodology	derived	human
marginal_total	marginal_subtotal + marginal_buffer	marginal_subtotal,marginal_buffer	$	costs	182	Total cost for marginal connectome			Subtotal + buffer; Internal methodology	derived	human
marginal_cost_per_neuron	marginal_total / neuron_count	marginal_total,neuron_count	$/neuron	costs	183	Marginal connectome cost per neuron			Total cost / neuron count; Internal methodology	derived	human
avg_total	if(total_connectomes > 1, (first_total + marginal_total * (total_connectomes - 1)) / total_connectomes, first_total)	total_connectomes,first_total,marginal_total	$	costs	164	Average cost per connectome			Weighted average; Internal methodology	derived	human
avg_cost_per_neuron	if(total_connectomes > 1, (first_cost_per_neuron + marginal_cost_per_neuron * (total_connectomes - 1)) / total_connectomes, first_cost_per_neuron)	total_connectomes,first_cost_per_neuron,marginal_cost_per_neuron	$/neuron	costs	165	Average cost per neuron across all connectomes			Weighted average; Internal methodology	derived	human
```

### `formulas/storage.tsv`

[Download the exact TSV snapshot](data/guesstimator/formulas/storage.tsv).

```tsv
id	formula	inputs	unit	section	row	description	ref_id	supporting_refs	ref_note	confidence	validated_by
raw_bytes_per_mm3	voxels_per_mm3 * bytes_per_voxel	voxels_per_mm3,bytes_per_voxel	bytes/mm³	storage	109	Uncompressed bytes per cubic millimeter			Standard volumetric calculation; Internal methodology	derived	human
raw_pb_total	raw_bytes_per_mm3 * effective_volume / 1e15	raw_bytes_per_mm3,effective_volume	PB	storage	111	Total raw uncompressed data size			Unit conversion to petabytes; Internal methodology	derived	human
active_pb	if(lossy_compression == 0, 0, (raw_pb_total / lossy_compression) + (raw_pb_total * label_overhead))	raw_pb_total,lossy_compression,label_overhead	PB	storage	112	Active storage size (lossy compressed + labels)			Compression with label overhead; Internal methodology	derived	human
archive_pb	if(lossless_compression == 0, 0, (raw_pb_total / lossless_compression) + (raw_pb_total * label_overhead))	raw_pb_total,lossless_compression,label_overhead	PB	storage	113	Archive storage size (lossless compressed + labels)			Compression with label overhead; Internal methodology	derived	human
active_storage_cost_first	active_pb * replicas_active_first * active_retention_years * active_cost_pb_year	active_pb,replicas_active_first,active_retention_years,active_cost_pb_year	$	storage	132	Active storage cost for first connectome			Storage cost = size × replicas × time × rate; Internal methodology	derived	human
archive_storage_cost_first	archive_pb * replicas_archive_first * archive_retention_years * archive_cost_pb_year	archive_pb,replicas_archive_first,archive_retention_years,archive_cost_pb_year	$	storage	133	Archive storage cost for first connectome			Storage cost = size × replicas × time × rate; Internal methodology	derived	human
total_storage_cost_first	active_storage_cost_first + archive_storage_cost_first	active_storage_cost_first,archive_storage_cost_first	$	storage	134	Total storage cost for first connectome			Sum of active and archive costs; Internal methodology	derived	human
active_storage_cost_marginal	active_pb * replicas_active_marginal * active_retention_years * active_cost_pb_year	active_pb,replicas_active_marginal,active_retention_years,active_cost_pb_year	$	storage	135	Active storage cost for marginal connectomes			Storage cost = size × replicas × time × rate; Internal methodology	derived	human
archive_storage_cost_marginal	archive_pb * replicas_archive_marginal * archive_retention_years * archive_cost_pb_year	archive_pb,replicas_archive_marginal,archive_retention_years,archive_cost_pb_year	$	storage	136	Archive storage cost for marginal connectomes			Storage cost = size × replicas × time × rate; Internal methodology	derived	human
total_storage_cost_marginal	active_storage_cost_marginal + archive_storage_cost_marginal	active_storage_cost_marginal,archive_storage_cost_marginal	$	storage	137	Total storage cost for marginal connectomes			Sum of active and archive costs; Internal methodology	derived	human
```

### `imaging/imaging-modalities.tsv`

[Download the exact TSV snapshot](data/guesstimator/imaging/imaging-modalities.tsv).

```tsv
id	name	definition	unit	em	exm	exm_molecular	wellcome	ref_id	supporting_refs	ref_note	confidence	validated_by
microscope_capital_cost	Microscope capital cost	Acquisition price per scope	$/scope	500000	500000	500000	5000000				none	none
microscope_depreciation_years	Depreciation horizon	Straight-line depreciation years	years	10	5	5	10				none	none
sustained_imaging_rate	Sustained imaging rate	Imaging rate at given resolution per microscope	Mvox/s	225	1100	1100	250				none	none
parallel_channels	Parallel channels	Simultaneous channel readouts	count	1	3	8	1				none	none
total_channels	Total channels	Imaging channels per voxel	count	1	1	800	1				none	none
scope_annual_service	Annual service	Electricity, licenses, maintenance	$/scope/year	50000	15000	15000	250000				none	none
technician_salary	Technician salary	Total salary incl benefits for microscopist	$/year	120000	120000	120000	120000				none	none
microscope_technician_ratio	Technician ratio	Microscopes per technician	count	2	5	5	0.5				none	none
microscope_uptime	Microscope uptime	Fraction of calendar time producing good data	fraction	1.0	1.0	1.0	1.0				none	none
reacquisition_rate	Reacquisition rate	Expected fraction of volume to re-image	fraction	0	0	0	0				none	none
sample_yield	Sample yield	Fraction of samples that pass QC	fraction	1.0	1.0	1.0	1.0				none	none
expansion_factor	Expansion factor	Linear expansion factor E; volume scales as E³	×	1	16	16	1				none	none
consumables_per_mm3	Consumables per mm³	Sample prep, expanding, staining per tissue volume	$/mm³	100000	2	2	200000				none	none
antibody_cost_per_mm3	Antibody cost per mm³	Antibody costs per original tissue	$/mm³	2	2	2	2				none	none
labor_cost_per_mm3	Labor cost per mm³	Human labor costs per original mm³	$/mm³	2850	2850	2850	2850				none	none
initial_prep_days	Initial preparation days	From tissue to ready-to-image	days	15	15	15	15				none	none
voxel_x	Voxel size X	Acquisition resolution X	nm	15	250	250	10				none	none
voxel_y	Voxel size Y	Acquisition resolution Y	nm	15	250	250	10				none	none
voxel_z	Voxel size Z	Acquisition resolution Z	nm	15	400	400	10				none	none
sample_depth	Sample depth	Layers of Z in one sample	count	1	10000	10000	1				none	none
tile_x	Tile width	Tile width in pixels	pixels	6000	2048	5000	6000				none	none
tile_y	Tile height	Tile height in pixels	pixels	6000	2048	5000	6000				none	none
tile_overlap	Tile overlap	Lateral overlap for stitching	fraction	0.1	0.1	0.1	0.1				none	none
```

### `compute/computational-demands-organisms.tsv`

[Download the exact TSV snapshot](data/guesstimator/compute/computational-demands-organisms.tsv).

```tsv
organisms	C. elegans (body)	fly (brain)	mouse (cortex)	mouse (brain)	human (cortex)	human (brain)	Unnamed: 7	Unnamed: 8	neuron models	LIF	5-comp HH	Unnamed: 12	synapse models	alpha synapse	tsodyks-markram	ref_id	supporting_refs	ref_note	confidence	validated_by
neurons	3.02E+02	1.40E+05	1.37E+07	7.00E+07	2.00E+10	8.60E+10			FLOPS per sec of sim	40000.0	3.45E+06		FLOPS per sec of sim	50000.0	80000.0				none	none
synapses	2.06E+04	5.40E+07	1.20E+11	1.35E+11	1.50E+14	1.70E+14			FLOPS per spike	15.0	-		FLOPS per event	20.0	51.0				none	none
firing (Hz)	10	10	10	10	10	10			bytes	4.0	8.00E+01		bytes	8.0	16.0				none	none
spikes/s	3.02E+03	1.40E+06	1.37E+08	7.00E+08	2.00E+11	8.60E+11				none	none									
fan-in	6.82E+01	3.86E+02	8.76E+03	1.93E+03	7.50E+03	1.98E+03				none	none									
events/s	2.06E+05	5.40E+08	1.20E+12	1.35E+12	1.50E+15	1.70E+15				none	none									
timesteps/s	1.00E+04	1.00E+04	1.00E+04	1.00E+04	1.00E+04	1.00E+04				none	none									
time-based simulation cost (per sec)	C. elegans (body)	fly (brain)	mouse (cortex)	mouse (brain)	human (cortex)	human (brain)				none	none									
FLOPS per sec of sim (lower bound)	1.04E+09	2.71E+12	6.00E+15	6.75E+15	7.50E+18	8.50E+18				none	none									
FLOPS per sec of sim (upper bound)	2.69E+09	4.80E+12	9.65E+15	1.10E+16	1.21E+19	1.39E+19				none	none									
event-driven simulation cost (per sec)	C. elegans (body)	fly (brain)	mouse (cortex)	mouse (brain)	human (cortex)	human (brain)				none	none									
FLOPS per sec of sim (lower bound)	4.16E+06	1.08E+10	2.40E+13	2.70E+13	3.00E+16	3.40E+16				none	none									
FLOPS per sec of sim (upper bound)	1.05E+09	5.11E+11	1.08E+14	3.10E+14	1.46E+17	8.67E+16				none	none									
simulation storage requirements	C. elegans (body)	fly (brain)	mouse (cortex)	mouse (brain)	human (cortex)	human (brain)				none	none									
bytes (lower bound)	1.66E+05	4.33E+08	9.60E+11	1.08E+12	1.20E+15	1.36E+15				none	none									
bytes (upper bound)	3.54E+05	8.75E+08	1.92E+12	2.17E+12	2.40E+15	2.73E+15				none	none									
```

## Interpretation checklist

- Name the organism and every non-default setting used.
- Report first-project and marginal-project results separately.
- Identify whether a value came from a TSV input, an app-local constant, or a user choice.
- Call estimates scenario outputs, not forecasts or ground truth.
- Preserve units and distinguish decimal GB/TB/PB conversions from binary units.
- Link to the interactive scenario when a share URL is available.
- Use the published report PDF for quotations or claims attributed to the report.