praxion

Generate or refresh AGENTS.md.tmpl for Praxion Codex onboarding from a project's CLAUDE.md, stripping Claude-only details. Triggers: install.sh codex needs a Codex source template, refreshing a previously generated Codex project template.

Creating and configuring agents (subagents): system prompts, tool permissions, lifecycle hooks, model selection. Triggers: building custom agents, designing agent workflows, spawning subagents, delegating via the Agent (formerly Task) tool, defining subagent_type, /agents command.

AI agent evaluation: Inspect AI/DeepEval/Promptfoo framework selection, golden datasets, LLM-as-judge, grader design, scoring, non-determinism handling, CI/CD integration. Triggers: evaluating agent behavior, choosing an eval framework, designing eval suites, building golden datasets, trajectory evaluation, eval-driven development, integrating evals into CI/CD. Python-focused; TypeScript in references/typescript.md.

Classification rubric for agentic-AI runtime failure modes (Microsoft AI Red Team taxonomy: prompt injection, excessive agency, tool abuse). Triggers: classify or diagnose an observed agent failure, or run a design-time failure-mode review. Diagnosis -- not prevention (agent-runtime-guardrails), not plugin security (context-security-review).

Interpret and act on the /project-metrics Agent Readiness score: 8 Factory pillars x 5 maturity levels x 80%-per-level gate, plus Pillar 9 Manageability. Triggers: reading or acting on an agent readiness report, understanding why a project scored a given level, deciding how to improve readiness, interpreting mechanical vs LLM criteria (naming_conventions, test_quality, readme_quality, docs_agent_friendliness), running readiness without an API key, grounding a new readiness run on a prior report.

Un-bypassable runtime enforcement for agentic apps: input validation, structured-output enforcement, tool-call gating, budget/permission enforcement via the deterministic-harness pattern. Triggers: design, build, or verify guardrails that enforce model I/O and gate tool calls regardless of model output. Prevention -- not SDK mechanics (agentic-sdks), not failure classification (agent-failure-taxonomy).

Interface design for the model as consumer: MCP tools, function-calling schemas, A2A contracts. Ergonomics, tool naming, error grammar, fat-vs-thin decomposition, progressive disclosure, idempotency, response pagination, JSON-schema craft. Triggers: designing/reviewing MCP tools, tool descriptions, function-calling schemas, agent error ergonomics, A2A contracts. Not for web/CLI (web-ui-design, tui-design) or REST/GraphQL quality (api-design-craft).

Building AI agents with OpenAI Agents SDK and Claude Agent SDK: architecture, tool integration, multi-agent orchestration, safety guardrails, tracing, context management, streaming, MCP integration. Triggers: building autonomous agents, multi-agent workflows, choosing agent frameworks, integrating MCP servers, agent safety patterns. Python and TypeScript modules.

Provider contract, decision rubric, and composition guidance for agentic payments (mandate-based rails, stablecoin/card/crypto settlement) and agentic trading (brokerage order placement, market data, portfolio positions). Triggers: agentic payment, agentic trading, Provider contract, mandate, settlement finality, HITL spend-gating, brokerage agent, MCP trading, order execution, payment rail, idempotency key, TransactionError, supports_sandbox. Language-independent; Python binding in references/provider-contract.md.

API design methodology: API-first development, resource modeling, endpoint naming, HTTP semantics, OpenAPI 3.1 patterns, GraphQL schema design, versioning strategies, schema evolution, contract testing, consumer-driven contracts, service boundaries, REST vs GraphQL. Triggers: designing APIs, writing OpenAPI specs, defining data contracts, planning API versioning, designing interface contracts, reviewing API surface design.

API quality, taste, and review craft above api-design methodology: canonical APIs (Stripe, S3, Linear, GitHub, Twilio, Resend), Bloch review checklist, robust-API canon, REST vs GraphQL vs gRPC, HTTP status semantics, PATCH, webhooks, low-latency ergonomics. Triggers: reviewing API quality, applying a taste lens, choosing a paradigm, designing error contracts/pagination/webhooks, evaluating latency ergonomics. Methodology in api-design; agentic tool design in agentic-interface-design.

