Agentic Engineering Boot Camp — Cohort 2

Background & goalsWhy this exists

A new role is being created

"Software 1.0 is code. Software 2.0 is neural networks. Software 3.0 is the era of agents — and it needs a new kind of engineer: the agentic engineer." Once Codex and Claude Code can finish nearly any coding task, the job itself moves.

What is actually being asked of you

For decades, AI/ML and software engineering work centred on implementation. The demand is moving fast toward something else: being able to design, build and ship agent systems that solve real problems — using LLMs, MCP, tools, skills and loops well, managing memory and context, and standing up the agent infrastructure of this era.

What frontier labs and AI companies are hiring for right now

Over the past year, agent engineering has become one of the fastest-growing engineering tracks in the industry. Open the careers page of almost any frontier AI company and you will find these roles:

AI Agent Engineer

Design and implement the full agent loop: planning, tool calls, multi-step execution and self-correction
Build evals and observability for agents, and drive task failure rates down over time
Strong context engineering and tool-interface design; experience taking LLM applications to production

— hiring at frontier labs and AI product companies (OpenAI, Anthropic, Perplexity and peers)

→ covered by: all of Phase 1 + Projects 1–3

LLM Inference / Serving Engineer

Work deep in the transformer inference path: KV cache, continuous batching, speculative decoding
Stand up high-throughput, low-latency model serving with vLLM / TensorRT-LLM and similar
Comfortable with quantization and memory optimization; own latency and cost against an SLA

— hiring at model-serving and AI infrastructure companies (NVIDIA, Together AI, Fireworks AI and peers)

→ covered by: Project 4 · LLM serving infrastructure

Robotics / Embodied AI Engineer

Build perception and control nodes in ROS2, wiring vision → 3D localization → motion planning
Put VLMs/LLMs into robot task planning so natural-language instructions become executable actions
Familiar with the sim-to-real debugging and validation loop

— hiring at robotics and automation companies (Tesla, Figure, Physical Intelligence and peers)

→ covered by: Project 5 · ROS2 × UR5 robot control

Applied AI / Forward-Deployed Engineer

Integrate agent capabilities into a customer's existing systems (ERP / CRM / internal tools)
Design permissions, audit trails and human approval gates so agents can be trusted under enterprise constraints
Own delivery end to end: scoping, integration, launch and operations

— hiring on forward-deployed teams (OpenAI, Anthropic, Palantir and peers)

→ covered by: Project 6 · Airline ticketing + ERP agent

Public compensation data puts Bay Area total comp for these roles commonly in the $200K–$500K+ range. What they share is that none of them stop at calling a model API — they ask you to build, evaluate and operate a complete agent system. That is exactly what these two phases and six projects train.

Who this is forFit & non-fit

A good fit if you are

An engineer or researcher who wants to build agent systems that solve real internal, customer-facing or research problems
Job-hunting, and want to land a role in LLM agent systems or embodied agents within six months
Learning to build or serve LLM/VLM agents in production
Ready to move your own development workflow into the agent era — out of hand-configured servers and artisanal shell work, into Vercel / Daytona / Langfuse / Supabase / Cloudflare / Render / Stripe MCP / CLI-anything
Trying to reach the genuine frontier of agent engineering rather than the tutorial layer

Not a good fit if you

Only want to learn how to use Claude Code / Codex, with no intent to build agents of your own
Want to understand LLM internals — an agent is LLM + harness, so the LLM itself is a prerequisite here, not the subject (you can prepare with LLM from Scratch and LLM Agents in Agentist Academy)
Only want to use AI tools (image generation, no-code agent builders) rather than build agent systems

What you will getOutcomes

Calibration

A calibrated view of the field: deep understanding of how modern agent systems are designed, and the ability to track, judge and apply new work on your own after the cohort ends.

Insight

Judgement: correctly telling apart the problems that deserve an agent from the ones that want a plain workflow or ordinary software.

Reliability

Reliability engineering: how to evaluate and debug agents, and how to carry one from demo to production — from toy project to something that carries real business weight.

Diversity

Range: agents for genuinely different shapes of problem — automated ML, research and paper reproduction, automated trading, enterprise data operations.

Advancing

Modern delivery: an automated build-and-deploy practice built on Vercel / Langfuse / Supabase / Daytona / Render / Cloudflare MCP tooling.

Governance

Governance and deployment: running your own token management layer, deploying and optimizing models, and self-hosting with vLLM / SGLang / TensorRT-LLM / Ollama / LMDeploy.

