Agents & Skills

Frontier (Fable) role that authors and re-plans Phase 2 plan synthesis — decomposes work, builds dependency graph, MECE-partitions ownership, issues corrected instructions on planning misses.

Sonnet advisory judge scoring autonomous-iterate-loop queue items (aligned/misaligned/uncertain) against intent.md/goal.md/constitution; never blocks, only routes.

Debugging domain assessor for API/REST/GraphQL errors, auth, rate limiting, and server-side route handlers.

Read-only architecture analyst dispatched by the orchestrator for baseline/chunk-impact/review-rules/iterate-subgraph/learn-sync tasks; decides native engine vs NavGator escalation.

Opus-tier coordinator that fans out parallel database/frontend/API/performance assessors for multi-domain debugging.

Top-level Opus orchestrator for the 5-phase build loop (Assess→Plan→Execute→Review→Iterate, optional Learn) with a 7-step Review sub-flow.

Debugging domain assessor for query/migration/schema/Prisma/Postgres/connection-pool/vector-index issues.

Sole writer to .build-loop/app-contract/{ui.md,data.md,traceability.json}; chooses UI design direction and reconciles design/data deltas after implementation.

Fable-tier validator tracing all rendered data/claims/metrics to their sources before completion.

Fable-tier adversarial pressure-test of a proposed fix — root cause vs symptom, regression risk, evidence check.

Debugging domain assessor for React/hooks/rendering/hydration/client-state issues.

Applies a single ux-fix-plan.md or targeted fix plan from the Phase 5 work list; designed for parallel fan-out (≤4 in flight).

Fable-tier LLM escalation for the deterministic commit-audit hook; renders a four-option verdict on large/boundary-crossing diffs.

Haiku-tier fast scan for residual mock/placeholder/fake/private/secret data in production code paths.

Executes the optimization loop — generates hypotheses, makes atomic changes, measures metrics, keeps or reverts, until convergence/budget exhaustion.

Fable-tier read-only adversarial review of optimization results for overfitting/Goodharting/test-gaming.

Debugging domain assessor for slowness/latency/memory-leak/CPU/bottleneck symptoms.

Fable-tier adversarial critique of a Phase 2 plan for non-deterministic issues (alternatives, MECE quality, marker adequacy) after plan-verify runs.

Fable-tier advisory judge for Phase 6 experimental-artifact promotion (approve/rethink/new_approach); never blocks, feeds user-confirmation gate.

Haiku-tier pattern-matcher scanning state.json run logs for recurring failures/patterns across 3+ runs; no judgment, just detection.

Post-push background synthesizer writing a 9-section retrospective + summary from the session transcript/state.json/intent/plan.

Deep causal-tree investigator for debugging symptoms beyond surface diagnosis; flags when external/environmental research is needed.

Fable-tier read-only Plan→Execute boundary check tracing callers of any changed public signature outside a commit's owned-files.

Fable-tier adversarial security review of implementer output against OWASP LLM/Agentic/Web Top 10 and MITRE ATLAS, gated on riskSurfaceChange.

Drafts a concrete experimental SKILL.md or agent definition from a recurring-pattern-detector proposal, written to .build-loop/skills/experimental/.

Sonnet-tier read-only critic for subjective synthesis dimensions (copy_tone, empty_state) on UI-touching commits; WARN-only, never blocks.

Pure stdlib regex miner of local Claude Code transcripts for corrections/tool sequences/file patterns/command rituals/secret exposures; no LLM calls.

Deterministic UI scanner against the running dev server (layout collisions, touch targets, console errors, hydration, visual SSIM) with its own authed browser session.

Coordinate build-loop with peer coding agents via Rally Point (presence/inbox/handoffs).

Listen for and wire Rally Point change watchers.

Consult the api-registry plugin when a new API dependency is detected; degrades gracefully if absent.

Scan for dead/orphaned code; native copy of NavGator's dead-code scan.

Blast-radius analysis tracing upstream/downstream dependencies before a refactor.

