Atrex Kernel Agent v0.4.0 — Lightweight workflow and plugin architecture

Atrex Kernel Agent v0.4.0

A lightweight workflow and plugin architecture are the two main changes in v0.4.0.

• Lightweight optimization: better kernel performance with 20–30% lower average
  token consumption. A unified Episode loop keeps research annotations, generated memory,
  and supplemental numerical probes optional while preserving authoritative measurement,
  correctness, and promotion checks.
• Plugin architecture: agents, problem/source loading, candidate workspaces, evaluation,
  execution, Wiki, and workflow services are composed through explicit contracts and profiles.
  Providers can be configured or replaced through composition, making it easier to extend
  individual capabilities without changing the orchestration core.

This release makes Light the default GPU kernel optimization workflow. Coding agents
work in managed source drafts and submit measured candidates through a private Tool Runtime.
The Supervisor owns evaluator inputs, source sealing, correctness and production-policy
checks, performance verification, and promotion. The previous workflow remains available
through --profile workflow.

Changes below cover the current implementation since v0.3.0.

Highlights

Lightweight Episodes and supervised promotion

• One Episode lifecycle. Light replaces the default Fast/Full stage split with a unified
  research, edit, evaluate, and report loop. Agents use Git-free drafts; the Supervisor owns
  Git commits and the incumbent. A valid episode-report seals the exact measured source,
  so subsequent draft edits cannot change the candidate under review.
• Evidence-backed acceptance. Private records bind measurements to candidate source,
  evaluator inputs, and execution settings. Reports cite those records; invalid reports
  return repair feedback. Failed, blocked, or unpromoted attempts preserve evidence without
  replacing the incumbent.
• Native ABBA promotion. Candidate and incumbent are compared in the same Agate allocation
  through native Atrex-Bench Eval. Promotion requires a geometric-mean latency reduction
  strictly above the configured threshold. Evaluator objective scores remain diagnostic;
  they do not substitute for the Light promotion metric.
• Optional search and learning state. Agent-created Skills/tools can carry across Episodes
  independently of kernel promotion. Direction/Experiment research records, generated memory,
  goal Episodes, and pooled multi-trajectory search can be configured separately.

Plugin architecture and source ownership

• Installed CLI and profiles. aka optimize selects providers through Bootstrap and Core.
  The atrex-aka-framework, atrex-aka-legacy, and atrex-aka-light distributions separate
  framework contracts, shared implementations, and Light services. Light continues to reuse
  shared agent adapters, production review, evaluator helpers, and profiling code.
• Explicit module boundaries. Problem loading, initial Source selection, and
  CandidateWorkspace are separate services. Evaluation plans measurements; Experiment owns
  records and deduplication; Execution owns GPU jobs; Journal, Acceptance, and Workflow own
  reporting and promotion. The private HTTP Tool Runtime authorizes and routes agent requests.
• Multi-file candidates by default. source_tree provides a fixed kernel.py adapter
  importing editable impl/model.py; agents can add source files under impl/ without an
  import manifest. Complete snapshots include headers and build settings in candidate identity.
• Native CUDA manifests. Explicit file_system=cuda_manifest with --framework Cuda
  supports CUDA sources, headers, and solution.json without a candidate Python loader.
  AKA transports a hash-verified archive and delegates compilation and binding to Agate.
  single_file remains an independent explicit layout. See source layouts.

Knowledge, profiling, and observation

• Wiki enabled by default. The bundled GPU Wiki provider supplies knowledge through
  the Tool Runtime. Providers can be replaced without changing workflow code. Wiki has its
  own query budgets, revision pinning, Episode-local result reuse, and timing receipts;
  startup no longer requires loading the local corpus before the first query.
• GPU micro-analysis Skill. An optional repository-local plugin adds guidance for focused
  GPU analysis alongside the existing NVIDIA, AMD, and PPU profiling tools. Select its directory
  explicitly through Resources; it is not included in the Python packages or Wiki resource export.
• Session observations and optional dashboard. Light captures agent sessions and retains
  observations across retries and replacement sessions. An independently installed dashboard
  shows persisted campaign observations, settled usage, and source-declared downloadable
  artifacts through a versioned observation provider. Its current performance-history reader
  requires generated memory/vN.json; the default file exporter does not package complete
  multi-file candidates. It is not started by the default profile.

Recovery and evaluator feedback

• Native local evaluation and terminal source export. The community local gateway
  accepts verified source uploads and native Atrex-Bench ABBA requests. Terminal Episodes
  retain the complete attempted source with matching measurement evidence before draft
  removal; unavailable or stale evidence cannot certify a candidate. See
  local evaluation and exports.
• Preserve work across interruptions. Bounded provider-throttle and output-limit recovery
  retain the Episode, draft, measurements, and usage history. Blocking Runtime requests pause
  the agent process tree and do not consume its active-time budget.