New in cohort 2What's new

① A much stronger learning and runtime environment

Agentist Academy: structured self-study on frontier agent work — prepare before the cohort, top up during it
Parallight Agent Runtime: hosted sandbox evaluation, data and result analysis for the agents you build

② Everything important from April–July

Loop engineering and graph engineering
Self-evolving agents and recursive evolving agent systems

③ More kinds of agent

Embodied agents
Computer-use agents
Multi-modal agents — theory and practice

④ System-scale project work

Building LLM serving infrastructure for enterprise support — a systems-level project
An agent upgrade of an existing enterprise ERP
A multi-modal, embodied UR5 pick-and-place robot

Phase 1 · Principles & architecturePhase 1 · Principle & Architecture · Week 1–4

Led by Marvin Gao. A live lecture each week plus 6–8 hours of lab work; within four weeks, three genuinely useful personal agent projects land alongside the curriculum.

W1

Modern agent principles and architecturefirst principles · memory · harness

aFirst principles of the modern agent: ReAct, MCP, tools and skills

Plan–Act–Observe–Verify: what each step of the ReAct loop actually does at the token level
The full life of a tool call: schema design, argument validation, result injection — the round trip between model and runtime
MCP's server / client / transport architecture, and how it differs from function calling
Where the boundaries actually fall between tools, skills and sub-agents
Sandboxing and execution permissions: the engineering boundary that lets an agent do work without doing damage

bAgent memory: memory and context engineering

How system prompt, conversation history and tool results get laid out — and the "context rot" problem
The three-layer architecture of working / episodic / long-term memory, and when each is read and written
The full RAG path: embeddings, vector retrieval, reranking, and how to inject results without poisoning the reasoning
Context compaction and summarization: what to keep, what to drop, what to push out to the filesystem
Seen from the KV cache: why prompt-prefix stability directly determines inference cost

You can keep an agent on task for hours without it losing the thread — the line between a task agent and a chat toy.

cHarness engineering, with a Claude Code source teardown

Claude Code: the most thoroughly validated agent harness in the world right now
Architecture teardown: main loop, tool set design, sub-agent dispatch, permission model, TODO management
System prompt engineering: why Claude Code's system prompt reads the way it does — the reason each section exists
Why the same model can be 10× more capable under a different harness
Hands-on extension: injecting your own tools, skills and workflows on top of Claude Code

Project 1

Auto-Scientist Agent

Built on top of Claude Code: reads papers and pushes you the summary, pulls and analyses data, writes training code, runs experiments, reads loss / accuracy / F1, diagnoses overfitting, iterates, and reports back — until it hands you a validated model and a written report.

W2

Personal assistant and computer-use agentspersonal assistant · computer use

aPersonal assistant agents: OpenClaw and Hermes, architecture and source

OpenClaw architecture: gateway, session management, multi-channel entry (WhatsApp / Telegram / iMessage), scheduled and self-initiated triggers
How Hermes works: the state machine of a personal assistant agent, its skill system, local tool orchestration and self-improvement loop
Resident agents vs one-shot agents: process model, memory persistence, event-driven execution
Privacy and permission design: how much it gets to see, and who decides

You will hand an agent a real computer and watch it complete real work.

bComputer-use agents and OSWorld

More than half of enterprise software has no API — computer use is the skeleton key to every legacy system, and one of the fastest-growing agent directions of 2026
The full path: screenshot → visual grounding → coordinates → mouse and keyboard actions → verification
GUI grounding models: why "understanding an interface" is far harder than "saying the right answer"
The OSWorld benchmark: how the field measures what computer-use agents can really do
Hybrid execution: API-first with computer use as fallback — the standard enterprise play
Multi-modal input fusion: text, screenshots and files entering one reasoning loop

Project 2

Personal productivity agent

Built on Hermes: drives OBS recording, edits the video, files the output. When this one is done, your content pipeline runs itself.

W3

Multi-agent systems and unattended operationmulti-agent · loop & graph · self-evolving

aMulti-agent systems

Reaching for multiple agents unnecessarily was one of the most expensive engineering mistakes of 2025 — this week settles which problems actually earn it
The classic topologies: orchestrator–worker, hierarchical, debate, pipeline — and the task shapes each one suits
Inter-agent communication: message passing, shared blackboard, A2A, and the information loss that context isolation costs you
Parallelism gains vs token cost: the cost model of a multi-agent system, and how to keep it from running away
Failure modes: diffusion of responsibility, forwarding loops, consensus collapse — and what to do about each