Producing best-in-class docs of your OWN API surface for humans and AI agents: REST/OpenAPI, Python/TypeScript libraries, GraphQL schemas, MCP server docs, agent-consumable docs (llms.txt). Triggers: document my API, API reference docs, OpenAPI docs, MCP server docs, GraphQL schema docs, agent-consumable docs, llms.txt, document a REST/Python/TypeScript API surface.

Applied statistics for engineering decisions: power/sample-size planning, multiple-comparisons correction, bootstrap intervals on pass@k, judge agreement, non-determinism variance, confounding/Simpson's-paradox risk, error-model tolerance bands, sequential testing. Triggers: claiming an effect is significant, sizing a sample or run count, comparing systems across benchmarks, deriving a threshold or tolerance band, when to stop collecting data.

Architectural fitness functions: ArchUnit-style invariants via import-graph tooling and assertion-based tests, graph-rule vs assertion rubric, ADR/CLAUDE.md citation contract, waiver pattern. Triggers: authoring fitness rules, deciding between graph-rule and assertion-based invariants, authoring a fitness waiver. Python/TypeScript/Rust modules.

The eight dimensions of beautiful code -- storytelling, simplicity, clarity of intent, expressiveness, purity, sustainability, durability, creativity -- with practitioner canon and review checks. Triggers: writing or reviewing code with beauty, elegance, or readability at stake; milestone code reviews; asking is there a more elegant way; judging a creative-but-unfamiliar solution; comment and narrative discipline; functional core / imperative shell; backward-compat and observable-behavior judgment; reconciling cleverness vs insight.

CI/CD pipeline design and GitHub Actions authoring: architecture, testing stages, deployment strategies, caching, secrets management, security hardening, performance optimization. Triggers: creating CI/CD pipelines, writing GitHub Actions workflows, configuring automated testing, setting up deployment automation, debugging workflow failures, optimizing pipeline performance, reviewing CI/CD config, designing deployment pipelines, implementing build automation.

Anthropic Claude platform: API features, SDK usage (Python/TypeScript), model selection, extended thinking, batch processing, prompt caching, structured outputs, token counting, Files API. Triggers: building with the Claude Messages API, choosing Claude models, integrating Anthropic SDKs, choosing between Agent SDK and Messages API, Claude API integration, navigating Anthropic documentation.

Structured code review methodology: finding classification (PASS/FAIL/WARN), language adaptation, report templates. Triggers: reviewing code for convention compliance, post-implementation verification, pull request review, PR review, code audit, code quality checks.

Creating and managing slash commands: reusable user-invoked prompts with arguments, tool permissions, dynamic context (!, @, argument-hint). Triggers: creating custom slash commands, debugging command behavior, fixing argument substitution, converting prompts to commands, organizing commands with namespacing.

Agent-to-agent communication protocols for multi-agent interoperability: A2A (Agent2Agent) -- Agent Cards, task-based messaging, discovery, streaming, push notifications, Python/TypeScript SDKs, ADK/LangGraph/CrewAI/Pydantic AI integration. Triggers: building multi-agent systems across frameworks or organizations, exposing agents via A2A endpoints, implementing agent discovery; A2A, agent-to-agent, Agent Card, multi-agent communication, agent interoperability, cross-agent protocol. Python/TypeScript modules.

Security review methodology for Claude Code plugin ecosystems: context artifact injection, hook compromise, dependency supply chain, script injection, secrets exposure, GitHub Actions security. Triggers: reviewing PRs for security, conducting security audits, verifying agent permissions, reviewing hook scripts, checking for secrets, assessing context artifacts (CLAUDE.md, skills, agents, rules, commands, hooks).

Database and data model design: relational/NoSQL modeling, normalization, migration planning, ORM patterns, schema evolution. Triggers: designing database schemas, choosing relational vs NoSQL, planning data migrations, modeling entities/relationships, designing indexes, ORMs, normalizing/denormalizing, ER diagrams, domain-driven design (DDD) aggregates, evolving schemas in production.