Heavyweight architectural integrity review for builds crossing 2+ layers; native copy from NavGator.

Detects orphans, layer violations, circular deps, and hotspots; native rules engine from NavGator.

Refreshes native component/connection data in .build-loop/architecture/.

Follows a component's connections end-to-end; native trace copied from NavGator's CLI.

Apply the four-layer Apache-2.0 attribution model (NOTICE, SPDX, REUSE.toml, canary markers) to a repo.

Wire/debug auth (Better Auth, Supabase Auth, Google OAuth, Resend) for a new or existing project.

Signal taxonomy and extraction prompts for proactive in-session decision capture into build-loop-memory.

Default-on auto-capture of severity-labeled findings/issues into the backlog regardless of source.

Main orchestrated build-loop entrypoint for multi-step code work; verb/symptom trigger language.

Build/refactor agents importing OSS deepagents (create_deep_agent) — SubAgent API, middleware, tool scoping.

Populates state.json.activeCapabilities with ≤8 relevant entries per phase via plugin-surface collapse.

Deep iterative debugging loop for when a fix didn't hold or root-cause analysis is needed.

Memory-first debugging workflow; owns verdict-handling and delegates lookup to debugging-memory-search.

Parallel domain assessment fan-out (db/frontend/api/perf) for complex debugging symptoms.

Search primitive for local build-loop incidents plus optional standalone Coding Debugger memory.

Stores a debugging incident record after a bug fix; native local storage with optional Coding Debugger mirror.

Bridges the orchestrator to the defenseclaw project's eval/test conventions when detected; otherwise no-op.

Compose a durable build-loop handoff document and optionally launch a fresh session with it injected.

Routes UI visual verification to the IBR plugin when installed, else falls back to native-ax-driver/ui-validator.

Read-only repo-local episodic memory review surface (decision rot, stale procedures, open conflicts).

Canonical build-loop-memory framework for recording decisions/ADRs, regenerating indexes, and recall.

Optional escalation to standalone Coding Debugger for extended observability/tracer backends.

Generates stack-appropriate logging/tracing with optional OpenTelemetry for silent failures.

Generates declarative focused-loop specs, presets, validators, and skill-chain plans.

Build/package/debug an MCP server or add MCP tools to a plugin.

Runs a controlled multi-model bake-off across isolated git worktrees with deterministic re-scoring and best-of grafting.

Two-axis taxonomy (work-role segment × 7-rung capability ladder) for choosing a subagent's model tier.

Drives running macOS apps via Accessibility API without touching the hardware cursor; self-contained Swift binary.

Design-of-Experiments test matrix (up to 6 variables) to find which variable moves a target metric.

Runs deterministic plan-verify rules on a Phase 2 plan and emits findings JSON.

Create/scaffold/convert/migrate a Claude Code plugin — plugin.json, layout, hooks, MCP, agents, LSP.

Static-analysis test harness for Claude Code plugins (namesake collisions, manifest drift, MCP misregistration).

Surfaces PRD principles and Navigation Map into Phase 1 Assess when a project PRD exists.

Recursive-learning retrospective encoding build history into memory, agents, skills, evals, and gates.

Generates a repo-grounded pre-decision research packet with risks, best path, confidence, next action.

Blameless RCA producing durable system levers, tiered L0/L1/L2 by impact; delegated-to by debug-loop.

Verifies a running app's core flow against the backing source-of-truth before claiming a fix works.

Threat-modeling and scoped-permission methodology backing the security-reviewer agent.

Deterministic OWASP scanner over the repo (secrets, injection, rate limiting, headers) mapped to OWASP IDs.

Scans recent runs for recurring patterns and auto-drafts experimental skills/agents with A/B tracking.

Writes a build-loop-compatible plan/spec, walking a completeness checklist and running plan-critic.

Read-only drift check recomputing source_hash for skills/architecture/ and skills/debugging/.

OpenTelemetry-first guidance for instrumenting observability/tracing/metrics/logs in an app.

Selects UI design direction for design-contract-specialist from tokens, UI Guidance, IBR artifacts, and research.