Give a defensible architectural verdict on any task — single agent, multi-agent, or plain workflow. This is the most valuable judgement call in both interviews and real design reviews.

bLoop and graph engineering: long-horizon agents that run unattended

The most important new direction in agents worldwide from April to July 2026 — agents that run all night, or all week, without someone watching
Getting out of hand-written prompts: agents that generate and manage their own prompts to steer their own execution
Loop engineering: state persistence, resumption, timeout / budget / retry policy, and where the human-in-the-loop approval points belong
Graph engineering: compiling a complex task into an execution DAG, with node-level retry and partial rollback
Safety valves for unattended runs: budget breakers, action allowlists, exception reporting — the preconditions for letting an agent run overnight alone

Design the system where you submit a task, close the laptop, and find a verified result waiting — the point where an agent stops being a tool and starts being labour.

cSelf-evolving agents and recursive evolving agent systems

The most closely watched new technique of 2026: not a human improving the agent, but the agent improving itself from its own traces
The full loop: trace → extract failure modes → generate a fix → validate in a sandbox → compare old against new
Recursive evolving agent systems: when the improvement mechanism itself enters the evolution loop
The boundary and safety of self-modification: which changes an agent may ship alone, and which must return to a human
Paid off in Phase 2: this machinery gets fully implemented in Project 6's airline-ticketing scenario (trace → failure mode → fix → sandbox test → approval → ship)

W4

Evaluation, security and the production substrateevaluation · security · production substrate

aEvaluating and securing agent systems

An agent evaluation framework across seven dimensions: task success rate, tool-call accuracy, hallucination rate, policy compliance, latency and cost
Trace analysis and failure taxonomy: classify and quantify every failure, then turn it automatically into a regression test
Using LLM-as-judge correctly, and the traps (position bias, self-preference, score drift)
Agent security: prompt-injection defence, least-privilege tools, approval gates on high-risk actions, audit trails
Sandbox evaluation → staged rollout → monitored rollback: a new version ships only if it evaluates better

Project 3

Automated trading agent (can connect to live Robinhood trading)

This week's eval and risk-control machinery applied to the least forgiving setting there is: strategy backtests, risk breakers, and a complete trace behind every single decision.

bThe production substrate: MCP-native databases, deployment and operations

Application deployment: Vercel / Cloudflare Workers / Modal (against the AWS 7-step configuration chain)
Self-hosted inference: vLLM and SGLang in depth, plus a five-engine selection map
Agentic DevOps (the 2026 pattern): canary, blue-green and shadow mode, all agent-driven
LLMOps observability: Langfuse in depth, plus a six-way comparison (LangSmith / Helicone / Phoenix / Braintrust / Datadog)
LiteLLM as a token and proxy governance layer: multi-model fallback, per-tenant quota, cost optimization
A framework for choosing your compute ecosystem: NVIDIA (CUDA / TensorRT / NIM), Amazon (Bedrock / AgentCore), Anthropic (MCP / Skills / Claude Code) plus the TPU path; and a comparison of the GPU compute market

By the end of Phase 1

You hold three agent projects that do real work, plus the engineering substrate to push any agent into production.

Phase 2 · Project intensivePhase 2 · Project Intensive · Week 5–13

Mentor-led, 15 days of iteration per project, every one adapted from real company work and fit to put on a résumé. If you will take a heavier workload, the three projects can run in parallel and start earlier (as early as week 2, finishing week 9) — you decide once the cohort starts. Each weekend: 3 hours of live lecture plus 3 hours of TA-led lab, to clear environment setup, permissions and data out of your way.

Project 4 · Week 5–7 · mentor: Marvin Gao

LLM serving infrastructure for enterprise support

LLM Serving Infrastructure for Enterprise Support

Adapted from a project at a well-known US AI lab

LLM serving infrastructure project diagram

W5

The full life of an inference request, and building the server

In the few hundred milliseconds between you hitting enter and the first token appearing — what is the GPU actually doing?

Prefill and decode: "reading your question" and "emitting the next token" are two completely different compute profiles
How streaming really works: SSE / WebSocket and the server structure behind token-by-token delivery
The shared vocabulary of serving performance: TTFT, TPOT, p50 / p95 / p99 and throughput — and why the average is the least useful number you have
What the KV cache actually caches: the quantitative trade between compute saved and memory spent
Write a toy server by hand: request intake → queue → inference → streamed response, with no serving framework underneath

W6

The engineering of throughput, and production integration