Data-structure and representation design: types, invariants, state shapes, and schemas at the heart of a component, chosen before its behavior. Triggers: defining or changing a core domain type or data model, designing state machines or lifecycle phases, choosing sum vs product types, making illegal states unrepresentable, parse-don't-validate boundaries, newtypes/smart constructors for constrained values, designing schema contracts between components or agent tools, deciding a representation before its operations. Persistence-layer schema design (databases, ORMs, migrations) belongs to data-modeling, not here.

Application deployment: Docker Compose, PaaS, cloud containers, Kubernetes, AI-native GPU platforms, reverse proxy, secrets management, AI/ML model serving. Triggers: deploying an app, writing compose.yaml or Dockerfile, choosing a hosting platform, configuring Caddy/nginx, deploying Ollama/vLLM, GPU passthrough, choosing Render/Railway/Fly.io/Vercel, managing Railway environments or PR environments, wiring Railway's agent plugin/MCP/CLI, deploying to Cloud Run/ECS/Modal/CoreWeave, writing systemd units for Compose. Siblings: cicd (pipeline automation), observability (monitoring).

Writing and maintaining project documentation: README.md, catalogs, architecture docs, changelogs, Mermaid diagrams. Triggers: creating/reviewing/fixing documentation, maintaining catalog READMEs, verifying filesystem state match, documentation audit, checking doc freshness, authoring diagrams.

Appraises imported claims -- cited studies, benchmarks, vendor docs, blog findings -- for whether the source actually supports the claim made of it. Triggers: citing a study, paper, or benchmark to justify a decision; relaying a coefficient, effect size, or vendor number without independent verification; importing an external finding into an architecture or design doc; appraising a source before it becomes load-bearing. Distinct from applied-statistics (audits inference on our own numbers) -- this audits whether someone else's numbers license our claim.

ML experiment lineage tracking -- NOT app observability (use observability for RED/OTel/Prometheus/Grafana). Covers per-run hyperparameters, metrics (val_bpb, loss curves), artifact URIs, run comparison via MLflow, W&B, or Aim. Triggers: setting up experiment tracking, connecting a training loop to MLflow or W&B, mapping run IDs to TRAINING_RESULTS.md; run lineage, hyperparameter logging, metric curves, mlruns, wandb.init, mlflow.start_run, program.md tracker declaration, experiment log. Activate alongside ml-training and llm-training-eval.

Retrieving current API documentation for external libraries and SDKs: search strategies, token-aware fetching (chub_search, chub_get, chub_annotate, chub_feedback), annotation persistence, provider fallback. Triggers: writing code against Stripe/OpenAI/Anthropic/AWS/FastAPI/Supabase or any external API, debugging an integration, evaluating SDK capabilities, looking up endpoint signatures/parameters, guarding against training-data staleness; external API reference, SDK docs lookup, current API signatures, integration reference.

Task-intake protocol for turning a fuzzy user request into an unambiguous, verifiable goal before committing to a direction. Triggers: at the start of any non-trivial task when the request is vague, implementation-first, or its success is not measurable; deciding whether to ask the user a clarifying question or proceed with stated assumptions; capturing acceptance criteria / definition-of-done at intake; reducing rework from misread intent.

Creating, testing, and registering Claude Code hooks: hook events, registration lifecycle, output patterns (additionalContext, updatedInput, decision), gotchas, installer integration. Triggers: creating new hooks, debugging hook execution, fixing hook registration, choosing hook types, why a hook is not firing.

Detect and remove ephemeral identifier citations (REQ-*, AC-*, EC-X.X.X, Step N, req{NN}_ test naming) from project source code. Triggers: pre-discipline Praxion project, check_id_citation_discipline.py reports violations, user asks to clean up REQ citations/decontaminate id references/remove pipeline residues from code, /decontaminate-ids invoked.

Decision rubric and recipes for querying LikeC4 architecture models: `likec4` MCP tools vs. reading `.c4` files directly. Path-scoped to architecture-authoring surfaces. Triggers: authoring/modifying DESIGN.md, .c4 files, diagram sources, exploring LikeC4 model for design decisions.

