Autonomous

Autonomous Operation

You have been given a problem to solve independently. Follow this protocol. It uses the full Triptych v2 infrastructure — research state, verification, and cross-verification.

The Loop

1. Accept problem and initialize

python -c "
import sys; sys.path.insert(0, '.')
from core.research import init_research
init_research('STATE THE GOAL HERE')
"

Set the goal to a clear statement of what needs to be shown, found, derived, or understood.

2. Exploration phase

Survey approaches before committing to one:

• What methods are available? (Lagrangian, Newtonian, energy methods, etc.)
• What tools are relevant? (SymPy, numerical computation, dimensional analysis)
• What are the key assumptions?
• What prior results or known solutions exist?

Update research state as you explore:

python -c "
import sys; sys.path.insert(0, '.')
from core.research import update_state
update_state('questions', '- What approach should we use?\n- What assumptions are needed?', 'workspace/research')
update_state('assumptions', '- Small angle approximation\n- No friction', 'workspace/research')
"

No claims emitted during exploration. No formal verification. You're forming a strategy.

3. Crystallize

State a clear research question or hypothesis. Update the goal if needed:

python -c "
import sys; sys.path.insert(0, '.')
from core.research import update_state
update_state('goal', 'Derive the equation of motion for a simple pendulum using the Lagrangian method', 'workspace/research')
"

4. Formalization phase — derive step by step

Work through the problem. At each significant step, emit a claim:

python -c "
import sys; sys.path.insert(0, '.')
from core.verify import emit_claim
emit_claim('T = (1/2)ml^2 * theta_dot^2', 'kinetic energy in polar coordinates', depends=['A1'], research_dir='workspace/research')
"

When to emit a claim: new equations, changes in approach, approximations, key intermediate results. Not every mechanical step — use judgment per PRD.

Show your work in the display panel using display addons.

5. Between each step — check verification log

python -c "
import sys; sys.path.insert(0, '.')
from core.verify import read_verification_results
results = read_verification_results('workspace/research')
for r in results:
    print(f'{r[\"type\"]}: {r.get(\"status\", r.get(\"kind\", \"\"))} — {r.get(\"detail\", r.get(\"content\", \"\"))}')
"

• If flagged: address the issue before continuing. Update attempts if the approach failed.
• If clear: proceed to next step.
• Clear results after reading: from core.verify import clear_results; clear_results('workspace/research')

6. At milestones — cross-verification

When you've established a significant result (not every claim, but key conclusions):

Spawn the cross-verifier agent:

Agent(subagent_type="cross-verifier", prompt="Problem: [problem statement]. Claimed result: [your result]. Verify by solving via a different method.")

The cross-verifier independently re-derives the result. If results match, confidence is high. If they diverge, investigate.

7. When done — final verification pass

• Start the verifier loop if it isn't already running: /loop 60s /verifier. It drains the claim queue via isolated subagents — don't spawn verifiers yourself.
• Wait for read_verification_results() to return empty (all claims have results).
• Update research state with final established results
• Update the dependency graph
• Show final results in the display panel with show_research()
• Stop the loop: /loop stop

python -c "
import sys; sys.path.insert(0, '.')
from displays.research import show_research
show_research()
"

Verification system architecture

The verifier agent (.claude/agents/verifier.md) receives only the claims and the original problem statement — never your reasoning. This isolation prevents contamination. For each claim, the verifier decides how to verify:

• Symbolic recomputation via CAS (SymPy MCP, Wolfram Alpha MCP)
• Numerical spot-check (plug in concrete values)
• Dimensional analysis
• Limiting case evaluation
• Comparison against known results
• Independent reasoning

You don't spawn the verifier subagent directly. Instead, start the verifier loop once formal work begins:

/loop 60s /verifier

The /verifier skill drains the queue one claim per tick via isolated subagents. Results land in workspace/research/verification.log and flow to research state automatically via process_result():

• verified → established results + dependency graph
• failed → attempts section only (not in graph)
• uncertain → open threads + graph with "unverified" status

If a verification agent fails to return results within a reasonable time, log the failure and proceed with claims marked unverified. Do not block indefinitely on verification.

Research state reference

Two files in workspace/research/, each doing what it's best at:

• state.md — human-readable narrative with seven sections: Goal, Questions, Assumptions, Attempts, Established Results, Open Threads, Next Step
• deps.json — machine-parseable dependency graph (nodes + edges with status)

Core operations (core/research.py):

import sys; sys.path.insert(0, '.')
from core.research import (
    init_research, read_state, update_state,
    add_attempt, add_established, add_observed,
    add_node, add_edge, invalidate, get_downstream, get_graph,
)

• add_established("R1", "L = T - V", ["A1", "A2"]) — formally verified (requires a verification.log entry); writes to state.md and deps.json with status verified
• add_observed("R2", "accuracy = 99.44%", ["A1"]) — empirically observed (measurements, readings, literature consensus); status observed, shown distinctly in the research display
• invalidate("A1") — propagates downstream, flagging all dependent results as "needs-reverification"
• get_downstream("A1") — returns all transitive dependents

Visualize: from displays.research import show_research; show_research()

Who verifies whom

Who's working	Who verifies
AI (autonomous or collaborative)	Verifier agent checks AI claims
Human	AI watcher checks human's workspace
Both	Both verification paths run

Key principles

• Don't pause for confirmation mid-work. Log everything, keep going.
• Verification at every step. Autonomous operation without verification is unsupervised hallucination.
• Maintain research state throughout. The human can check in anytime and see progress.
• If stuck, log it and try something else. Update attempts, don't loop forever.
• If the verifier flags everything as uncertain, proceed with uncertainty logged. Don't loop trying to achieve perfect certainty.

What the human sees

• Display panel: current work, derivations, plots
• Research state: full trajectory from exploration to verified answer
• Dependency graph: the logical structure of the derivation
• Verification log: what was checked, what passed, what failed