Same GPU: why does someone else hold 1,000 concurrent requests while you top out at 30?

Static vs continuous batching: the dividing line of high-throughput serving in 2026
Request queue scheduling: priority, fairness, and the head-of-line blocking you get from mixing long and short requests
FP16 / INT8 / INT4 quantization in practice: measured speedup against measured quality loss
Production frameworks: deploying and tuning vLLM / SGLang, mapping your toy server's principles onto a real engine
Rate limiting, multi-tenant isolation and backpressure: how one tenant saturating traffic fails to take everyone down
Wiring in enterprise knowledge bases and CRM data: the support agent's retrieval path and where it couples to the serving layer
Load testing, fault injection and capacity planning: producing an SLO you could actually promise a customer

W7

Project iteration and office hours

What you ship

A streaming LLM server plus the API layer an enterprise support agent runs against
A KV-cache and batching comparison study, and before/after numbers on quantization quality and speed
A latency / throughput / GPU-memory / cost-per-task dashboard, and one explicit service SLO
The LLM server source — résumé-ready evidence that you understand inference serving, not just how to call an API

Project 5 · Week 8–10 (can start as early as week 2–4) · mentor: Howard Cao · taught Sundays

A ROS2 and multi-modal agent control system for the UR5 robot

Embodied Agent · Vision → Motion · UR5

Adapted from real work at a leading US robotics company

UR5 robot control system project diagram

W8

Robot dynamics, ROS2 and embodied AI

A software agent's mistake can be retried. A mistake in the physical world breaks something.

ROS2 fundamentals: node / topic / service / action, and simulated control of the UR5 and its gripper
Robot dynamics and frames: camera calibration and TF2 transforms — going from "seeing it" to "knowing where it is"
RGB and depth input: a perception pipeline that survives visual noise
The embodied AI landscape: why embodiment is the final exam for multi-modal agents

W9

Motion control and pose correction driven by multi-modal foundation models

"Find the orange block and put it in the marked area" — how does one sentence become a sequence of executable arm movements?

VLM-driven object detection and target selection: from 2D detection to 3D pose estimation
Task planning → motion planning: MoveIt2 path planning, grasp pose generation, collision checking
Execution feedback and visual verification: confirming after each action that the world actually changed as intended
Failure classification and replanning: recovery from missed grasps, collisions and occlusion; robot safety boundaries
Using harness engineering and skills to raise robot task success rates
Getting the model onto real hardware

W10

Project iteration and office hours

What you ship

ROS bag execution replays
A grasp success-rate and failure-classification report
A project demo video you can put on a résumé

Project 6 · Week 11–13 (can start as early as week 7–9) · mentor: Howard Cao

Agentifying an airline ticketing system and an enterprise ERP

Task Agent · Self-Evolving · Enterprise ERP

Adapted from an airline-ticketing agent project at a US technology company

Airline ticketing and ERP agent project diagram

W11

Task agents and self-evolution: taking over airline ticketing

Booking, changes, refunds, baggage, seating, policy constraints — one of the hardest domains a task agent can be pointed at.

Dialogue state and formal task state: multi-turn clarification, intent tracking, recovery after interruption
Policy grounding and RAG verification: every answer standing on real policy, real knowledge base and real business data
Joint reasoning over structured and unstructured data; where business rules must be hard-coded rather than inferred
The self-evolving loop, fully implemented: trace → failure mode → proposed fix → sandbox test → old-vs-new comparison → approval → ship

W12

Letting an agent into an existing ERP safely: permissions, approvals, audit

No real company is going to rewrite its ERP for your agent. The valuable skill is getting an agent safely into a system that already exists.

Taking over an existing system: inventory of API / database / UI capability, and business capability mapping
Wrapping ERP APIs as agent tools, an API-first strategy, with computer use covering the legacy gaps
RBAC least privilege, approval gates on high-risk actions, idempotency and double-submit protection, transactions and compensating actions
End-to-end audit trails, and permission attack testing
The exercise: have the agent find products likely to stock out in the next two weeks while demand is rising, generate a purchase recommendation, auto-create the PO when the amount is within its authority, and escalate to a manager when it is not — leaving a complete audit record either way

W13

Project iteration and office hours

What you ship

A complete, continuously deployed agent system that real users can reach and use — straight into your own portfolio

What comes with the cohortResources

This is not just a series of live lectures.

13 weeks of live teaching (fast track: 9)

August 15 to October 31; or on the fast track, August 15 to October 10 — adjusted once the cohort starts, based on the workload you want to take.

