.env.example

# openrouter | nvidia | openai  (single-provider fallback)
LLM_PROVIDER=openai
# comma-separated; with WORKERS_PER_PROVIDER runs both in parallel
LLM_PROVIDERS=
WORKERS_PER_PROVIDER=0

# OpenRouter (Anthropic Messages) — used when a role selects openrouter
OPENROUTER_API_KEY=

# NVIDIA NIM (OpenAI-compatible) — used when a role selects nvidia
# Up to 3 keys (or comma-separated in NVIDIA_API_KEY). Each key is its own
# nvidia slot; with WORKERS_PER_PROVIDER=N you get N workers per key.
NVIDIA_API_KEY=
NVIDIA_API_KEY_2=
NVIDIA_API_KEY_3=

# OpenAI-compatible Poke API is the default endpoint for openai roles.
OPENAI_API_KEY=
OPENAI_MODEL=gpt-6-luna

# Leave MODEL empty to use the provider-specific names.
MODEL=
OPENROUTER_MODEL=nvidia/nemotron-3-ultra-550b-a55b:free
NVIDIA_MODEL=nvidia/nemotron-3-ultra-550b-a55b
# Per-agent provider/model/API URL/thinking level. Empty values inherit the
# worker provider, MODEL (or provider model), default endpoint, and THINKING_LEVEL.
# Knowledge roles without a thinking override inherit KNOWLEDGE_THINKING_LEVEL.
# API_BASE_URL accepts a root URL or a URL ending in /v1.
GENERATOR_PROVIDER=openai
GENERATOR_MODEL=gpt-6-luna
GENERATOR_API_BASE_URL=
GENERATOR_THINKING_LEVEL=high
REPAIR_COMPILE_PROVIDER=openai
REPAIR_COMPILE_MODEL=gpt-6-sol
REPAIR_COMPILE_API_BASE_URL=
REPAIR_COMPILE_THINKING_LEVEL=medium
REPAIR_NUMERIC_PROVIDER=
REPAIR_NUMERIC_MODEL=
REPAIR_NUMERIC_API_BASE_URL=
REPAIR_SEMANTIC_PROVIDER=
REPAIR_SEMANTIC_MODEL=
REPAIR_SEMANTIC_API_BASE_URL=
CRITIC_PROVIDER=
CRITIC_MODEL=
CRITIC_API_BASE_URL=
COT_EDITOR_PROVIDER=openai
COT_EDITOR_MODEL=gpt-6-luna
COT_EDITOR_API_BASE_URL=
COT_EDITOR_THINKING_LEVEL=high
REFVAL_EXTRACT_PROVIDER=openai
REFVAL_EXTRACT_MODEL=gpt-6-luna
REFVAL_EXTRACT_API_BASE_URL=
REFVAL_EXTRACT_THINKING_LEVEL=high
KNOWLEDGE_GENERATOR_PROVIDER=openai
KNOWLEDGE_GENERATOR_MODEL=gpt-6-luna
KNOWLEDGE_GENERATOR_API_BASE_URL=
KNOWLEDGE_GENERATOR_THINKING_LEVEL=high
KNOWLEDGE_REPAIR_PROVIDER=
KNOWLEDGE_REPAIR_MODEL=
KNOWLEDGE_REPAIR_API_BASE_URL=
KNOWLEDGE_JUDGE_PROVIDER=
KNOWLEDGE_JUDGE_MODEL=
KNOWLEDGE_JUDGE_API_BASE_URL=
THINKING_LEVEL=high
MAX_INPUT_TOKENS=131072
MAX_OUTPUT_TOKENS=50000
MAX_TOKENS=50000
TOP_P=0.95
LLM_TIMEOUT_SEC=600

# Generation loop
MAX_CANDIDATES=3
MAX_REPAIRS=3
# Provider/key assignment count; each assignment admits MAX_INFLIGHT_JOBS jobs.
# Repeated assignments for the same key share the LLM_CONCURRENCY API limit.
WORKERS=1
MAX_INFLIGHT_JOBS=2
LLM_CONCURRENCY=2
COMPILE_CONCURRENCY=1