Checklist for independently verifying a dispatched agent's claimed commits/tests, since a solicited peer check is not independent.

Scans live UI page, compares against user intent, fixes mismatches, re-scans. Invoked for 'check my UI', 'verify the design', or after building components.

Primary design-agent planner — design intent, specialist passes, target roles, validation criteria for page, flow, app, dashboard work.

Web archetype classifier — routes to defaults for dashboards, research tools, workbenches, AI chat, checkout, content, admin screens.

Chart-worthiness gates, chart routing, hierarchy, attribution, accessibility, validation for charts, graphs, dashboards, KPIs, metrics.

Pre-build design direction, Calm Precision rules, component pattern selection, active design tokens, validation handoff.

Reusable component blueprints for cards, nav, forms, dashboards, modals, tables, lists with Calm Precision principles.

Design token extraction, validation, design system compliance, initialize tokens, view principles, add rules.

Building UI from user descriptions, implementing designs, matching mockups, aligning frontend edits with intent.

Post-build verification pass — audit UI, validate build, check accessibility, find regressions, compare before/after.

Capturing and comparing design references, screenshotting pages, saving design inspiration from URLs.

IBR refinement loop orchestration — scan → fix → re-scan iteration management until validation passes.

CLI command reference for inspecting, testing, validating UI via IBR for web and native platforms.

Form testing, click-through flows, search/login interaction testing, browser interaction assertions.

iOS, watchOS, macOS native app scanning — touch targets, a11y labels, watchOS constraints, Fix Guide.

Configuring/troubleshooting IBR automatic before/after scan workflow on UI file edits.

Pre-build UI brainstorming — explore directions before implementing, capture platform/scope/archetype context.

Reusable UI guidance patterns and decision aids, indexes central and project-local templates.

Bridge between mockup gallery reviews and IBR scan verification, enforces approved target roles.

Mobile web UI patterns — responsive design, touch targets, viewport handling, Material 3, iOS Safari, WCAG 2.2.

iOS HIG rules — SwiftUI conventions, safe areas, SF Symbols, Dynamic Type, haptics, Liquid Glass.

iOS archetype classifier — routes to defaults for 6 iOS app archetypes (Utility, Content, Productivity, Consumer, Editorial, Tool/Pro).

How to build for iOS, watchOS, macOS — architecture patterns, SwiftData, Swift concurrency, CI/CD, TestFlight.

macOS UI patterns — AppKit/SwiftUI, menu bar, window chrome, materials, Liquid Glass, notarization.

Use when planning or implementing UI with IBR in Codex — compact routing skill.

Use when validating iOS, watchOS, macOS UI with IBR in Codex.

Compact IBR guidance for Codex — Calm Precision, web archetypes, interaction states, mobile, content states, data viz, Mockup Gallery.

Use when scanning, auditing, comparing, or testing UI with IBR in Codex.

Design auditory UI channels — sounds, tones, notifications, sonic logos, voice confirmation, spatial audio.

Audit URLs or images against tagged pattern library, preferences profile, and ui-guidance principles.

Design interactive components — buttons, icons, forms; cross-platform craft with state coverage.

Design charts, graphs, tables, KPIs, sparklines; decision-first titling and ruthless decluttering.

Build design systems by revealed preference — users pick live previews; emits platform-aware DESIGN.md (web/iOS/macOS).

Route design evidence gathering between source-of-truth reads (tokens, palette) and live IBR capture.

Design action feedback — confirmations, button states, loading, success/error states, haptics, sounds.

Design visual hierarchy — title/description/metadata ladders, typography scale, emphasis through size-weight-contrast.

Extract design patterns from screenshots or mockups; maps observable structure to ingestion schema.

Extract design patterns from live URLs via IBR scan; maps DOM and computed styles to ingestion schema.

Build or audit SwiftUI/UIKit iOS apps — HIG essentials, archetype classifier, SF Symbols, Dynamic Type, haptics.

Build or audit native macOS apps — window chrome, toolbars, menu bar, NSVisualEffectView, keyboard-first interaction.

