NAIRR Pilot: Access, Allocation & Research Guide

The National Artificial Intelligence Research Resource (NAIRR) Pilot is a shared U.S. federal research infrastructure initiative launched in January 2024 by the National Science Foundation (NSF) in partnership with 12 federal agencies and 25 private-sector and non-profit organizations. It provides U.S.-based academic researchers, educators, and students with no-cost, in-kind computational allocations—including high-performance computing clusters, cloud AI credits, pre-trained foundation models, curated scientific datasets, and specialized hardware accelerators—to lower technical and financial barriers in artificial intelligence discovery and education.

What it is used for in research

The NAIRR Pilot was created to address a widening resource divide in computational science. Over the past decade, the rapid escalation of parameter counts in deep neural networks and frontier foundation models created an unprecedented resource bottleneck. Cutting-edge artificial intelligence research increasingly required massive high-performance computing (HPC) clusters equipped with thousands of interconnected tensor-core GPUs. While well-capitalized commercial technology firms and a small group of elite private universities could secure dedicated compute clusters, the broader academic research community—particularly researchers at non-R1 institutions, historically Black colleges and universities (HBCUs), minority-serving institutions (MSIs), and emerging state universities—found themselves priced out of foundational model training and large-scale empirical AI evaluation.

To establish a sustainable national infrastructure, the U.S. Congress authorized the initiative under the National AI Initiative Act of 2020 (Public Law 116-283). The blueprint was operationalized through the NAIRR Task Force Final Report in January 2023 and accelerated under Executive Order 14110 on Safe, Secure, and Trustworthy Artificial Intelligence. Rather than functioning as a direct funding mechanism that disburses grant cash to institutional bank accounts, the pilot operates entirely on an in-kind resource allocation model. Approved research teams are awarded compute hours on participating national supercomputers, commercial cloud credits, and direct API tokens for specialized model endpoints. For a formal conceptual definition of the overarching initiative, consult the National AI Research Resource (NAIRR) definition in the CASRAI research terminology dictionary.

Across university departments and national laboratories, researchers utilize NAIRR Pilot allocations to drive four distinct scientific thrusts:

• Foundational AI and Model Safety: Investigating mechanistic interpretability, red-teaming safety boundaries, empirical alignment auditing, adversarial robustness, and algorithmic bias mitigation across open-weight foundation models.
• AI for Scientific Discovery: Applying scientific machine learning workflows to data-intensive disciplines, including structural biomolecular folding, climate and meteorological system emulation, quantum chemistry, fusion energy plasma containment, and astronomical image synthesis.
• Privacy-Preserving Biomedical Research: Conducting rigorous health data modeling within the specialized NAIRR Secure partition, co-administered by the National Institutes of Health (NIH) and Department of Energy (DOE). Researchers access clinical imaging archives from the Medical Imaging and Data Resource Center (MIDRC) to train diagnostic classifiers without violating patient data confidentiality controls or HIPAA requirements.
• Classroom Instruction and AI Workforce Training: Enabling university instructors to provision multi-tenant GPU environments and interactive Jupyter workspaces for undergraduate and graduate computer science, statistics, and data science courses.

All activities conducted under NAIRR allocations must comply with federal standards for responsible science, including the NSF AI research policy guidelines governing scientific reproducibility, transparent methodological disclosure, and responsible data provenance.

Install or access (official source only)

Unlike commercial desktop applications or packaged command-line utilities, you do not install the NAIRR Pilot as a local executable on your workstation. Instead, access is granted via federated identity authentication and formal competitive resource allocation requests coordinated through the official portal at nairrpilot.org and the NSF Advanced Cyberinfrastructure Coordination Ecosystem: Services and Support (ACCESS) cyberinfrastructure at access-ci.org.

To establish access, research teams must satisfy strict federal eligibility criteria and register through sanctioned identity providers. Principal Investigators (PIs) must hold a recognized faculty, scientific, or research appointment at a U.S.-based academic institution, non-profit research institute, or federally funded small business. Postdoctoral scholars and graduate students cannot serve as primary PIs on standard allocation requests, but they can be added as Co-PIs or allocation users once a faculty sponsor establishes the primary project account.

The NAIRR Pilot allocation portfolio comprises four distinct operational resource tracks:

• NAIRR Research Track: Primary allocation pathway for empirical AI and scientific projects. Research proposals are evaluated on rolling monthly cycles, with application cut-offs occurring on the 15th of each calendar month. Awards grant resource access for a standard duration of 12 months.
• NAIRR Classroom (Educator Track): Streamlined track for educators delivering accredited courses. Instructors request bundled student GPU accounts and pre-configured virtual environments for a single academic semester (3 to 6 months).
• NAIRR Secure Track: Tailored computing environments designed for privacy-preserving computation and regulated data assets. Administered in partnership with the NIH and DOE, this track enforces multi-factor identity gating, air-gapped data staging, and specialized zero-trust container sandboxes.
• NAIRR Exploration and Demonstration: Rapid-turnaround opportunities for preliminary feasibility testing, model prototyping, and pilot demonstrations prior to submitting full 12-month requests.

Once an allocation is awarded, researchers access the underlying infrastructure through one of three official channels depending on the awarded facility: Secure Shell (SSH) command-line connections to supercomputing login nodes, web-based Open OnDemand browser portals providing interactive JupyterLab sessions, or federated API keys and cloud console IAM roles for commercial provider platforms including Microsoft Azure AI, Amazon Web Services, Google Cloud Platform, and Hugging Face Enterprise.

Step-by-step task (numbered, with menu names or commands exactly as in the current docs)

The following step-by-step procedure guides a Principal Investigator through the complete workflow of establishing credentials, preparing proposal materials, submitting an application through the official portal, and executing an initial distributed deep learning job on an allocated supercomputer.

1. Create and Authenticate Your ACCESS Identity:

   Navigate in your web browser to the official ACCESS Identity Portal at identity.access-ci.org. Select Register / Sign In and choose CILogon as your authentication identity provider. Search for your home academic institution in the federated identity dropdown menu and log in using your university institutional credentials and institutional multi-factor authentication. You must register with an institutional email address (such as .edu, .org, or .gov); registrations originating from commercial or personal email domains are automatically rejected.

2. Assemble the Required Proposal Documentation:

   Before launching the submission form, prepare a single PDF document (strictly adhering to the 3-page narrative limit) containing the following required sections:

   • Project Summary and Intellectual Merit: Articulate the fundamental research questions, empirical hypotheses, and expected scientific contributions of the AI workload.
   • Technical Feasibility and Methodology: Detail the neural network architectures, software frameworks (such as PyTorch, JAX, and DeepSpeed), and distributed parallelism paradigms (such as Fully Sharded Data Parallel or Tensor Parallelism) to be deployed.
   • Quantitative Resource Justification: Show the exact arithmetic backing your allocation request. State the target GPU architecture (such as NVIDIA H100 or A100), the number of parameters in the model, estimated floating-point operations (FLOPs) per training step, batch size, target training tokens, and the total required GPU node-hours, including a 20% margin for checkpointing, validation, and hyperparameter tuning.
   • Data Management and Provenance Plan: Confirm that all training and evaluation data comply with federal licensing, ethical curation standards, and intellectual property requirements.
3. Submit the Project Request via XRAS:

   Visit the official NAIRR Pilot portal at nairrpilot.org, navigate to the Opportunities menu, and click Submit Allocation Request. You will be redirected to the eXtensible Resource Allocation System (XRAS). Log in with your authenticated ACCESS ID. In the XRAS application dashboard:

   • Select the appropriate allocation opportunity (e.g., NAIRR Pilot – Research Track).
   • Enter your Project Title and paste the plain-text Abstract (under 250 words).
   • Select your target resource providers from the catalog (such as NCSA Delta GPU, PSC Bridges-2, or ALCF Polaris).
   • Upload your 3-page Project Narrative PDF and your NSF-style biographical sketch.
   • Click Review Submission, verify all attached files, and click Submit Proposal.
4. Configure Your Cluster Environment and SSH Keys:

   Upon receiving formal notification of an awarded allocation from the NAIRR review committee (typically delivered within 3 to 4 weeks of submission cut-off), log into the ACCESS User Portal. Under Allocations → Manage Projects, locate your active project code (such as cis240012). Navigate to Security → Public Keys, and paste your public SSH key (generated locally on your workstation using ssh-keygen -t ed25519 -C "[email protected]"). Allow up to 60 minutes for the public key to propagate across the cluster user directories.

5. Connect to the Allocated HPC Facility via SSH:

   Open a terminal on your local workstation and establish a secure connection to the login node of your assigned cluster. For example, to connect to the NCSA Delta system:

   ssh -i ~/.ssh/id_ed25519 [email protected]

   Once authenticated, check your home directory disk quota and verify your allocation accounting string by running the project query command:

   accounts