Live sessions run Saturday or Sunday, 3 hours each, with roughly 6–8 hours of lab work per week. Exact session times are announced before the start date and are set to work across US and Asia time zones.

Cloud sandboxes · GPU · ROS robotics environment

A Linux sandbox system built specifically for running and evaluating agents: compute and experiment data provisioned for you, with simulated real-world users driving performance tests.

Learner cloud sandbox list: an isolated Linux sandbox per person, with vCPU and memory allocated per course

Unified access to major model tokens + a cloud Claude Code IDE

One environment connecting Claude Code tokens (including Fable 5), GLM, Kimi and other major providers; every participant gets a hosted Claude Code environment to run labs in.

Parallight Center cloud IDE: Claude Code conversation on the left, lab list on the right

A dedicated Parallight MCP server

Our own MCP, running inside Claude Code and Codex: it sets up labs, loads them, and coaches you through them — resident in your editor, feeding you data and tracking your progress.

Parallight MCP setting up a lab inside Claude Code: one command lays down every file

A publishing channel for your own MCPs

We provide the servers and walk you through building and publishing your own MCP servers and skills to the world — which then counts as shipped work on your profile.

Repository list of MCP servers and skills published by learners

Automated evaluation on Parallight Agent Runtime

A sandbox evaluation system with real evaluation data: automated scoring on ML tasks, and Mini-SWE-Bench runs against your long-horizon software engineering agent (problem-solving rate, token spend and more). It records agent cost and context-window usage precisely — the reference you optimize the system against.

Agent run analysis: context window curve, cache reuse rate and a full tool-call ledger

50+ curated courses and a self-directed learning system

More than 50 AI and agent courses drawn from top universities and labs as supporting material; the self-directed learning centre reads your background and gives you personalized guidance, visual analysis and cloud sandboxes — so theory turns into practice immediately.

Knowledge galaxy and Agentist Advisor: a learning path built around your background

3 personal agents that give you time back

An ML training agent that tunes hyperparameters and drives GPUs on its own
A productivity assistant that manages OBS recording and edits video automatically
An automated stock trading agent (can connect to live Robinhood trading)

3 résumé-grade project experiences

LLM serving infrastructure for enterprise support — adapted from a project at a well-known US AI lab
A ROS2 and multi-modal agent control system for the UR5 robot — adapted from real work at a leading US robotics company
An agent upgrade and automation of an existing enterprise ERP — adapted from an airline-ticketing agent project at a US technology company

Your mentorsAbout your mentors

Marvin Gao

Founder & CEO of Parallight · teaches Phase 1 and Project 4 · weekly 1-1s

Studied computer science at Zhejiang University and Johns Hopkins University, and did reinforcement learning research at Peking University. Formerly a senior AI scientist at IBM, with work published in JMLR, IEEE TPAMI, ICRA and AAAI; creator of MARLlib, a widely used multi-agent reinforcement learning framework. The company he founded, KeploreAI, focuses on automated enterprise agent construction and most recently closed a pre-seed round at a $27M valuation. Over 2,000 engineers across 13 countries on four continents have trained in his and Parallight's programs.

ex-IBM senior AI scientist JMLR · TPAMI · ICRA · AAAI Zhejiang University · Johns Hopkins 2,000+ engineers trained

LinkedIn ↗ Full CV →

Howard Cao

Leads Project 5 (UR5 robot) and Project 6 (ticketing + ERP)

Studied computer science at the University of Houston and Johns Hopkins University, worked on robotics vision and AI engineering research at Amazon Robotics, and is now chief AI architect at KeploreAI. He has led work on robotic item picking, vision-based physical inspection, automotive intelligent automation and visual inspection agents, with a deep research background in computer vision and video understanding.

ex-Amazon Robotics · vision & AI Chief AI architect, KeploreAI University of Houston · Johns Hopkins Embodied AI · enterprise agents

LinkedIn ↗

Across the 13 weeks, Marvin teaches the weekly live session himself and answers questions live; every participant can book one 1-1 per week and bring whatever is genuinely stuck in their own project. Day to day, the Agentist Mentor and the TAs work alongside you in the online IDE; every Phase 2 project also comes with a TA-led weekend lab.

About usAbout us

Parallight Inc is an AI company based in San Mateo, in the heart of Silicon Valley. It runs Agentist, for engineers building up their agent capability, and Parallight Agent Runtime, a platform for evaluating enterprise agent performance. Its enterprise customers span the US and China, and its individual users span 14 countries.