Design animations and transitions — page transitions, hover, sequenced reveal, shimmer, micro-interactions.

Design navigation and wayfinding — tab bars, drawers, breadcrumbs, back stacks, sheets, modals.

Set defaults for token shape (typography, color, touch targets, motion, error UX) or audit against owned-app reference set.

Cross-medium design doctrine applicable to UI, writing, images, docs, data — principle stable across primitives.

Discover or narrow design preferences via mockup-gallery A/B rounds; aggregates picks into preferences profile.

Design for multiple form factors and screen sizes — breakpoints, container queries, density per surface.

Design element state lifecycles — rest, hover, focus, active, selected, disabled, loading; empty/error/success screens.

Mark captures as liked or disliked patterns; cross-references ui-guidance principles followed or violated.

Design token systems shipping across form factors without forking — scale, ladder, condition, composite patterns.

Build or audit web apps — semantic HTML, ARIA, responsive design, forms, WCAG 2.1 AA, keyboard navigation.

Build production PowerPoint decks with a python-pptx primary engine plus an opt-in pptxgenjs polish layer for the cover slide; runs a QA gauntlet (typography, WCAG contrast, drift check) before delivery.

Turn a codebase, workflow, process doc, or org/financial model into an audit-grade diagram (Mermaid, SVG, HTML, or PPTX).

Canonical rule library for Barbara Minto's Pyramid Principle (SCQA, MECE, governing thought) that sibling skills depend on.

Audit existing writing against Pyramid Principle / MECE / SCQA rules and produce ranked, cited findings.

Draft answer-first short-form prose (email, memo, exec summary) under ~500 words using SCQA and a governing-thought key line.

Produce a full nested key-line outline for long-form reports, briefs, and whitepapers before prose drafting.

Produce a slide-by-slide ghost-deck storyline (assertion headlines and key lines) for presentations before slide design.

Build Word (.docx) files to a locked typography spec (Arial 12pt, heading hierarchy, TOC, callouts) via python-docx mechanics.

Draft or rewrite short-form conversational writing (Slack, casual email, chat) in the author's voice.

Canonical style library (punch-then-unpack, em-dash hygiene, register map) underlying the other voice skills.

Owns argument/structure logic for PowerPoint decks (Minto Pyramid, MECE, Duarte, action titles) prior to handoff to pptx-builder.

Pre-ship logic/fact review that flags contradictions, unsupported claims, and overreach with severity-tagged findings.

Draft or rewrite LinkedIn posts/comments in the author's analytical, research-backed voice.

Section architecture and narrative logic for Word documents and long-form reports, prior to handoff to docx-builder.

Draft or rewrite structured professional writing (cover letters, memos, executive emails) in the author's voice.

3-node linear pipeline (retrieve_semantic -> retrieve_graph -> analyze) that does semantic + graph retrieval then a single LLM call to produce a cited analysis (general/SWOT/competitive/trend). Self-labeled 'Research agent' with an 'A-RAG adaptive' docstring, but the implementation is a fixed linear sequence, not dynamic tool-choice.

3-node pipeline (gather_findings -> extract_brief -> generate_outputs) that runs an LLM map-reduce extraction into a StrategyBrief, then fans out to format generators (pptx/docx/email/notes/outline).

Top-level orchestrator (Opus): plans via research-planner, delegates to specialist subagents, tracks progress, enforces Pyramid Principle output and artifact verification

Decomposes research questions into structured task plans before data gathering

Extracts and verifies data from PDFs, websites, spreadsheets, and presentations

Analyzes SEC filings, earnings reports, and financial statements; runs Python calculations

Synthesizes multi-source extracted data into MECE/Pyramid-structured narratives with citations

Produces executive-ready SCQA briefs from synthesis output

Designs process architectures and flowchart visualizations as PowerPoint decks

Designs visual layout/structure for deliverables applying Calm Precision principles

Refines weak/ambiguous research prompts for accuracy and specificity

Monitors execution for scope/quality/source/goal drift against the research plan

