Crucible — Task Backlog

Deferred / planned work, captured so nothing is lost.

In progress

• Git-like edit version control (history / revert / branch) with per-tensor delta snapshots
• Clone-before-edit (pristine backup + active copy)
• GUI changelog view (history timeline, revert/clone buttons)

Understandable visualization (4 of 4 DONE)

• Live activation heatmap (token × layer)
• Plain-language feature cards (auto-named mechanism + trigger/output/location)
• Causal flow graph (input concepts → carrier components → output tokens)
• Before/after behavior diff (multi-probe results assessment)

Modification styles

• Single-layer / multi-layer banded ablation
• Reversible runtime ablation (forward hooks, nondestructive)
• In-place weight editing (no copy, model stays live)
• Feature insertion mechanism (additive runtime steering)
• Insertion auto-tuner (coherence-guarded search; FOUND a clean additive window — corrects earlier "no window")
• Restoration via remove-the-suppressor (target-prompt suppressor direction, proven removal)

crucible CLI — full Claude-Code parity

• Functional CLI (agent loop, remote-aware --endpoint, slash commands)
• Persistent sessions
• Settings file (~/.crucible/settings.json)
• MCP server support (stdio client, tool wrapping, /mcp command)
• Full slash-command set + status line + config

Remote orchestration

• Remote-aware endpoints (--endpoint / CRUCIBLE_ENDPOINT)
• [~] Remote orchestration plumbing done (CORS + configurable GUI/CLI node URL); live 1.5TB run runs on a high-RAM inference node

BYO-AI — bring your own backend

• Service auto-detection (Crucible/Ollama/llama.cpp/vLLM/ComfyUI) on localhost + named remotes
• Capability badges + per-service notes (full / chat-only / no-chat) in the Models tab
• Drive the forge in "chat (direct)" mode — browser → service /v1, works on the static page
• Drive the forge in "+ tools (via Crucible)" mode — register endpoint, full agent tool-loop over it
• POST /api/models/connect — register an OpenAI-compatible endpoint as a first-class model
• Token-level streaming on the tool-loop path (assistant_delta SSE; fragmented tool-calls reassembled)
• Token-level streaming on the direct-chat path (browser → service SSE, static-page friendly)
• Stop/cancel an in-flight run (AbortController through runAgent + chatDirectStream; Stop button)
• Per-service model picker on BYO cards (when a service exposes several; persisted, used by both modes)
• Demo-mode simulated token streaming (static page shows the animation + caret with no backend)
• CORS / OLLAMA_ORIGINS + write-permission docs

Benchmarks

• lm-eval integration (canonical suite, capability retention)
• loglikelihood MC tasks via HF backend (MMLU/ARC/HellaSwag)

Full AI dev & analysis pipeline (all DONE)