# Judge Agent (code quality analysis)
JUDGE_ENABLED=true
USE_JUDGE_OPTIMIZATION=false
KERNEL_LLM_CRITIC=adaptive
CRITIC_RETRY_ON_ERROR=1
REPAIR_HISTORY_MODE=single_turn

# Task kind: kernel (default, compile gate) | knowledge (rubric gate) | auto
TASK_MODE=kernel
KNOWLEDGE_JUDGE_ENABLED=true
KNOWLEDGE_MIN_SCORE=7
KNOWLEDGE_FACTUAL_MIN=6
KNOWLEDGE_MAX_CANDIDATES=2
KNOWLEDGE_MAX_REPAIRS=2
KNOWLEDGE_MIN_ANSWER_CHARS=400
KNOWLEDGE_REQUIRE_STRUCTURE=true
KNOWLEDGE_MAX_OUTPUT_TOKENS=8192
KNOWLEDGE_THINKING_LEVEL=medium
KNOWLEDGE_ON_JUDGE_FAIL=retry

# Kernel dialects: cuda | cutlass (CUTLASS 4.x + CuTe, aliases cute) | triton | tilelang
# KERNEL_MODE=single uses the first listed dialect (or KERNEL_DIALECT).
# KERNEL_MODE=all generates every listed dialect for each question.
KERNEL_DIALECTS=cuda
KERNEL_MODE=single
KERNEL_DIALECT=
CUTLASS_HOME=/usr/local/cutlass-4.3.5
CUTLASS_CXX_STD=c++17
# CUTLASS 单独更小思考预算，避免 Super/Ultra 写出几十万字 reasoning
CUTLASS_THINKING_LEVEL=low
CUTLASS_MAX_OUTPUT_TOKENS=8192
CUTLASS_REASONING_MAX_TOKENS=2048
TRITON_TIMEOUT_SEC=90
TILELANG_TIMEOUT_SEC=180

# CoT: capture API reasoning, polish with CoT Agent, wrap <think> in SFT labels
COT_ENABLED=true
COT_AGENT_ENABLED=true
COT_IN_ASSISTANT=true
COT_TEMPERATURE=0.2
COT_MAX_CHARS=8000
COT_RAW_MAX_CHARS=24000
COT_RAW_STORE_MAX_CHARS=32768
COT_ON_EMPTY=synthetic
COT_ON_AGENT_FAIL=raw
COT_REPAIRED_POLICY=synthetic
COT_CONSISTENCY_CHECK=true
SFT_SYSTEM_MODE=fixed
SFT_USER_IS_RAW_QUESTION=true

# Async LLM (speculative repair generation during compile)
ASYNC_LLM_ENABLED=true
ASYNC_LLM_MAX_WORKERS=2

# CUDA compile (leave CUDA_ARCH / GPU_NAME empty to auto-detect)
CUDA_ARCH=
GPU_NAME=
CUDA_HOME=/usr/local/cuda-12.6
NVCC_TIMEOUT_SEC=60
REPAIR_ERROR_MAX_CHARS=6000
# simple = only last solution.cu per question; detailed = all c*/r* attempts
WORK_KEEP=simple

# Numeric validation (compile → CPU reference → GPU compare). Strict mode is
# the default for training releases; use REFVAL_STRICT=false only for a
# compile-only exploration run. Missing toolchains and reference_error are
# quarantined in strict mode.
REFVAL_ENABLED=true
REFVAL_TIMEOUT_SEC=45
REFVAL_EXTRACT_TIMEOUT_SEC=180
REFVAL_BUILD_TIMEOUT_SEC=120
REFVAL_RUN_TIMEOUT_SEC=45
ORACLE_RETRY_MAX=2
ORACLE_RETRY_BACKOFF_S=5,20
REFVAL_CASES=standard
REFVAL_STRICT=true
REFVAL_MAX_ELEMENTS=4000000
REFVAL_CACHE=true