Onboarding

Asgard

26 cards ~ 3.3 h Foundational

Foundational walk through the asgard project. Read top to bottom if you're new; no prior context assumed.

  1. asgard beginner 5 min

    ASGARD Corpus Map: CORPUS_INDEX.yaml and the Six Sections

    Use when: orienting in the asgard-codes repo for the first time; deciding which top-level section owns a file you need to find; confirming the file-naming convention before adding a doc

  2. asgard beginner 6 min

    Two Peer Content Agents: Yáo and Jazz on Shared Infra

    Use when: understanding why there are two agent subsystems in asgard-codes; deciding which agent (Yáo or Jazz) owns a given content flow; locating the shared substrate both agents build on

  3. asgard beginner 5 min

    Yáo Mandate: The Social-Media Scrutiny Layer

    Use when: explaining what Yáo is (and is not) allowed to do; deciding whether a marketing draft should be routed through Yáo before it ships; onboarding to the two-content-agent split (Yáo social vs jazz educator)

  4. asgard intermediate 7 min

    Yáo's Six Operating Principles

    Use when: reconstructing Yáo's methodology in order, not just its outputs; understanding why arc-state is read before the lexicon and anti-patterns; auditing whether a Yáo review actually applied all six principles

  5. asgard intermediate 6 min

    Yáo's Three Tests: Deadpan, Algorithmic-Shape, Audience-Cast

    Use when: judging a single caption candidate against Devarno's voice; explaining why a grammatically-fine caption still fails scrutiny; building a repeatable rubric instead of ad-hoc taste calls

  6. asgard intermediate 8 min

    Yáo's Severity Gates: hard_pass, warn, flag_for_devarno

    Use when: assigning a severity to a caption that trips the anti-pattern catalogue; deciding whether a flagged item is a refusal, a warning, or a human call; auditing the catalogue's rule ids and the override recurrence threshold

  7. asgard intermediate 7 min

    Yáo's Output Envelope + Appended Decision Log

    Use when: structuring a Yáo review so every mandated section is present; understanding why every response appends a decision-log entry; reading the decision_log in arc-state.yaml as training data

  8. asgard intermediate 8 min

    arc-state.yaml: Yáo's Feed-State + Freshness Gate

    Use when: understanding what state Yáo reads before a sequencing decision; reasoning about the staleness gate on feed data; tracing where the canonical arc-state now lives after the abacus move

  9. asgard advanced 10 min

    YAO Suggestion Pipeline: the D-watcher generate-and-gate loop

    Use when: tracing how a git commit becomes a queued content suggestion; debugging why a candidate was refused, capped, or rerouted; extending the pipeline with a new gate or stage

  10. asgard intermediate 8 min

    YAO Agent Tools: seven grounded lookups and a terminal scrutiny emit

    Use when: wiring the anthropic-sdk invoker's tool-use loop for YAO generation; adding or auditing a grounding tool the drafting LLM can call; understanding what terminates the bounded tool-use loop

  11. asgard intermediate 8 min

    YAO Scrutiny Validator: the deterministic, LLM-free content gate

    Use when: deciding whether a candidate is refused, softened, or passed; tuning the conformance pre-gate or anti-pattern checks; explaining why scrutiny never calls an LLM

  12. asgard advanced 9 min

    YAO Claim Gate: the PETROVA contract seam and claim verification

    Use when: understanding how unverifiable claims get blocked or capped; reading a target repo's .petrova/contract.yaml claim_index; distinguishing this repo's seam from the external petrova runtime

  13. asgard advanced 10 min

    YAO Autonomous Cycle: hourly approve, ship-sweep, reconcile

    Use when: tracing the unattended drafting-to-shipped conductor; explaining why ship is dry-run and there is no live stage; debugging why an artifact was held instead of approved

  14. asgard intermediate 8 min

    Agent Runner: One Interface, Three LLM Impls

    Use when: choosing an LLM invocation backend for the YAO/JAZZ pipeline; wiring a dry-run agent into a test or CI smoke check; adding a new pluggable agent impl behind createAgent

  15. asgard beginner 4 min

    The AgentResult Envelope

    Use when: parsing the return value of any agent-runner invoker; checking why the model stopped before trusting the text; reading the tool-call audit trail after an anthropic-sdk run

  16. asgard intermediate 7 min

    Versioned CLI Output Envelope

    Use when: consuming a --json emission from any asgard CLI command; adding a new command that must emit machine-checkable output; validating a persisted results/cli-json envelope

  17. asgard intermediate 8 min

    Lifecycle: Forward-Only Stages + Approval Gate

    Use when: moving an artifact between lifecycle stages; deciding whether an artifact is allowed to reach approved; auditing why a transition or approval was rejected

  18. asgard intermediate 6 min

    jazz / dj-educator: Ledger Exhaust to Provenance-Backed Journal

    Use when: explaining what the jazz (dj-educator) subsystem is and why it exists; deciding whether a ledger record can become a published journal entry; positioning jazz as the second content agent, peer to Yao

  19. asgard advanced 10 min

    jazz Pipeline: Normalise, Translate, Gate, Judge, Settle, Import

    Use when: tracing an artefact end-to-end through the jazz subsystem; understanding the translate revise-loop and batch entrypoints; reading a jazz batch report shape

  20. asgard advanced 9 min

    jazz verify-gate: Deterministic Fail-Closed Defect Checks

    Use when: auditing why an entry failed the jazz gate; adding or reasoning about a deterministic defect check; distinguishing the deterministic layer from the semantic pass

  21. asgard intermediate 7 min

    jazz authenticity-judge: LLM Scoring Against a Gold Exemplar

    Use when: explaining the autonomy hinge that lets entries auto-approve; debugging why a gate-passing entry was still held; reasoning about the JUDGE_THRESHOLD and fail-closed behaviour

  22. asgard intermediate 8 min

    jazz settle economy: Pricing an Entry by Provenance Quality

    Use when: computing or auditing the slug cost of a jazz entry; reasoning about the gap_penalty > fidelity_rate invariant; understanding what a settlement record freezes and when it goes stale

  23. asgard intermediate 8 min

    jazz Adapters and the Entry-Output Contract

    Use when: onboarding a new org to jazz via a single adapter file; checking the required fields of the entry-output or ledger-artefact contract; explaining the provenance block as the audit receipt

  24. asgard intermediate 7 min

    jazz Stage Vocabulary: deriveStage and STAGE_ORDER

    Use when: deriving the display or ship stage for a jazz entry; distinguishing the jazz stage vocabulary from the yao lifecycle stages; debugging why an entry shows held, gated, or stale

  25. asgard intermediate 9 min

    Profile Testing CLI: Six-Layer Ollama Pipeline

    Use when: testing an LLM profile against local Ollama models; adding a new validation strategy or CLI command to the legacy layer; distinguishing the profile-testing framework from the content agents

  26. asgard intermediate 8 min

    Autonomous Hourly Crons: Approve, Ship (Dry-Run), Reconcile

    Use when: reasoning about how content ships without a human in the loop; checking whether shipping is live or still fake / dry-run; finding the human step that gates live publishing