Agentic Engineer Program

Syllabus

The Physics of LLMs: Tokenization, Latency vs. Cost, and the Autoregressive nature of generation.
Context Engineering: Moving beyond "Prompt Engineering" to the engineering discipline of the "Context Packet"—controlling the Perception-Reasoning-Action loop.
Lab: The Reliability Challenge – Iteratively refining a context packet to achieve 95% accuracy under strict token budgets.

The Orchestrator Mindset: Transitioning from solo coder to strategic orchestrator, including when to use Async (AI) vs. Sync (Human) logic.
The Playbook: Writing a "Mission Brief" and "Technical Plan" before writing code, with Deterministic Anchors that separate testable logic from probabilistic AI responses.
Spec-Driven Development: The principle of "Debug the spec, not the code."
Lab: Automating the playbook end to end with Tikal's spec-kit CLI, building a feature from intent to implementation.

Agent Protocols: Deep dive into the ReAct loop (Think → Act → Observe).
Model Context Protocol (MCP): Architecting the agent as a "Universal Client" that connects to external databases and tools via strict schemas.
The Decision Matrix: Engineering judgment: When to use dynamic LLM tools vs. deterministic hard-coded functions.

Agent Memory: Architecting Short-term (Graph State) vs. Long-term (Vector) memory, and patterns for managing knowledge across sessions.
Knowledge Formats & Standards: Structuring agent facing knowledge with approaches like LLM Wiki and the Open Knowledge Format (OKF).
Beyond Naive RAG: The evolution of RAG, solving "Lost in the Middle" and data hallucinations, and choosing between retrieval strategies.
The Self-Correction Loop: Implementing Reflection and Corrective RAG (CRAG) patterns.

From Tools to Peers: Moving from function calling to Agent-to-Agent (A2A) collaboration.
Organizational Design: Implementing Hierarchical (Supervisor) vs. Swarm (Panel of Experts) architectures.
When Not to Go Multi-Agent: Cascading failures, context fragmentation, runaway cost and latency chains, and the discipline of starting with the simplest architecture that works.

The Economics of Model Selection: Creating a strategy for Model Routing, dynamically routing simple tasks to cheaper models and complex reasoning to SOTA models to optimize TCO.
Evaluation-Driven Development: Building a "Golden Dataset", running regression tests to detect quality drift, and instrumenting observability for agents in production.
The Security Envelope: Deterministic guardrails, permission boundaries, and Human-in-the-Loop (HITL) gates that keep non-deterministic systems inside the lines.

The Challenge: Teams design, build, and validate a Multi-Agent System using the Tikal Agent Scaffold.

Mandatory Requirements:
Self-Healing Logic: The system must detect and fix its own errors.
The Evaluation Gate: Must pass a "Golden Dataset" of adversarial inputs.
Presentation: Teams present their architecture, cost analysis, and "Evolve Loop" story.