Verifies synthesized claims against cited sources; flags unsupported claims and stale data

Scores report quality (completeness, accuracy, structure, depth, actionability) against a 4.0/5.0 threshold

Post-run debrief that diagnoses execution quality and records lessons/memory updates for future runs

Domain assessor for API/REST/GraphQL, auth, and route-handler debugging symptoms.

Coordinates parallel domain-specific assessors (db/frontend/api/performance) when the debugging symptom spans multiple domains.

Domain assessor for database/query/migration/Prisma/PostgreSQL debugging symptoms.

Pressure-tests a proposed fix before it's declared resolved (root cause vs symptom, regressions, evidence).

Domain assessor for React/hooks/rendering/state/hydration debugging symptoms.

Domain assessor for latency/memory/CPU/bottleneck debugging symptoms.

Builds a causal tree (not a linear 5-whys chain) to find true root causes across multiple branches.

7-phase iterative root-cause debugging loop (investigate, hypothesize, fix, verify, score, critique, report), up to 5 iterations.

Memory-first debugging workflow that checks past incidents via the debugger MCP search tool before investigating a bug.

Generates stack-appropriate structured logging/tracing code (optionally OpenTelemetry) with a zero-dependency-first tiered approach.

Runs Playwright/E2E tests inside a Docker devcontainer for isolated, reproducible execution; manages the full container lifecycle (build, run, cleanup). Uses haiku model.

Build, install, and hot-reload Nimbalyst extensions using in-app MCP tools.

Entry point for Nimbalyst's in-app bug-report/feature-request flow; gathers evidence, anonymizes, and posts to GitHub Issues.

Drives Nimbalyst's interactive 'Commit with AI' widget; explicitly NOT for generic commit requests.

Create visual Prisma-format database schema / ER diagrams using Nimbalyst's DataModelLM editor.

Create .mockup.html UX mockups/wireframes for visual planning inside Nimbalyst.

Create/track structured plan documents and work items (bugs/tasks/ideas) via YAML frontmatter in nimbalyst-local/plans/.

Create flowcharts/architecture diagrams/sketches as .excalidraw files; includes an explicit 'stop after one pass, don't thrash' rule.

Lead-agent session driver built on claude-agent-sdk's query(); TeammateManager (2039 lines) spawns, messages, and manages the lifecycle (active/idle/resume) of sub-agent 'teammates' the lead agent creates at runtime.

MCP server + service letting a running agent session create/spawn/inspect/prompt sibling or child agent sessions across providers (Claude, Codex) and worktrees (tools: create_session, spawn_session, get_session_status/result, send_prompt, respond_to_prompt, list_spawned_sessions).

Implement, modify, or update server-side logic, API endpoints, database schemas, and business logic

Perform comprehensive security analysis on code changes, static code scanning, and dependency checks

Handle CI/CD pipelines, container builds, and cloud deployments with rollback capabilities

Maintain, consolidate, and update documentation across repositories

Build, modify, and maintain React/TypeScript UI components with styling and state management

Champion usability for React/TypeScript web apps through heuristic audits and Calm Precision design

Design and review overall architecture, API contracts, and data models for React/TypeScript applications

Coordinate multiple agents for complex tasks and ensure proper delegation across domains

Run automated test suites including Jest, Playwright, and Lighthouse for quality assurance

Specialized agent for architecture decisions, dependency management, and impact analysis. Use when planning significant changes to the tech stack.

Autonomous subagent for investigating architecture issues using NavGator MCP tools. Follows SRE-style read-only investigation before proposing changes.

Reads NavGator's stored graph, decides whether data is stale, runs incremental scan if needed, then dispatches read-only analysis tools and aggregates structured reports.

Resolves external boundary nodes (npm/pip/spm/cargo/go/service/llm/infra) against upstream registries with canonical identity, version, and freshness verdict.

Architectural integrity review of system flow and connections using impact analysis, data flow tracing, and lessons tracking.

Scan project architecture, check health, and monitor staleness using NavGator scan and status tools.

