top of page
BG 1.png
Original.png

Agentic Engineer Program

Syllabus

Module 1:
Foundations & The Context Packet

  • 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.

Module 2:
The Twelve-Factor Agentic SDLC

  • The Orchestrator Mindset: Transitioning from solo coder to strategic orchestrator.
     

  • The Testing Pyramid for AI: Introducing Deterministic Anchors – How to separate and test deterministic logic vs. probabilistic AI responses.
     

  • The Playbook: Writing a "Mission Brief" and "Technical Plan" before writing code.
     

  • Triage: Strategic decision-making: When to use Async (AI) vs. Sync (Human) logic.

Module 3:
Automation with Spec-Kit

  • Automating the Playbook: Using Tikal’s spec-kit CLI to automate the Agentic SDLC workflow.
     

  • Spec-Driven Development: The principle of "Debug the spec, not the code."
     

  • Lab: A fast-paced workshop building a feature from intent to implementation using the CLI.

Module 4:
The Core Engine – ReAct & MCP

  • 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.

Module 5:
Self-Healing Architectures & Agentic RAG

  • Beyond Naive RAG: Solving "Lost in the Middle" and data hallucinations.
     

  • The Self-Correction Loop: Implementing Reflection and CRAG (Corrective RAG) patterns.
     

  • Memory Systems: Architecting Short-term (Graph State) vs. Long-term (Vector) memory.
     

  • Lab: "The Self-Doubting Bot" – An agent that critiques its own answers and rewrites queries until confidence is met.

Module 6:
Multi-Agent Orchestration

  • From Tools to Peers: Moving from function calling to Agent-to-Agent (A2A) collaboration.
     

  • The Agent Card: Standardizing discovery protocols between agents.
     

  • Organizational Design: Implementing Hierarchical (Supervisor) vs. Swarm (Panel of Experts) architectures using LangGraph.

Module 7:
Production-Ready Agents (Governance & Economics)

  • 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.
     

  • Testing Non-Deterministic Systems: Building a "Golden Dataset" and running regression tests to detect quality drift.
     

  • Safety Layers: Implementing Human-in-the-Loop (HITL) gates and deterministic guardrails.

Module 8:
Capstone Project – "The Simulated Reality"

  • 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.

  • Externalized State: Production-grade state management (Redis/Postgres).
     

  • Presentation: Teams present their architecture, cost analysis, and "Evolve Loop" story.

Original.png
bottom of page