Course ENG 100 · Units: 4.0 · Credential: HACE
Agentic Coding Systems with Hanzo Dev & Zen 6
The definitive systems curriculum for autonomous software engineering. Learn to architect production-grade coding agents that inspect repositories, reproduce failing test cases, synthesize syntax-safe AST diffs, and self-heal in isolated Hanzo Visor sandboxes under strict micro-USD budget ceilings.
Academic specificationsENG 100 · 4.0 UNITS
Duration4 WeeksSelf-Paced Intensive
Estimated effort8–10 HoursPer Week (Lectures & Labs)
PrerequisitesPython or Rust / GitSystems Programming Assumed
Evaluation methodSWE-bench GraderAutomated Cleanroom CI
Course tuition & fellowshipCredential: HACE
Total tuition
+$50 CREDITS (25% REBATE)$199USD
Enroll in ENG 100 — $199 USD →Have a coupon code or fellowship grant? Enter it during checkout.
Cloud Fellowship Credit Rebate:
+$50 USD (25%)Already enrolled?Enter Enrolled Student Portal →
Laboratory Infrastructure
The cleanroom execution environment
Autonomous agents cannot be evaluated on unconstrained local machines. Every student is provisioned an isolated execution pod with strict kernel virtualization and zero-copy IPC.
LABORATORY TERMINAL · ISOLATED RUNSC BOUNDARY
Real-time terminal feedback: students inspect agent AST diffs, Cap’n Proto trace records, and micro-USD budget meters.
Hanzo Visor (`runsc`) User-Space Kernel IsolationEvery agent turn runs inside an unprivileged sandbox pod with virtualized syscalls, seccomp filtering, and read-only host mounts.
Zero-Copy ZAP IPC ProtocolMulti-agent communication traverses Cap’n Proto zero-copy serialization over Unix domain sockets, reducing message dispatch latency from 180ms to < 2ms.
Zen 6 High-Throughput Model ServingAccess quantized GGUF/AWQ builds of Zen 6 (27.3B) and Zen 6 Flash with continuous token streaming, structured JSON tool schemas, and KV-cache reuse.
Micro-USD Financial GovernanceEvery test execution is bound to an exact integer micro-USD budget ceiling ($0.50 per defect). Exceeding the ceiling triggers in-band refusal and automatic grading failure.
Academic Syllabus
Weekly Lecture & Laboratory Curriculum
Modeled on elite graduate computer science systems curricula. Each week integrates foundational systems theory, primary literature readings, terminal laboratory assignments, and milestone grading.
ENG 100.1Week 1
Module 1 of 4Runtime Virtualization, Ephemeral Sandboxes & Zero-Copy ZAP RPCAnalyze the systems boundary of autonomous code execution. Configure local high-throughput quantized serving for Zen 6 (27.3B) and Zen 6 Flash. Engineer Hanzo Visor user-space kernel virtualization with ephemeral lease lifecycles and zero-copy Cap’n Proto RPC channels.
LECTURE TOPICS & SYSTEMS PRINCIPLES:
Zen 6 architecture: quantized GGUF/AWQ local inference on Apple Silicon (Metal) and Linux (CUDA)
The 4-surface boundary contract: unified ergonomics across CLI, SDKs, HTTP REST, and MCP sockets
ZAP Zero-Copy RPC over Cap’n Proto: replacing high-overhead JSON serialization with microsecond IPC
User-space container virtualization: Hanzo Visor / runsc process boundaries and ephemeral rootfs mounts
REQUIRED READING:• Google Engineering: Container Isolation through User-Space Kernel Virtualization (Hanzo Visor Architecture)• Kent: Cap’n Proto Serialization and RPC Protocol Specification
GRADED LABORATORY ASSIGNMENT:Lab 1: Provision an isolated multi-process execution jail with ZAP IPC socket bridge and evaluate inter-process latency.
ENG 100.2Week 2
Module 2 of 4Abstract Syntax Trees, Context Distillation & Dual-Index RetrievalTrain agents to navigate 100,000+ line repositories without exceeding token context boundaries. Extract AST symbol graphs using tree-sitter grammars and synthesize dual-index retrieval combining BM25 keyword matching with dense vector embeddings.
LECTURE TOPICS & SYSTEMS PRINCIPLES:
AST-based symbol extraction using tree-sitter across Python, TypeScript, Go, and Rust codebases
Dual-index code retrieval: combining BM25 exact keyword inverted indexes with dense vector embeddings
Context compression algorithms: distilling 50-file call chains into a 4k-token working memory scratchpad
Three-tier memory hierarchy: immediate scratchpad, thread history log, and long-term vector stores
REQUIRED READING:• Bruns et al.: Tree-sitter: An Incremental Parsing System for Programming Tools• Robertson et al.: The Probabilistic Relevance Framework: BM25 and Beyond
GRADED LABORATORY ASSIGNMENT:Lab 2: Implement an autonomous AST file scout that isolates defect locations across a 100k-line repo in < 3 tool hops.
ENG 100.3Week 3
Module 3 of 4Test-Driven Self-Healing & Finite-State Kai VerificationClose the autonomous execution feedback loop. Engineer agents that parse natural-language issue tickets, synthesize minimal reproducible failing tests, generate syntax-safe AST patches, and verify state transitions with Kai zero-token heuristics.
LECTURE TOPICS & SYSTEMS PRINCIPLES:
Automated reproduction synthesis: generating failing pytest / cargo test cases directly from GitHub issues
AST diff validation: guaranteeing generated patches introduce zero syntax regressions or unused symbols
Kai finite-state decision checkpoints: zero-token verification scoring, completion heuristics, and state branching
Micro-USD economic governance: enforcing hard pre-call cost ceilings and handling in-band budget refusals
REQUIRED READING:• Hanzo Research: Finite-State Decision Models: Zero-Token Control in Autonomous Software Construction• Monperrus: Automatic Software Repair: A Survey on Principles, Benchmarks, and Verification
GRADED LABORATORY ASSIGNMENT:Lab 3: Build an autonomous test runner that iterates on AST patches in an isolated pod until test exit code 0.
ENG 100.4Week 4
Module 4 of 4Coordinator-Worker Swarms & SWE-bench Capstone DefenseDeploy multi-agent coordinator-executor pairs to resolve authentic defects from Princeton SWE-bench Lite. Submit your agent harness to the automated Hanzo cleanroom grader pod for adversarial evaluation and credential issuance.
LECTURE TOPICS & SYSTEMS PRINCIPLES:
Coordinator-Worker topology: formal architectural decoupling of high-level planning from atomic file editing
Git branch management: automated branch isolation, semantic commit hygiene, and pull request generation
Distributed telemetry & audit trails: streaming full Cap’n Proto agent trajectories to ClickHouse O11y
W3C Verifiable Credential issuance: on-chain cryptographic proofs and dynamic GitHub SVG verification badges
REQUIRED READING:• Jimenez et al. (Princeton NLP): SWE-bench: Can Language Models Resolve Real-World GitHub Issues?• W3C Recommendation: Verifiable Credentials Data Model v2.0
GRADED LABORATORY ASSIGNMENT:Capstone Project: Autonomously resolve 5 SWE-bench benchmark issues with 100% test pass rate and < $0.50 spend per issue.
Evaluation Standards
Grading Rubric & Automated Evaluation Policy
To earn the Hanzo Certified Agentic Coding Engineer (HACE) credential, candidates must satisfy rigorous machine-evaluated benchmarks. All grading is conducted via synthetic fault injection in isolated cleanrooms.
40%Test Suite Pass Rate100% of pre-existing unit test suites and student-synthesized reproduction tests must pass with exit code 0.
20%AST & Type CleanlinessPatches must pass strict AST verification, linters, and typecheckers without introducing formatting errors or dead imports.
20%Micro-USD Budget CeilingsThe agent must resolve each defect within a strict 500,000 micro-USD ($0.50) ceiling. Exceeding the ceiling triggers instant failure.
20%Telemetry & Audit FidelityFull Cap’n Proto trace records, tool invocation timestamps, and Kai state probabilities must be emitted to ClickHouse O11y.
The Cleanroom Fault-Injection Policy
To prevent students from hardcoding solutions to known SWE-bench issue IDs, the Hanzo Grader Pod executes synthetic fault injections: renaming test assertions, injecting subtle dependency regressions, and scrambling directory paths during test execution. Passing requires a truly generalized autonomous reasoning and repair harness.Credential Verification
The HACE Professional Credential
Unlike static PDF diplomas, the Hanzo Certified Agentic Coding Engineer credential is an immutable, machine-verifiable cryptographic proof.
W3C Verifiable CredentialIssued under the W3C Verifiable Credentials Data Model v2.0 standard, cryptographically signed by the Hanzo Trust Root (`did:hanzo:trust`).
Immutable On-Chain ProofEvery issued certificate is permanently anchored with an on-chain cryptographic commitment, preventing credential forgery or revocation tampering.
Dynamic GitHub SVG BadgesEmbed a real-time verified SVG badge into your GitHub profile and READMEs. Click-throughs link directly to your passing CI benchmark runs.
Instruction & Support
Faculty, Preceptors & Grader Pods
Continuous asynchronous grading backed by live developer preceptorials and active technical office hours.
Systems FacultyCurriculum designed by the core Hanzo AI systems architects who build Zen 6, Enso, and the ZAP RPC runtime.
Automated Grader Fleet`hanzo-grader` pods run 24/7. Submit your repository at any hour and receive comprehensive test traces within 90 seconds.
Developer PreceptorialsJoin private Discord channels and weekly architecture reviews with fellow systems engineers and teaching assistants.
Enrollment Open · Term 2026
Enroll in ENG 100: Agentic Coding Systems
Join the elite systems engineers mastering autonomous code generation. Claim your $50 usage credit rebate immediately upon registration to fund all laboratory sandboxes.