• Durable GPU execution. Job IDs, idempotency keys, checkpoints, queue/execution deadlines,
  and bounded infrastructure retries distinguish accepted jobs from safe replacement attempts.
  Completed ABBA batches survive sibling failures. Recorded continuations restore the original
  module selection and runtime pins.
• Accurate outcome caching. Unknown or unavailable evaluations cannot become reusable
  completed verdicts. Completed candidate failures remain reusable evidence. Adapter and cache
  checks preserve the distinction between a successful transport and a successful evaluation.
• Actionable failure diagnostics. Agent feedback retains compiler/runner output, rank-local
  checks, failing-case metadata, measured errors, and tolerances while redacting private shapes
  and credentials. Oversized diagnostics have explicit truncation metadata. Version reports
  distinguish objective-score ratios from geometric-mean latency speedups.

Defaults and correctness

Setting	v0.4.0 Light default
Fresh aka optimize / aka workflow launch	light
Coordinator agent	Native execution with capture; Bubblewrap requires light-sandbox
Optimization mode	leaderboard; production review requires --optimization-mode production
Candidate file system	source_tree
GPU Wiki	Enabled
Direction/Experiment research recording	Disabled
Generated memory summaries	Disabled
Goal Episodes and pooled search	Opt-in
Supplemental numerical planning/probes	Disabled; enable workflow.config.numerical_validation explicitly
Optimization Episode budget	14,400 seconds of agent active time
Native candidate correctness	Six cases per shape: base plus five additional cases
Performance sampling	20 timing iterations, five warmup iterations, clock locking enabled
Native ABBA	Two measurements per side by default: one A/B/B/A block

Supplemental numerical probes are additional validation. Their default-off setting does
not disable ordinary evaluator correctness, production constraints, or ABBA verification.
Likewise, optional memory and research recording do not control authoritative measurement
storage, report sealing, or promotion.

Production source-policy review is shared with Legacy. For Agate tasks with a validated
distributed evaluator contract (torchrun, NCCL, world_size >= 2), source-policy inspection
and framework conversion are exempted. Correctness and performance checks remain required.
The decision is frozen from trusted evaluator metadata and cannot be changed by editing
candidate files. See policy and options.

Upgrading from v0.3.0

1. Build and reinstall matching packages. Use the commands in the setup guide.
   Keep the packages and resource checkout at the same revision. Distribution metadata currently
   uses 0.1.0; that package version alone does not identify the v0.4.0 repository release.
2. Update launch scripts. Replace python orchestrator/optimize.py with the installed
   aka optimize --repo-root /path/to/aka -- .... Launch options such as --profile and
   --patch precede --; optimization arguments follow it. The removed source-tree entry
   points and private implementation paths are not compatibility interfaces.
3. Choose the workflow and workspace explicitly when migrating. New launches default to
   Light and require atrex-aka-light. Use a new workspace when moving from Legacy to Light.
   Manually restarting a Legacy workspace requires --profile workflow; recorded continuations
   retain their original selection. Missing Light never silently selects Legacy.
4. Check evaluator and source-layout compatibility. Light's native ABBA path requires
   Agate Atrex-Bench. SOL/SSH inputs require explicit single_file, and Light ABBA has no
   SOL/SSH fallback; use Legacy for campaigns needing its verification path. Native CUDA
   manifests do not support SOL/SSH or Check/Disassemble. Existing Light campaigns must
   resume with their original file-system selection.
5. Review optional settings. Use light-sandbox on Linux for Bubblewrap. Native Light
   is a cooperative execution boundary. Enable supplemental probes, research recording, or
   generated memory only when needed; composition patches replace a provider's whole config,
   with omitted fields taking provider defaults. Retain "startup": true in Workflow
   patches used by aka optimize so the required launch service remains available.
6. Compare results under the current measurement contract. Light promotes on same-allocation
   geometric-mean latency reduction; Legacy retains its score-based rule. Historical evidence
   remains readable, but records with different source, evaluator, or measurement identities
   cannot satisfy a new acceptance request.

Validation evidence and scope

The native CUDA and source-layout report records live <gpu_arch> checks for
multi-file compilation, six-case correctness, native ABBA, deliberate candidate rejection,
and exact snapshot restoration. Its Agent optimization history includes an accepted
improvement, a rejected regression, and a timed-out handoff whose later independent comparison
did not promote the candidate. These are scoped interface and campaign checks, not a general
performance claim for every backend.

The Light implementation guide records
package, composition, session, isolation, report, and recovery checks. The
evaluator-outcome report documents local fault-injection
and diagnostic regressions; those checks did not submit GPU work.

For configuration and extension details, see Light modules,
installed application startup,
Core contracts, and the dashboard.