8.0. Repository

Why every claim needs a file you can open

A source-ownership map is the index from a claim to the file that owns it. This page is that map: four Go modules, the committed seed, the infrastructure tree, and the root policy documents, each with a named owner. It exists because prose has no compiler. Chapter 6 names the path and port the agent’s readiness probe hits; change the manifest and leave the page alone, and nothing fails until someone debugs a Pod that will not go Ready. The defence is not diligence; it is being able to open the owning file in under a minute, from any sentence.

The repository holds the course and every executable surface the course teaches:

agentops-open-course/
├── content/       # the course pages, built by Hugo
├── agents/
│   ├── go/        # ADK Go reference agent and offline tests
│   └── data/      # immutable SQLite, log, runbook, and runtime-skill seed
├── evals/         # standalone black-box Go evaluation module
├── tools/         # native repository conventions, freshness, and evidence CLIs
├── clients/web/   # dependency-free A2A browser client
├── load/          # k6 protocol and latency checks
├── skills/        # portable Agent Skills for other projects
└── infra/         # gateway, Kubernetes, kagent, telemetry, and optional GCP plan

skills/ holds portable instructions developers install in other projects. agents/data/skills/ holds runtime instructions the agent loads during a turn, so they are reviewed as text a model will act on. Same word, different consumers — do not merge them.

One source revision can change prose, behavior, tests, and deployment wiring at once, which is what makes a claim traceable at all. The cost is a bigger clone and checks that have to agree with each other — a fair trade while these surfaces ship as one release.

How four Go modules keep evaluation independent of the agent

The single agentops-open-course directory is not a single Go module. Ask it:

for module in . agents/go evals tools; do (cd "${module}" && go list -m); done

github.com/MLOps-Courses/agentops-open-course
github.com/MLOps-Courses/agentops-open-course/agents/go
github.com/MLOps-Courses/agentops-open-course/evals
github.com/MLOps-Courses/agentops-open-course/tools

The root module exists only to pin the Hextra theme for Hugo. The other three carry their own locks and dependency graphs, and one boundary among them is enforced rather than trusted: evals may not import agents/go.

An evaluation that imports the code it is judging can accidentally assert against the implementation instead of the behavior: call the same validator the agent calls, and every malformed payload the agent accepts becomes a payload the evaluation also blesses. So evals watches ADK REST or A2A events over the wire, folds both transports into one typed Turn — one question plus everything the agent emitted in reply — scores what it captured, and writes sanitized verdicts. Because a Turn is assembled from observed events, a verdict depends on the agent’s behavior, not on its implementation.

That rule is not a convention someone remembers; it is a test:

cd evals
go test -run TestImportGraphCannotCrossIntoAgentModule -v -count=1 .

=== RUN   TestImportGraphCannotCrossIntoAgentModule
--- PASS: TestImportGraphCannotCrossIntoAgentModule (0.97s)
PASS
ok  	github.com/MLOps-Courses/agentops-open-course/evals	1.013s

Add one import of an agent package and that test goes red: independence from the thing you are grading is checkable in one command, not something a reviewer has to vouch for.

Inside agents/go the rule is one concern, one named owner:

agents/data sits outside the agent module on purpose: committed seed and mutable runtime state have different lifecycles. Host processes copy state into agents/go/.state, Kubernetes writers use the shared state claim, and MCP mounts it read-only. The evaluation harness reads its domain vocabulary from agents/data rather than from agent packages, so the values it expects stay independent of the implementation it is judging.

Infrastructure is filed by executable owner, not by chapter

The local and GKE overlays share one application contract and differ only where the environment genuinely differs: registry, model backend, storage, cloud identity, and egress. When a page describes a manifest, that manifest is the authority and the page is the copy.

The shared vocabulary across all of it is mise run install, format, check, test, scan, and build. Module tasks stay local; the root aggregates give hooks and CI one entrypoint. 8.5. Contributions takes a change through them.

How a page quotes source through named include regions

Pages do not retype code. They point at a named region — a --8<-- [start:name] line and its matching end line in the source — and the build extracts everything between them. Markers travel with the code when it moves; a line number would not:

rg -c -- '--8<-- \[start:' agents/go agents/data infra .github/workflows | sort | head -6

agents/data/sql/schema.sql:1
agents/go/a2aserver/a2aserver.go:1
agents/go/a2aserver/identity.go:1
agents/go/a2aserver/serve.go:2
agents/go/cmd/agent/runtime.go:1
agents/go/compose/composition.go:2

Drop the head and twenty-five files answer, from the seed schema to the release workflow. A missing file, a missing region, a duplicate marker, or an empty one fails the strict docs build, mise run check:docs, so a page cannot keep quoting an excerpt that no longer exists. 8.4. Documentation shows that failure happening and explains the rest of the mechanism.

Two root documents split the audience rather than duplicating it. README.md is the human entrypoint — outcomes, architecture, setup, and the shortest runnable path — while AGENTS.md is the coding-agent contract, holding invariants, owners, safety rules, pinned compatibility, and exact commands.

Six smaller policies sit around them, each owning one question: SUPPORT.md for stable surfaces and compatibility ceilings, CONTRIBUTING.md for mapping a local change to what CI runs, GOVERNANCE.md for project decisions, SECURITY.md for routing vulnerability reports privately, ACCESSIBILITY.md for keyboard, contrast, and diagram expectations, and CODE_OF_CONDUCT.md for participation standards. CITATION.cff owns citation metadata, and the issue and pull-request templates under .github/ collect reproducible commands — they do not replace any of those policies.

Two skill directories, aimed in opposite directions

agents/data/skills/ holds runtime skills: procedures the agent loads mid-turn, which 3.2. Skills teaches. The top-level skills/ directory holds the same file format aimed the other way — at the human or coding agent building an agent. Those distil the course’s operational patterns: telemetry, guardrails, resilience, token budgets, least privilege, evaluation, and incident response.

Because both follow the open SKILL.md convention, the portable ones install into a coding assistant with the skills CLI — Antigravity, Codex, OpenCode, Claude, or Copilot:

npx skills add MLOps-Courses/agentops-open-course --all           # every pattern
npx skills add MLOps-Courses/agentops-open-course --skill agent-resilience

Each ends with a “Reference implementation” section naming the exact course files it distils, and mise run check:skills keeps every one of them valid and machine-path-free. That is the honest test of whether a pattern in this course generalizes: it has to survive being read outside the repository that produced it.

What you can do now

• You can name the owner of an agent behavior, an eval verdict, a repository check, and a deployment claim without searching by keyword.
• You can run the one test that forbids evals importing agents/go.
• You can list the files that expose named regions, and open the exact excerpt a page renders.
• You know which root document answers a human setup question, a coding-agent question, and a support question.

Return to 8. Community, or straight back to 8.7. Capstone — this page is a map, not a stop on the path.