6. Build a Slurm Batch Script and Submit Your Training Job:

   Compute nodes on NAIRR supercomputers are managed through the Slurm workload manager. Never run intensive computational workloads or model training loops directly on the shared login nodes. Create a batch job script named submit_nairr_job.sh using a text editor:

   #!/bin/bash
   #SBATCH --job-name=nairr-train
   #SBATCH --account=cis240012-gpu
   #SBATCH --partition=gpuA100x4
   #SBATCH --nodes=1
   #SBATCH --ntasks-per-node=4
   #SBATCH --cpus-per-task=16
   #SBATCH --gpus-per-node=4
   #SBATCH --time=12:00:00
   #SBATCH --output=logs/nairr_%j.out
   #SBATCH --error=logs/nairr_%j.err
   
   # Load cluster environment modules
   module purge
   module load cuda/12.2
   module load python/3.11
   
   # Activate Python virtual environment or Apptainer container
   source $WORK/venvs/ai-research/bin/activate
   
   # Execute distributed training using torchrun across 4 GPUs
   srun torchrun 
       --standalone 
       --nproc_per_node=4 
       train_model.py 
       --dataset_path $SCRATCH/datasets/open_science_corpus 
       --output_dir $SCRATCH/checkpoints/run_01 
       --batch_size 32 
       --precision bf16

   Submit the batch job script to the Slurm scheduler from the command line:

   sbatch submit_nairr_job.sh

   Monitor your active jobs in the queue with:

   squeue -u $USER

Output and how to read it

Once your Slurm batch job is submitted to the scheduler, it progresses through queue states from PENDING (awaiting resource availability or node allocation) to RUNNING. Understanding the generated logs, resource consumption accounting, and runtime telemetry is essential for productive research operations and future allocation renewals.

The standard output and standard error streams are redirected to the files specified in your #SBATCH directives (for example, logs/nairr_1289451.out and logs/nairr_1289451.err). A healthy training output log should report environment initialization, GPU device enumeration, NCCL distributed communication rendezvous, and epoch-level loss progression:

[INFO] Initialized distributed process group: rank 0/4, device cuda:0 (NVIDIA A100-SXM4-40GB)
[INFO] Initialized distributed process group: rank 1/4, device cuda:1 (NVIDIA A100-SXM4-40GB)
[INFO] Initialized distributed process group: rank 2/4, device cuda:2 (NVIDIA A100-SXM4-40GB)
[INFO] Initialized distributed process group: rank 3/4, device cuda:3 (NVIDIA A100-SXM4-40GB)
[INFO] Total model parameters: 345,128,448 | Precision: bfloat16
[INFO] Step 500/10000 | Loss: 2.1452 | Grad Norm: 0.84 | Throughput: 14,280 tokens/sec
[INFO] Step 1000/10000 | Loss: 1.8920 | Grad Norm: 0.76 | Throughput: 14,310 tokens/sec
[INFO] Checkpoint saved successfully: /scratch/checkpoints/run_01/step_1000.pt

Upon job completion or termination, inspect execution efficiency using the Slurm efficiency utility:

seff 1289451

The seff report reveals critical operational metrics:

• CPU Utilized and Efficiency: Indicates whether data loading workers (via PyTorch DataLoader) kept the GPUs continuously supplied with tensors. CPU efficiency under 50% often indicates I/O bottlenecks where GPUs idle waiting for data.
• Memory Utilized and Efficiency: Reflects maximum host RAM consumption. If host memory usage approaches 100%, future jobs risk Out-Of-Memory termination by the Linux kernel OOM killer.
• State: Reports COMPLETED, FAILED, TIMEOUT, or OUT_OF_MEMORY.

To audit remaining allocation balances, use the facility-specific accounting tool. On NCSA Delta, execute sbalance; on PSC Bridges-2, execute projects. These commands output your initial awarded Service Units (SUs) or GPU-hours, cumulative units charged against your account, and the remaining balance. Maintain close accounting of your consumption: once your allocation balance reaches zero, the scheduler rejects new job submissions until a renewal or supplemental request is reviewed and approved by the NAIRR Pilot allocation panel.

Troubleshooting

High-performance computing and federated cyberinfrastructure present distinct operational challenges. The following remediation instructions resolve the five most frequent technical issues encountered by NAIRR Pilot researchers.

• Error: sbatch: error: Batch job submission failed: Invalid account or account/partition combination

  Cause: The account string passed to #SBATCH --account= does not match the active project code associated with your ACCESS identity on that specific machine, or the requested partition (such as gpuA100x4) is not authorized for that project.

  Fix: Run sacctmgr show associations user=$USER to view your valid cluster accounts, partitions, and Quality of Service (QOS) parameters. Update your job script with the exact account string returned by the cluster manager.