Prompt engineering for LLMs: few-shot patterns, chain-of-thought, reasoning-effort control, structured output (Pydantic/Zod), prompt versioning, regression testing. Framework-agnostic. Triggers: designing prompts for production LLM calls, writing system prompts, debugging output-quality issues, migrating across model versions, picking a prompt-management platform, establishing prompt regression tests. Defers to claude-ecosystem, agentic-sdks, agent-evals, external-api-docs. Python/TypeScript modules.

LLM pre-training evaluation: primary metric val_bpb (bits-per-byte), validation perplexity (secondary), PASS/FAIL/WARN tolerance bands, baseline-comparison syntax, EleutherAI lm-evaluation-harness. Owns TRAINING_RESULTS.md schema. Triggers: designing training-run acceptance criteria, setting metric thresholds, verifier evaluating training results; val_bpb, bits-per-byte, perplexity, lm-eval-harness, training evaluation, metric thresholds, tolerance bands. Compose with ml-training and neo-cloud-abstraction.

Building MCP (Model Context Protocol) servers with official SDKs: tools, resources, prompts, transports (stdio, streamable HTTP), bundles (.mcpb), Inspector testing, client integration, logging, error handling, security. Triggers: creating MCP servers, defining MCP tools/resources, configuring transports, packaging bundles, testing servers, integrating with Claude; MCP tool definition, MCP resource exposure, FastMCP server patterns. Python (FastMCP) and TypeScript (@modelcontextprotocol/sdk) modules.

ML/AI pre-training project management in Praxion: training archetype vocabulary, three operational modes (owned-GPU, rented-GPU, separated-cloud), program.md as experiment-loop meta-prompt, compute-budget rules. Triggers: onboarding neural-network training; train.py/prepare.py/program.md present; GPUs, loss curves, perplexity, autoresearch, Karpathy, torch/jax/tensorflow; an autonomous agent driving a training loop. Compose with agentic-sdks, agent-evals; siblings llm-training-eval, neo-cloud-abstraction, experiment-tracking.

Composition layer for multi-perspective deliberation: calibrated confidence annotation, lens-independence discipline, heterogeneous model orchestration (Haiku-proposer/Opus-aggregator), two-tier disconfirmation (Tier-A architectural ADRs, Tier-B cross-model adversarial challenge). Triggers: high-stakes design decisions with genuine uncertainty, adversarial stress-testing of architectural choices, calibrating confidence on research claims, parallel lens fan-out that must remain independent, pre-mortem failure-imagination at planning-implementation boundary.

ML training job dispatch abstraction for Praxion ML/AI projects: mode-invariant training_job_descriptor schema, four backends (local subprocess, SkyPilot 20+ providers, RunPod, Nebius). Triggers: configuring a compute backend, dispatching via /run-experiment, reading/writing training_job_descriptor YAML or neo_cloud_backend.yaml, debugging backend dispatch errors, choosing local vs SkyPilot vs RunPod vs Nebius, subprocess training, GPU cloud dispatch, Nebius, backend: nebius-direct. Activate alongside ml-training and llm-training-eval.

Node.js project lifecycle: version pinning, package management, dependency graph hygiene, workspace/monorepo patterns, tsconfig baseline philosophy. Triggers: setting up a Node.js project, choosing a package manager, wiring a monorepo, managing transitive dependency conflicts, configuring tsconfig inheritance, auditing dependency graph health. TypeScript module.

Application observability: structured logging, metrics, distributed tracing, alerting, three pillars, RED/USE, SLI/SLO/error budgets, OpenTelemetry, cardinality management. Triggers: adding observability, choosing logging/metrics/tracing strategy, designing alert rules, defining SLIs/SLOs, instrumenting OpenTelemetry, reviewing coverage; monitoring, telemetry, OTel, spans, log levels, burn-rate alerting, Prometheus naming, Grafana dashboards, trace context propagation, metrics cardinality, runbooks, on-call, SLA, log aggregation, trace analysis.

