// CALLSIGN — RASPUTIN.WARMIND.001 //

RASPUTIN

Autonomous Multi-Agent Build Warmind. Spec In · Working App Out · No Operator Required.
Status · Operational v1.1 · Certified 7-Agent Hierarchy Self-Repairing Architecture · Public Mechanism · Classified
// TACTICAL OVERVIEW

What it is. What it does. By the numbers.

// MODEL · WARMIND.CORE.001
TRANSMITTING · LIVE
// PROJECTION · CIPHER-7
// ROTATION · 0.15 RAD/S
7
// Specialized Agents
Tiered models · Strict hierarchy
11
// Features Built · VoxAlign
Public on GitHub
360/364
// Tests Green
98.9% pass rate
v1.1
// Operational
Certified 2026-03-21
Capability Matrix · 8 of 8 Online
  • Spec → Working Application · No operator inside the loop
  • Sandboxed Parallel Build · Backend + Frontend in disjoint write paths
  • Adversarial QA · Returns PASS / FAIL / INCONCLUSIVE with evidence
  • Self-Repair on Capability Gaps · BLOCKED → research → retry
  • Persistent Learning · TF-IDF lessons injected into next build
  • Full Audit Trail · Replay-capable, evidence-grade chain
  • Crash Recovery · Atomic state, mid-cycle reconciliation
  • Threat-Score Sentinel · Halt on severe guardrail violation
// THE SEVEN · COUNCIL

Seven specialized minds. Each with one job.

Every agent is a focused Claude instance with a fixed role, sandboxed scope, and tier-based authority. Specialists never speak to each other — routing flows only through Cortex. Authority escalates only to Sentinel. Cerberus is invisible; it watches everything.

// AGENT.001
TIER 1
CORTEX
Central Intelligence · Orchestrator

Routes every signal between agents. Owns the feature lifecycle and decides which phase comes next. Reads state; dispatches tasks; receives status. Never writes code.

// SEES · all messages   // MODEL · sonnet
// AGENT.002
TIER 0
SENTINEL
Authority Gate · Approver

The sole approver. Every proposal from Cortex ascends here. Returns approve, defer, or reject with reasoning and conditions. Cannot self-approve, cannot write code.

// SEES · proposals   // MODEL · haiku
// AGENT.003
TIER 2
ARCHITECT
Backend Builder · Smith

Builds backend systems. Endpoints, databases, server logic. Sandboxed to backend paths only — pre-write gates block any attempt to touch the frontend.

// SCOPE · backend/ only   // MODEL · sonnet
// AGENT.004
TIER 2
ENGINEER
Frontend Builder · Weaver

Builds the visible surface. Components, accessibility, responsive layout, client state. Sandboxed to frontend paths; cannot break the API contract Architect built.

// SCOPE · frontend/ only   // MODEL · sonnet
// AGENT.005
TIER 2
STYLIST
Research · Feasibility Seer

Investigates technical approaches before commitment. Returns confidence (high/medium/low), cited findings, identified risks, and at minimum two alternative paths with tradeoffs.

// OUTPUT · feasibility report   // MODEL · haiku
// AGENT.006
TIER 3
ANALYST
QA Validator · Adversary

Tests every acceptance criterion. Runs the actual test suite, parses results, returns pass / fail / inconclusive with per-criterion evidence. Adversarial — never accepts unproven claims.

// OUTPUT · verdict + evidence   // MODEL · haiku
// AGENT.007
SENTINEL
CERBERUS
Silent Watcher · Threat Score

Invisible to the other six. Scores threats per agent on every guardrail violation. Investigates anomalies, throttles when concerned, halts the system when severe violations stack.

// VISIBILITY · hidden   // MODEL · haiku
// SECTION 01 / DOSSIER

An autonomous build system that delivers shipped applications from a feature spec.

Rasputin is a multi-agent build system that takes a structured feature specification, processes it through a council of seven specialized agents in strict hierarchy, and outputs a working application. Backend code, frontend code, tests, audit logs. No human operator inside the loop.

It runs unattended. The launcher spawns each agent as a separate watcher daemon with its own polling interval, model tier, and message inbox. The orchestrator routes proposals through an authority gate, dispatches sandboxed build tasks in parallel, validates output adversarially against acceptance criteria, and self-repairs through capability-gap research when specialists report blocked. Every inter-agent message is archived. Every guardrail violation is scored.

The system has been used to build one publicly verifiable production app and one internally certified one, plus the supporting infrastructure to operate continuously through the night without supervision.