• Error: torch.cuda.OutOfMemoryError: CUDA out of memory

  Cause: The tensor memory required for model weights, gradients, optimizer states (such as Adam momentum and variance buffers), and intermediate activation maps exceeds the physical VRAM of the GPU (e.g., 40 GB or 80 GB per card).

  Fix: Reduce per-device batch size and compensate using gradient accumulation steps (for example, set gradient_accumulation_steps=4). Enable native PyTorch automatic mixed precision using torch.cuda.amp.autocast(dtype=torch.bfloat16) to halve tensor memory footprint. For models exceeding 7 billion parameters, configure activation checkpointing or wrap the model in DeepSpeed ZeRO-Stage 2 or ZeRO-Stage 3.

• Error: CILogon Federated Single Sign-On Handshake Failure

  Cause: The identity federation system cannot validate institutional credentials due to expired campus security certificates, two-factor authentication desynchronization, or institutional role changes.

  Fix: Clear your browser cache and cookies, or open a fresh private browsing session. Navigate directly to identity.access-ci.org. If your home university identity provider fails to release your institutional affiliation attributes, submit an ACCESS support ticket at support.access-ci.org referencing your CILogon ePPN.

• Error: slurmstepd: error: *** JOB CANCELLED DUE TO TIME LIMIT ***

  Cause: The job exceeded the maximum walltime duration specified in #SBATCH --time= before finishing its execution loop or saving its final checkpoint.

  Fix: Increase the requested wallclock time up to the partition maximum. Implement automated periodic checkpointing in your training script so that progress is saved every 500 to 1,000 steps. In addition, register a POSIX signal handler in your Slurm script using #SBATCH --signal=B:USR1@180 to catch impending walltime termination signals and write a clean checkpoint before process termination.

• Error: Hugging Face Model Gated Repository 401/403 HTTP Access Denied

  Cause: The training script attempts to download a gated foundation model (such as Meta-Llama-3 or Mistral) from the Hugging Face Hub without an authorized user access token.

  Fix: Log into your Hugging Face account and agree to the license terms on the model repository card. Generate a User Access Token with read permissions under Settings → Access Tokens. On the cluster login node, set your token as an environment variable (export HF_TOKEN="hf_...") or run huggingface-cli login before launching your batch job.

Free alternatives

While the NAIRR Pilot provides premier supercomputing allocations, researchers exploring preliminary prototypes or educators seeking immediate student access should consider alternative zero-cost computing platforms. The table below compares the NAIRR Pilot against established free and subsidized academic resources across key operational dimensions.

Platform / Service	Primary User Group	Available Hardware Tier	Maximum Session Runtime	Storage and Data Limits	Application and Review Overhead
NAIRR Pilot	U.S. academic researchers, educators, graduate students	Multi-node NVIDIA H100 / A100 SXM, AMD MI250X, Cloud TPUs, Cerebras CS-2/CS-3	Up to 24–48 hours per batch job via Slurm; 12-month project tenure	Terabytes to petabytes on parallel Lustre/GPFS scratch filesystems	Formal 3-page proposal with monthly peer-review cycle
NSF ACCESS (Explore Track)	U.S. researchers and students needing preliminary HPC time	NVIDIA A100 / V100 GPU nodes across university supercomputers	Standard cluster walltime (typically 24 hours per job)	Standard cluster scratch (typically 1–10 TB per user)	Lightweight proposal (1 page); rapid administrative review (1–3 business days)
Google Colab (Free Tier)	Individual learners, students, rapid Python prototyping	Single shared NVIDIA T4 GPU (subject to dynamic preemption)	Up to 12 hours (frequently preempted after 1–4 hours of idle time)	Temporary container storage (approx. 70 GB); Google Drive integration	Zero overhead; immediate browser login with standard Google account
Kaggle Notebooks	Data science competitors, students, open-source experimenters	Single NVIDIA P100 or 2x NVIDIA T4 GPUs	30 GPU hours per week quota; maximum 12 hours continuous execution	20 GB temporary disk; persistent dataset mounts up to 100 GB	Zero overhead; phone number SMS verification required
Hugging Face Spaces (Community)	AI model demonstration, student demos, web app deployment	Basic 2-core vCPU with 16 GB RAM (community tier; GPUs require paid upgrade)	Persistent web service (sleeps after 48 hours of inactivity)	50 GB container disk per Space	Zero overhead; immediate deployment via Git repository push
Campus Institutional HPC	University-affiliated faculty, lab postdocs, and graduate students	Institutional GPU clusters (variable by campus endowment; e.g., A100, L40S, V100)	Governed by campus condo/slurm policies (typically 12–72 hours)	Local NFS/Lustre storage (typically 500 GB–5 TB per lab)	Campus department request form; approved by departmental cluster administrator