Generate architecture diagrams and export architecture summaries using mermaid diagrams and CLI exports.

Install the plugin, update to latest version, or launch the web dashboard and UI maintenance.

Analyze what's affected by changes and map component connections using impact analysis, connection viewing, and dataflow tracing.

Implement/modify server-side logic, API endpoints, DB schemas, and business logic for the React/TS app; proactive when new data entities or API contracts change.

Security gate run after tests pass, before deploy: static analysis, dependency vulnerability scanning, blocks merges on critical issues.

Owns CI/CD, Docker builds, and cloud deployments (Vercel/Fly.io/AWS), including rollback procedures; runs proactively after code-review approval.

Maintains/consolidates repo docs, prevents doc sprawl, merges LESSONS.md growth into docs, updates changelogs/API guides.

Builds/maintains React/TypeScript UI components, Tailwind styling, Calm Precision design tokens, Storybook docs, accessibility.

Heuristic UX audits, accessibility/WCAG review, proposes Calm Precision token tweaks, drafts BDD test scenarios.

Owns end-to-end architecture and cross-agent coordination: API contracts, data models, tech-stack decisions across frontend/backend/infra.

Runs Jest/Playwright/Lighthouse automated test suites proactively after merges or new test scaffolds, fails fast on regressions.

Coordinates substantial multi-system changes by engaging system-architect and other domain agents for planning and sequencing.

Owns the deck's argument before any layout decision. Turns a fuzzy ask into a Pyramid-shaped ghost deck with governing thought, key line, and action-titled outline with evidence placeholders.

Owns visual + structural quality. Audits the Builder's .pptx against hard-constraints, composition principles, and house-style instances. Returns findings with routing verdicts.

Runs after Strategist and before storyline writing. Gathers and classifies information into a tiered evidence base (proven/directional/gap) that grounds downstream claims.

Owns structure.json → .pptx rendering. Reads Designer's layout decisions, calls python-pptx helpers, runs full QA gauntlet before signaling done.

Owns the visual system. Reads Strategist's ghost deck and auto-layout pipeline. Produces per-slide LayoutDecision objects the Builder consumes. Never calls python-pptx directly.

Build PowerPoint (.pptx) decks with the calm-precision-pptx hybrid model. python-pptx is the primary structural engine; pptxgenjs polish layer optional for cover slides.

Turn any source artifact into a clean, audit-grade diagram with explicit node types, decision branches, and exception paths. Renders to Mermaid, SVG, HTML/interactive, or PowerPoint.

Main production research agent — DeepAgents single-agent flow with built-in write_todos planning, filesystem tools, and task-tool subagent delegation (planner/researcher/analyzer/writer/fact_checker/reviewer/reflector/worker role prompts)

Lead agent decomposes task into worker subtasks, workers execute independently and register artifacts, lead synthesizes from artifact summaries only (telephone-game mitigation, one-level-only enforced)

Evaluator-optimizer loop — writer agent generates content, critic agent scores/verdicts, writer revises until score threshold or max iterations

Reflexion-style loop — same-model agent generates an answer, then self-critiques against a rubric and revises (bounded iterations, stagnation guard)

Runs N sampled agent turns at varied temperature concurrently, then a synthesizer agent merges them into one answer (ensemble voting / hallucination catching)

Classifier turn labels the query, then dispatches to one specialist agent turn scoped to that label

Linear staged agent pipeline (gather -> analyze -> write), each stage consuming the prior stage's output, optionally pinned to different models per stage

Plans (and optionally produces) product marketing video for any software product; dispatches for launch strategies, audience-tailored content plans, and production.

Transforms raw screen recordings into polished demo clips with spotlight focus, captions, and optional speed adjustment.

Tunes video craft — pacing, color, typography, sound, and emotion arc — and translates design choices into Spectra render parameters.

Connects to and captures screenshots/video from running web, macOS, and iOS/watchOS simulator applications for marketing and documentation.

Plans product marketing content tailored to product type, audience, and funnel stage; routes to Spectra capture/polish tools for production.