// On Disclosure — The architecture is public. The mechanism — exact agent prompts, decision-matrix routing logic, guardrail algorithms, working-memory schema, self-modification protocol — is intentionally not published. This page documents what Rasputin does and has done. It does not document how.
// SECTION 02 / OPERATIONAL METRICS

Verified output. Six months of production behavior.

Numbers below are drawn from two builds: VoxAlign (publicly verifiable; source on GitHub) and ChronoLog (internally certified; release report is self-attested). Disclosure on each is in Section 04.

7
// Specialized Agents
Tiered models, strict hierarchy
14
// Features Delivered
11 VoxAlign · 3 ChronoLog
360/364
// Backend Tests Green
VoxAlign · 98.9% pass rate
26/26
// Cert Tests Passed
ChronoLog · 100%
22/22
// Acceptance Criteria
ChronoLog cert run
6,666
// LOC Generated
VoxAlign backend (excl. deps)
90
// System Integrity Checks
selfcheck.sh, --fix repair
0
// Agent Violations
ChronoLog cert run
74
// Inter-Agent Messages
VoxAlign F-001 build
2.3hr
// Wall-Clock Build Time
VoxAlign F-001, autonomous
3
// Self-Repair Cycles
F-001 to convergence
6+1
// Guardrail Layers
Sandbox · Schema · Type · Token
// SECTION 03 / COMMAND HIERARCHY

Seven specialists. Four tiers. No cross-talk.

Specialists communicate only with the orchestrator. The orchestrator escalates only to the authority gate. A silent security agent monitors threat scores across all communications. The hierarchy is enforced by code, not convention — message routing is validated at dispatch.

Tier 0
Authority Gate
Tier 1
Orchestrator (routes all)
Tier 2
Backend Builder
Frontend Builder
Research
Tier 3
Adversarial QA
Sentinel
Silent Security · Threat Scoring

Roles, sandboxing, model assignment per agent, message protocol, guardrail enforcement layers, and the working-memory mutation contract are documented internally. The capability matrix below reflects what the system provides, not how it provides it.

CAP · 01
Spec → Working Application
Structured feature specs become deployed code. Backend, frontend, tests. End-to-end without operator intervention inside the loop.
CAP · 02
Sandboxed Parallel Build
Backend and frontend agents build in parallel under disjoint write paths. Cross-domain leakage blocked at the dispatch layer, not by convention.
CAP · 03
Adversarial Validation
QA agent tests every acceptance criterion with evidence requirements. Returns PASS, FAIL, INCONCLUSIVE — never accepts unproven claims.
CAP · 04
Self-Repair on Capability Gaps
When a specialist reports blocked, the orchestrator routes the blocker for research, returns alternative paths, and retries the original task with the new capability.
CAP · 05
Persistent Learning
Every defect cycle records a lesson. Subsequent builds retrieve relevant lessons via TF-IDF index and inject them into agent prompts before any work begins.
CAP · 06
Full Audit Trail
Every inter-agent message is archived with timestamps, urgency, payload, and parent reference. Replay-capable. Investigation-grade evidence chain.
CAP · 07
Crash Recovery
State persistence is atomic. Mid-cycle crashes are detected on next start; the system reconciles to the lifecycle authority and resumes from the last completed phase.
CAP · 08
Threat-Score Sentinel
A silent monitor scores every agent on guardrail violations. Tier escalation triggers throttling; severe violations halt the system before damage propagates.
// SECTION 04 / FIELD EVIDENCE — VOXALIGN

Public proof: VoxAlign was built autonomously over a 31-hour run.

VoxAlign is a singer-aware pitch correction tool — CREPE-based pitch detection, DTW reference alignment, PSOLA + WORLD vocoder. The full source code is public. It was built end-to-end by Rasputin's agents starting 2026-03-20. The build log is preserved.

↗
Source · github.com/ashsiwakoti/voxalign Public repo. Backend (FastAPI · CREPE · librosa) · Frontend (React · TypeScript) · 360/364 backend tests green
Open

Selected output, by the numbers:

11
// Features Delivered
F-001 through F-011
40
// Backend Test Files
routes, F005–F011 suites
72
// Frontend Source Files
.tsx · .ts · React
2,275
// LOC Single Module
routes.py — generated

Selected entries from the build report (auto-generated by the audit subsystem during the run):

# BUILD REPORT — F-001 (Audio Upload & Preprocessing)
# Generated by SCRIBE @ 2026-03-20T05:29:29Z
# Window: 2026-03-20T03:10:24Z → 2026-03-20T05:29:28Z (2h 19m)
# Total messages: 74

04:42:32 SENTINEL → CORTEX  DIRECTIVE U5
   "KICKSTART: Build VoxAlign — AI-powered vocal pitch correction.
    Begin with P0 features."