Bring a project into the Praxion ecosystem: detect state and install the managed-project contract (gitignore block, .ai-state/ skeleton, git hooks, merge drivers, settings toggles, CLAUDE.md blocks) plus optional tiers (architecture, code-quality, CI autofix, Architecture-as-Code, ML, Obsidian). Four modes: new, existing, hackathon, promote. Safe to re-run; nothing is committed.

Architectural patterns for performant software systems, including agentic/multi-agent systems. Triggers: performance, bottlenecks, caching strategies, capacity planning, latency, throughput, load testing, performance budgets, performance anti-patterns, latency analysis, connection pooling, async/concurrent patterns, database query optimization, benchmarking, scaling/scalability, token budget, context-window efficiency, agent spawn cost, subagent fan-out, multi-agent pipeline wall-clock, progressive disclosure as a performance optimization.

Systematic methodology for understanding unfamiliar software projects: characterization, structure analysis, dependency mapping, workflow discovery, layered output. Triggers: joining a new project, exploring an unfamiliar codebase, project overview, architecture understanding, codebase orientation, codebase walkthrough, code exploration, project analysis, developer onboarding.

Python development conventions: type hints, pytest, code quality tools (ruff, mypy, pyright), data modeling (dataclasses, Pydantic), async patterns, error handling, pattern matching, version-specific idioms (3.10-3.14+), curated library catalog by archetype. Triggers: writing Python code, implementing tests, configuring linting/formatting, choosing between dataclasses and Pydantic, pytest fixtures and parametrize, ruff formatting/linting, mypy type checking, pytest configuration, picking a library for a new capability (web framework, ORM, CLI parsing, dataframes, async task queue, logging, config).

Python project management with pixi and uv: initialization, dependency management, pyproject.toml, lockfiles (pixi.lock, uv.lock), virtual environments, workspaces, CI/CD integration, conda vs PyPI. Defaults to pixi unless uv is explicitly requested. Triggers: setting up Python projects, managing dependencies, choosing between package managers.

Pragmatic refactoring: modularity, low coupling, high cohesion, incremental improvement. Triggers: restructuring code, improving design, reducing coupling, organizing codebases, extracting modules, eliminating code smells, refactoring patterns/code organization, cleaning up code, addressing technical debt, splitting modules, simplifying complex code.

Feature prioritization and backlog management: RICE/MoSCoW/WSJF/Kano/ICE frameworks, dependency mapping, roadmap formats (now-next-later, timeline, theme-based, outcome-based), capacity-based planning. Integrates promethean IDEA_LEDGER output into spec-driven-development. Triggers: prioritizing features, building a product roadmap, sequencing releases, release planning, backlog grooming, mapping feature dependencies, deciding what to build next.

Produces ROADMAP.md from a full-project audit via a project-derived lens set: paradigm detection (deterministic/agentic/hybrid), lens-set derivation (SPIRIT, DORA, SPACE, FAIR, CNCF Platform Maturity, Custom), parallel audit fan-out, lens synthesis, grounded claims. Triggers: ultra-in-depth project analysis, spring cleaning roadmap, project state of the union, lens-based audit, strengths/weaknesses/deprecations roadmap, agentic-era project evaluation, AGENTS.md-aware audit, SDLC health audit. Contrast with roadmap-planning (prioritizes existing backlog).

Creating and managing contextual domain knowledge rules (auto-loaded by relevance): rule structure, path-specific rules (paths: frontmatter), naming for relevance matching, content guidelines, rules-vs-skills-vs-CLAUDE.md decision model, rule mechanics, rule debugging. Triggers: creating/updating rules, debugging rule loading, organizing rule files, deciding rule vs skill vs CLAUDE.md placement.

Rust development conventions: type-driven API design (newtypes, builders, typestate), error handling (thiserror for libraries, anyhow for apps), Cargo workspace/lint/toolchain config, mechanical-vs-judgment split. Triggers: writing Rust code, configuring Cargo.toml lints or workspace, rustfmt/clippy setup, choosing thiserror vs anyhow, cargo-nextest test runs, reviewing unsafe code, Rust CI pipeline design, picking a crate for a new capability (async runtime, web framework, serialization, database).