• Causal interpretability: activation patching / causal trace (proves WHERE, not just correlates)
• Multiple refusal directions (refusal isn't rank-1) + CAA/RepE concept steering
• Sparse autoencoders — monosemantic feature dictionaries (+ token labels)
• Tuned lens — faithful per-layer decodability curve
• Plain-language surgical diagnosis (where/how-we-know/target/repair/risk; translatable)
• Piecemeal alignment: decompose into components → pick → preview remove/add
• Un-alignment AND re-alignment — in-place OR portable LoRA (exact inverse; reversible)
• Direct GGUF abliteration (edit the quantized model in place; F16/BF16/F32/Q8_0)
• Quantization analysis (per-tensor fidelity/compression for a target type)
• Retraining pipeline — real gradient LoRA SFT (peft), saved + auto-registered as a variant
• Eval rigor: safety suites (XSTest/HarmBench/AdvBench/StrongREJECT), LLM-judge, refusal classifier, pass@k, contamination

Serving, models, ops (all DONE)

• Runtime manager: load/stop, multi-active round-robin, tok/s speed test; llama.cpp OR vLLM
• Online/offline autodetection; health-checked routing; GGUF detected by magic bytes
• Import from Ollama (grab the raw GGUF blobs → editable/retrainable/servable)
• Crucible as an OpenAI-compatible provider/gateway (chosen/preferred/nearest routing)
• Tool-calling for EVERY backing model (native relay + ReAct bridge + name coercion)
• Interactive 'ask' tool approval; server-side cancellation; live + pre-flight tok/s
• Crucible MCP server — drive/evolve the whole system from any agent

Harness (all DONE)

• Full skillset: read/write/edit/multi_edit/list_dir/grep/glob/bash/web_fetch/web_search/todo_write
• Hybrid tool loop (native + text ReAct) so tools work with any model, no toggle

Roadmap — next phase (from design brainstorms)

Legend: [x] shipped · [~] partial/foundation laid · [ ] open

Multimodality — I/O across audio, voice, video, image, document

• Provider passthrough of multimodal content (image_url / input_audio) to VLM/audio backing models
• Media endpoints: /v1/audio/transcriptions (STT), /v1/audio/speech (TTS), /v1/images/generations, /v1/embeddings
• [~] Route image/video generation to the already-detected ComfyUI backend (generate_image tool + routes)
• Media tools for the agent + /api/tools (transcribe, speak, generate_image, describe_image)
• Document I/O (parse PDFs/docs in, render documents out)
• Mixed / asymmetric / changing input-output structures (per-request modality shapes)

Multi-model systems / subsystems (model graphs)

• Model-graph engine: compose routed model calls into pipelines/DAGs (e.g. STT -> LLM -> TTS; image -> VLM -> text -> image)
• Cascades (cheap -> escalate) and verifier / judge ensembles as graph nodes
• Per-subsystem config + versioning; asymmetric modality edges between stages
• [~] Mixture-of-models by task (task_router) — DONE as the node selector; graph edges TODO

Swarm / fractal AI (orchestration primitives)

• Subagents: /api/agent/swarm runs+merges sub-agents
• Recursive agent trees (agents spawning agents) — 'fractal': spawn_agent tool, bounded by a shared depth+total fork-bomb budget; wired into /api/agent/run and the swarm
• Task/model sharding across the distributed runtime (multi-node + gateway substrate exists)
• Coordination/merge strategies (map-reduce, tournament, debate, blackboard)

Component-aware / multimodal anticensorship

• Composition map: identify parts (vision/audio encoder, connector, language model, moderation head, vocoder) + prescribe per-part technique
• Per-part abliteration execution (scope edits to a named part) — abliterate_gguf part= filter + part_writing_matrices; composition reports executable_now vs needs_probing
• Modality refusal directions (image/audio embedding space), not just text
• Cross-modal connector re-alignment (let filtered concepts pass the projection)
• Moderation-head DETACH (disable a bolted-on classifier rather than cut a direction) — detach_part_gguf zeros the classifier tensors; /api/abliteration/detach
• Per-part versioning + lineage (each part independently versionable/revertable)
• Modality-specific in/out censorship diagnosis (refuses-to-describe-image, refuses-audio, etc.)

Model intelligence / routing

• Task-aware routing (classify -> route; user level fast/balanced/max); /api/route + auto:task
• [~] Model-based task classifier (replace heuristics); eval-driven selection using measured safety/capability
• Hand-labeled model tags/tiers in the registry (override inferred tags)

Integration / exposure

• MCP server (crucible-mcp) + MCP client (bidirectional)
• Embeddable tool exposers: GET /api/tools catalog + POST /api/tools/invoke
• Tool-manifest export + JS/Python client SDKs for embedding in other apps
• Richer MCP server surface (expose more of the pipeline as MCP tools)
• Slash-command sets importable from other harnesses/models (Claude Code / OpenCode packs)

Context & memory

• Context compaction (summarize old turns when the window fills)
• Persistent project memory (CLAUDE.md-style) surfaced to the agent
• Web-forge session persistence (history survives reload; CLI already has sessions)

Harness parity (Claude Code / OpenCode)

• Plan mode (read-only 'propose before acting')
• File-edit checkpointing / undo (revert the agent's file changes)
• Agent hooks (pre/post-tool)
• Slash commands in the web GUI (CLI has them)
• LSP integration; usage/cost/token accounting; vision input; IDE extension

Platform / infra (worth adding)

• Prompt/response caching; budget/cost caps
• RAG / embeddings store
• Observability / tracing of agent + graph runs
• Plugin system; batch/queue processing; streaming tool results