04:55:59 ARCHITECT → CORTEX STATUS  U3
   "Implemented Audio Upload & Preprocessing backend with
    POST /api/sessions endpoint..."

05:00:07 ANALYST → CORTEX  VERDICT  U3   FAIL
   "Code implementation appears correct but test suite cannot run.
    Architect claims tests pass but execution fails."

05:04:46 ARCHITECT → CORTEX STATUS  U3
   "Fixed 3 defects in POST /api/sessions endpoint (F-001).
    All acceptance criteria covered."

05:08:39 ANALYST → CORTEX  VERDICT  U3   FAIL

05:17:19 ARCHITECT → CORTEX STATUS  U3
   "Fixed test infrastructure — dependencies properly installed.
    28/29 tests passing."

05:20:34 ARCHITECT → CORTEX STATUS  U3
   "All 29 tests passing."

05:23:20 ANALYST → CORTEX  VERDICT  U3   PASS
   "Feature F-001 acceptance criteria fully met.
    Database injection fix works correctly."

05:24:39 ANALYST → CORTEX  VERDICT  U3   PASS
   "Feature F-001 passes all acceptance criteria.
    Test suite: 13/13 passed (100%)."

This trace shows the system catching its own failure mid-build. The QA agent rejected the architect's first two completion claims with evidence ("test suite cannot run"). The architect then routed to debug the test infrastructure itself, fixed dependencies, then resumed feature work. No operator intervened.

The orchestrator's audit trail also captured a self-diagnosed root-cause analysis from a later commit:

"Record F-003 root cause: crepe import blocks pytest, not fastdtw." — Auto-generated commit message · 2026-03-21

The system independently identified that the CREPE library's import was the test blocker, not the fastdtw dependency it had originally suspected.

// SECTION 05 / DISCLOSURES

What's verifiable vs. what's self-attested.

Building credibility requires being honest about which claims have external proof and which are internal records. This section is the audit-grade version of the metrics.

// VOXALIGN — Externally Verifiable — Source code public on GitHub (ashsiwakoti/voxalign). Backend test files, frontend source, package configs all visible. Test counts (40 backend test files, 360/364 passing) are independently re-runnable. Build report timestamps cross-reference with git commit history. This is the proof.
// CHRONOLOG — Self-Attested — Internal certification report (CERT-2026-03-22-001) records 3 features, 22/22 criteria passed, 26/26 tests passed, 0 agent violations. The cert report is real and reproducible from the audit trail. However, the actual generated backend artifacts were not retained in the public output directory after the run completed. Treat as internal evidence, not external proof.
// V1.1 CERTIFICATION — The "v1.1 certified" status is internal attestation by the system's selfcheck and certification subsystems. It is not third-party validation. The certification bundle (1,200-line FULL_BUNDLE.md, 462-entry telemetry.jsonl, violation logs, feature traces) is reproducible from the audit trail but not externally audited.
// SELF-REPAIR LOOP — The capability-gap protocol (BLOCKED → research → 2+ alternatives → retry) is documented in the orchestrator's decision matrix and demonstrated working in the VoxAlign build trace. The fully automated re-routing logic is partial — orchestrator action is required to dispatch the research task; the loop is protocol-driven, not zero-touch automatic.
// FIRST-SHOT ACCURACY — Per the VoxAlign F-001 trace, the system needed 3 attempts (FAIL → fix → FAIL → fix → PASS) to converge. Most non-trivial features are expected to take 1–3 defect cycles. Pure first-shot accuracy on complex features sits in the 30–50% range; eventually-passes accuracy after self-repair is in the 85–95% range. The system is engineered to converge, not to be right first.
// SECTION 06 / STATUS & SUCCESSION

Operational. Phase 5 paused. Descendant in development.

Rasputin v1.1 is the current operational version. Phase 4 (persistent learning, test runner, schema generator, dashboard chat, guardrails dashboard) is complete. Phase 5 (self-modification protocol, multi-project parallelism, supervisor orchestrator) is on deck but paused pending hardware refresh.

A descendant project — Oraborus — distills Rasputin's discipline patterns into a Claude skill suite for desktop fast-mode feature creation. Different runtime; same agent council. Case study →

v1.1
// Current Version
Certified 2026-03-21
4/6
// Phases Complete
Self-mod & multi-project pending
75%
// Captured by Oraborus
Skill-based descendant

// Mechanism · Classified

Architecture documented. Decision-matrix routing logic, agent role prompts, guardrail algorithms, working-memory schema, message protocol, atomic-write patterns, self-modification flow, threat-score formulas — all retained internally. Inquiries route through contact.

◆ AS · OPERATOR ◆