LLM-driven sequential navigation through UI flows with capture; used by host agents (Claude Code, Codex) to plan from snapshots and drive Spectra execution.

Design, evaluate, or rebuild agentic harnesses — tool use, permissions, workflow state, memory, evals, observability, multi-agent, framework selection. Activates on harness-gap symptoms too.

Multi-node orchestrator for schedule optimization, priority triage, time-block planning, decision logging, and follow-up tracking with role-based task assignment.

Document analysis and knowledge management agent with embeddings, retrieval, and local LLM summarization for meetings, documents, and research materials.

Planning agent that constructs structured outlines, generates plan sections, and builds implementation roadmaps using local LLMs.

Meeting analysis agent that extracts actions, decisions, and notes from meeting transcripts with semantic classification.

Canonical rule library for Pyramid Principle: SCQA, MECE, deductive/inductive logic, vertical/horizontal relationships, governing thought structure.

Drafts answer-first short-form writing (emails, memos, exec summaries, one-pagers, BLUF notes) using Pyramid Principle structure.

Structures long-form professional documents (reports, briefs, proposals, whitepapers) with full nested pyramid outlines before prose.

Builds presentation storylines and slide decks with assertion-based headlines and logical flow following Pyramid Principle.

Audits existing writing against Pyramid Principle rules; produces structured violation findings and ranked fixes with source citations.

Orchestrates LLM requests between on-device (Apple Foundation Models) and cloud (Groq) providers with routing, caching, and state management for AI features

Orchestrates plan critique generation by combining deterministic PlanCoachEngine logic with LLM inference and safety validation

Orchestrates weekly review generation via AIInsightService with weekly caching, permission checks, and prompt construction

Routes task decomposition between Apple on-device Foundation Models and cloud providers for parsing raw text into structured tasks

Deep investigation agent that reads all source files in a Replit project, maps the full dependency graph, identifies hidden Replit dependencies, and produces a comprehensive migration readiness report.

Use to "scan this Replit app", "analyze for migration", "check Replit dependencies", or assess migration readiness; auto-triggers when a .replit file is present.

Use when the user asks to "migrate to web", "deploy to Vercel", "move to Cloudflare", "get off Replit", or convert a Replit app to standalone/self-hosted production.

Use when the user asks to "make this an iOS app", "convert to native", "port to Swift", "SwiftUI version", or migrate a Replit app to native iOS/macOS.

Executes the agent-doe-engine autoresearch loop: generates one hypothesis per iteration, makes an atomic scoped change, measures every objective, and keeps/reverts by aggregate score until convergence or budget exhaustion.

Read-only adversarial reviewer that checks kept optimization commits for Goodhart violations, metric-gaming, safety removal, scope violations, and unvalidated-metric winners.

Orchestrates DOE (Design of Experiments) and autoresearch optimization: plans/validates factors, sets multi-objective scoring (scalarize/desirability/pareto), runs the trial matrix or single-factor loop, and reviews results for overfitting.

Use BEFORE writing API config, env setup, auth, LLM client init, or debugging external services. Returns authoritative source URLs, latest version, and deprecation warnings. Triggers on any named library/API/tool.

Contract for external plugins (build-loop, debugger, research) to consult api-registry during API setup or debug. Reads ~/.api-registry/registry.db; exits silently if absent.

Use when the user asks how a library/API/tool works, requests docs for a named service, or asks about current models/versions/endpoints. Routes via api-registry to Context7 or WebFetch.

Reviews a product, UI, workflow, or feature from one assigned persona perspective with evidence and measurement.

Selects task-specific persona perspectives, checks execution readiness, defines measurements, launches review passes, and synthesizes findings.

Turn user requests into focused persona panels for reviewing products, UIs, workflows, and features with task-specific perspectives, measurement, and evidence-based findings.

Use when working in a repository that uses Rally/Agent Rally Point for cross-agent coordination, especially at session start, before editing files, when deciding what to do next, handing work to another agent, recording facts/artifacts/decisions, resolving blockers, or coordinating with other coding agents through the `rally` CLI.