For researchers conducting exploratory prototyping or hyperparameter sanity checks, free browser-based platforms like Google Colab and Kaggle Notebooks provide zero-friction environments. However, once training datasets exceed 50 gigabytes or models require distributed multi-GPU data parallelism, migrating to NAIRR Pilot or NSF ACCESS infrastructure is essential to avoid preemption and memory exhaustion.

The interactive dataset compiled below details technical hardware specifications across the supercomputers, leadership facilities, and accelerator platforms available through the NAIRR Pilot allocation portfolio.

Frequently asked questions

Who is eligible to apply for resources through the NAIRR Pilot?

Principal Investigators (PIs) must hold a recognized faculty, scientific, or research position at an accredited U.S. academic institution, non-profit research organization, or federally funded small business. Postdoctoral scholars and graduate students are eligible to utilize awarded resources and participate as project personnel, but their proposal must be submitted under the formal sponsorship of a qualified faculty Principal Investigator.

Does the NAIRR Pilot award direct cash grants to researchers?

No. The NAIRR Pilot does not disburse monetary grant funding, equipment subsidies, or institutional overhead cash. Instead, it awards strictly in-kind computational allocations, providing researchers with subsidized compute time (measured in Service Units or GPU node-hours) on national supercomputers, commercial cloud credits, API model query tokens, and curated dataset access.

How long do awarded NAIRR Pilot allocations remain active?

Standard allocations granted under the NAIRR Research Track are active for an award duration of 12 consecutive months from the date of provisioning. Educational allocations awarded under the NAIRR Classroom Track are tailored for academic instruction and typically span a single academic term of 3 to 6 months. Unused resource units do not automatically roll over into subsequent academic years.

Can researchers from international institutions access the NAIRR Pilot?

Primary PIs must be affiliated with a U.S.-based institution. International co-investigators and overseas collaborators may participate on an awarded project only if the primary lead PI is based at an eligible U.S. institution and the cross-border collaboration conforms to U.S. federal export control regulations and university data governance policies.

How is the NAIRR Pilot related to the NSF ACCESS supercomputing program?

The NAIRR Pilot collaborates closely with the NSF ACCESS program, leveraging ACCESS cyberinfrastructure components for identity federation (CILogon), user profile management, proposal processing (XRAS), and high-performance computing systems (such as Delta, Bridges-2, Anvil, and Expanse). While ACCESS focuses broadly on general scientific cyberinfrastructure across all disciplines, NAIRR specifically expands dedicated AI resources, foundation models, and commercial cloud integrations.

What types of datasets and foundation models are available through the pilot?

The pilot coordinates access to curated scientific datasets from federal agencies, including medical imaging repositories from the NIH Medical Imaging and Data Resource Center (MIDRC), NASA Earth science observations, and NOAA climate data. Additionally, partner integrations with Hugging Face, Microsoft, AWS, and Google Cloud provide access to open-weight foundation models, privacy-preserving evaluation environments, and specialized pre-trained weights.

Sources

• National Science Foundation (NSF). “National Artificial Intelligence Research Resource (NAIRR) Pilot.” Official Program Page: https://new.nsf.gov/focus-areas/artificial-intelligence/nairr. Checked 2026-11-14.
• NAIRR Pilot Operations. “National Artificial Intelligence Research Resource Pilot Portal.” Operational Portal and Resource Catalog: https://nairrpilot.org. Checked 2026-11-14.
• Advanced Cyberinfrastructure Coordination Ecosystem: Services and Support (ACCESS). “ACCESS Allocations and High-Performance Cyberinfrastructure.” Platform Guide: https://access-ci.org. Checked 2026-11-14.
• National Center for Supercomputing Applications (NCSA). “Delta and DeltaAI GPU Computing Systems.” Resource Documentation: https://www.ncsa.illinois.edu. Checked 2026-11-14.
• Pittsburgh Supercomputing Center (PSC). “Bridges-2 AI and High-Performance Computing System.” User Guide: https://www.psc.edu. Checked 2026-11-14.
• Argonne Leadership Computing Facility (ALCF). “Polaris Supercomputer and AI Testbed.” System Overview: https://www.alcf.anl.gov. Checked 2026-11-14.
• National Energy Research Scientific Computing Center (NERSC). “Perlmutter Cray EX System Architecture.” Technical Documentation: https://www.nersc.gov. Checked 2026-11-14.
• Medical Imaging and Data Resource Center (MIDRC). “MIDRC Open Clinical AI Repositories.” Platform Catalog: https://www.midrc.org. Checked 2026-11-14.