Ultra-light per-task quality loop for Rally Flow / dynamic-workflows fan-out. Wrap each fanned-out task in assess → plan → execute → mini-judge to raise accuracy, with zero tools or scripts.

Use when fanning out work across multiple agents, running a dynamic workflow, coordinating parallel subagents, or splitting a workstream across hosts, terminals, or machines through Agent Rally Point.

Modifies/creates/fixes UI (HTML/CSS/frontend-backend integration), ensures data rendering and design-system consistency; invoked by the Chief orchestrator or directly for UI work.

Read-only Supabase/Postgres investigation for atomize-ai — pipeline freshness sweep and coverage-gap analysis (freshness.py, coverage_gap.py) used to diagnose stale/empty data before fixing.

Multi-step intelligent-search pipeline — classifyIntent → planRetrieval → fan-out retrieval (vector+KG) → rerank → quality-guard (reformulate-and-retry on low relevance) → synthesize → numeric verification → normalize; feature-flagged, falls back to legacy search handler.

Conversational multi-step router: detects specialty/intent, generates and adapts intake surveys, classifies via Stage 0, then dispatches to the Decision Engine or Recommendation Engine and streams the Groq completion back to the user

Deterministic multi-stage decision pipeline (weights/AHP -> constraints -> weighting -> outranking -> ranking -> feasibility -> scaffold), with LLM calls at Stages 1, 5, 6 via Groq

Chains pain-path classification -> library retrieval -> candidate task generation -> 9-criteria scoring -> promotion (or the newer runWorkflowV2 decompose/score/lynchpin/horizon pipeline) to produce an AiTaskRecommendation

Agent for deep analysis of session context and snapshot comparison. Use for detailed context review, decision timelines, and coverage analysis.

Restores session via bookmark snapshots when user asks to continue from last session, restore context, or pick up where they left off.

Frontend UI specialist handling HTML/CSS/TypeScript UI implementation, responsive design, accessibility, and frontend-backend integration.

Multi-strategy content scraping orchestrator supporting RSS discovery, sitemap parsing, HTML scraping with fallback logic.

Turns a described workflow into a generated loop pack (loop.yaml, rubric.md, report template, validators, README.md).

Generates declarative focused-loop specs, presets, validators, and skill-chain plans for any host coding agent.

Multi-step orchestrator that runs guided-conversation intake for a product spec: routes to a method (jtbd/qfd/pugh/agent) via a Haiku sub-call, scores unknowns 0-15 to decide ask-vs-infer, generates the next question or safe-default assumptions, then finalizes into a rendered spec draft.

Handles UI/UX implementation (HTML/CSS/JS/TS), responsive layouts, accessibility, and frontend-backend data integration.

Build Word (.docx) files with locked typography, heading hierarchy (16/14/12pt), 1" margins, table header shading, callout boxes, auto-TOC. Pair with doc-structure for section planning.

Extract blog and news content from any website via RSS, sitemap, or HTML scraping with LLM-ready output.

Design, evaluate, or rebuild agentic harnesses — tool use, permissions, workflow state, memory, evals, observability, multi-agent, framework selection.

Capture PowerPoint .pptx visual style (theme colors, fonts, slide size, masters, layouts) into JSON spec, then generate new .pptx from Markdown/JSON content reusing that style; includes native chart support via R or python-pptx fallback.

Classify, diagnose, rewrite, and score prompts calibrated to model tier and deployment context.

Structured research methodology (5-phase general research, collection, synthesis, quantitative/database analysis, active-project ingestion) producing cited, verified findings persisted to ~/dev/research/.

Create scratch-first HTML mockups, rate mockups in gallery, check selections, align mockups to routes/screens, and implement approved designs from the mockup gallery.

Workshop assistant for producing threat-model artifacts — walks STRIDE decomposition, asset/actor enumeration, data-flow description, OWASP LLM/Agentic/ATLAS/NIST cross-mapping, mitigations, residual risk, decision log for agentic systems and risk-surface changes.