<img height="1" width="1" style="display:none" src="https://www.facebook.com/tr?id=2572935303135173&amp;ev=PageView&amp;noscript=1">
Live online intensiveDecember 2026 cohort · Early bird open
MIT
For engineers and technical leaders · Software Design Group, MIT CSAIL

AI Engineer
Intensive

A 9–10 week Intensive for Builders

AI engineering, taught in the order that lasts.

Three modules from the Software Design Group at MIT CSAIL. Design principles that don't age. Systems architecture that refreshes with the industry. Engineering for speed and security that moves at its pace. Taken together, as one program, in the order that makes each layer last.

Live online · Starts December 2026 · Three modules, one program · All sessions recorded

Tuition$3,995 early bird (standard rate $4,500) · until the 20 places are taken

Co-led by
Prof. Daniel Jackson
Prof. Daniel JacksonMIT CSAIL
Eagon Meng
Eagon MengMIT CSAIL

A technology collaboration: the Software Design Group at MIT CSAIL and NGL, a new technology start-up.

LIVE Prof. Daniel Jackson + Eagon Meng
APPLIED One system you genuinely want to build
TAKE FORWARD Your system designed, deployed, hardened and cheaper to run
The program

Three modules, one program.

You bring one system you want to build and take it through all three modules, in order. Each module teaches a layer of AI engineering that ages at its own speed, so each one refreshes on its own schedule, and alumni come back only for the parts that move.

The program, in one picturePrinciples first, technology last
1Design module2.5 weeks

AI design: principles

Specify what an AI system should do, precisely enough that people and agents build the same thing.

You leave with Your system, specified A concept design and spec to build from
Nearly evergreen
2Systems module3–4 weeks

AI systems: design to implementation

Learn the current technologies, from RAG and graphs to agents and workflows, and which ones your design calls for. Then deploy.

You leave with Your system, deployed Architected for reasons you can defend
Updated as new tools settle
3Engineering module3–4 weeks

AI engineering: efficiency & security

Make the system secure and cheaper to run: principles first, then dealing with new threats and applying the latest optimizations.

You leave with Your system, hardened Benchmarked and cheaper to run
Core stable, frontier rebuilt every cohort
One program, one fee. You take all three modules together and in order, for $3,995 at the early bird rate. Modules aren't sold separately.
The situation

You can build with AI. That's not the same as engineering it.

Five things builders say out loud. Each traces back to the same missing layer, and each one maps to a module.

01

“I can ship a demo in a weekend. I can't defend it in production.”

The demo worked because you chose the five paths it would take. Production chooses its own. What's missing isn't more code — it's a specification precise enough to say what correct even means.

Resolved in1Design module
You define what correct means before a line of code exists — so production behavior is checkable against the design, not against the demo.
02

“Every six months, my stack knowledge resets to zero.”

You learned the framework, not the reasoning that made it the right choice. So when the framework changes, everything you know changes with it. It feels like staying current. Structurally, it's starting over.

Resolved by the structure1Design module2Systems module
Once the Design module's principles are yours, a new framework is a change of syntax. The Systems module's refreshes carry you across each shift, with only the new parts left to learn.
03

“I know how to use RAG. I couldn't tell you when not to.”

Tutorials teach the how. So stacks get assembled by buzzword: a vector database because everyone has one, an agent framework because it launched loud. Nobody teaches the why — when retrieval beats a graph, when a workflow beats an agent, and what property of the design makes it so. Without the why, every architecture decision is a coin flip that compounds.

Resolved in2Systems module
Architecture chosen from the properties of your design — when retrieval, when structure, when orchestration — so the stack is a set of reasons, not a set of trends.
04

“Security is the ticket I keep moving to next sprint.”

Prompt injection, data exfiltration, tool misuse — the attack surface of an AI system is new, moving fast, and mostly undocumented in the tutorials you learned from. It gets bolted on last because nobody taught it as part of the build.

Resolved in3Engineering module
Threat models enter with the build, on a stable engineering core — and the module's frontier half covers the latest threats and how to deal with them.
05

“The AI bill scales faster than the product.”

Every re-prompt, every oversized context, every model call that a cheaper path could have handled — the invoice is where an unexamined design becomes a number. Efficiency isn't an optimization pass. It's a consequence of decisions made much earlier.

Resolved in1Design module3Engineering module
You set cost structure where it's decided, in the design, then engineer it down in the Engineering module with the current generation of optimizations.

They are one problem. The technology was taught first, and the thinking that outlives it was never taught at all.

The premise

The tricks you learned in 2023 have already expired.

Since 2023, most AI techniques and tools have lasted a few months. Architecture patterns have lasted a year or two before changing shape. The design principles underneath have held the whole time. A curriculum written once can't keep pace with the top of that stack, so this program refreshes each layer at the rate it changes and anchors all of it to the layer that holds.

What AI builders had to learn, 2023 to now Illustrative. Dates are approximate.
Techniques and toolsLasted months

8K-context chunking, regex output parsing, “think step by step” prompts and chatbot plugins were all replaced by 2025.

In the program3Engineering moduleFrontier rebuilt every cohort
Architecture patternsChange shape every year or two

Retrieval went from chunk-and-embed RAG to agentic search. Agents went from single loops to multi-agent orchestration.

In the program2Systems moduleUpdated as new tools settle
Design principlesHeld throughout

Say what the system should do, define what correct means, keep concepts independent.

In the program1Design moduleNearly evergreen

Once the principles are yours, each new cycle asks you to learn only what's new: the syntax, the flows, the shape of this generation's tools.

The three modules

What you learn, what you build, and how long it lasts.

Each module builds on the one before. You design a system in the Design module, architect and deploy it in the Systems module, and make it secure and cheaper to run in the Engineering module. Each one ends with working artifacts.

1Design module 2.5 weeks Nearly evergreen

AI design: principles

Agents now write code faster than anyone can review it, so the design is where your leverage sits. With a precise design, you, your team and your agents build the same system and can check it against one definition of correct. With a vague one, you get plausible code that does the wrong thing, faster.

Concept design gives you a way to be that precise. You describe the system as a set of concepts: small, independent units of behavior, each with one purpose. Because concepts don't depend on each other, you can specify, build and test each one on its own, and so can an agent.

Daniel Jackson developed concept design at MIT and set it out in his book The Essence of Software (Princeton University Press, 2021). It's also the method at the center of the MIT CSAIL Agentic AI Intensive, where leaders learn to specify systems that others build. This module teaches it from the builder's seat, because you build the system yourself in the next two modules.

  • Specify what an AI system should do, precisely enough that people, agents and machines build the same thing
  • Break a system into independent concepts, the kind of modularity AI code generation needs
  • Decide what the system must refuse to do, and make correctness checkable before a line of code exists
You leave withA complete concept design and specification for the system you intend to build
Next:2Systems modulearchitects and deploys it
2Systems module 3–4 weeks Updated as new tools settle

AI systems: design to implementation

Take your design and work out the best way to architect and deploy it. You learn how the current technologies work, from RAG and graphs to agents and workflows, and above all the why: which properties of your design call for which architecture, so each decision rests on reasoning you can defend.

The faculty keep the module in step with industry practice and update it once new technologies establish themselves. The reasoning stays the same from one update to the next; the tools it points to change.

Eagon Meng teaches this module alongside fellow MIT researchers who work on AI system architecture.

  • Map design properties to architecture choices: when retrieval, when structure, when orchestration, and why
  • Deploy the system your design specifies, with the tradeoffs explicit and defensible
  • Build systems judgment that survives paradigm shifts, because it never depended on one paradigm
You leave withYour design, architected and deployed as a working system
Next:3Engineering modulehardens it and cuts its cost
3Engineering module 3–4 weeks Core stable, frontier rebuilt every cohort

AI engineering: efficiency & security

You have the design and a deployed system. Now you make it secure, fast and cheaper to run.

Eagon Meng teaches this module alongside fellow MIT researchers who work on AI security and efficiency.

  • Threat-model an AI system against prompt injection, data exfiltration and tool misuse, and build the defenses into the system
  • Measure cost and latency, then bring both down without giving up correctness
  • Judge each new attack or optimization against principles you already hold, in the week it appears

Security and efficiency share a shape. Each rests on a few principles that hold for years, and each gets a steady stream of new specifics: a new attack and its fix, a new model tier, a new caching feature. The faculty built this module in the same shape, which makes it the whole program in miniature.

Weeks 1–2: the coreStable Weeks 3–4: the frontierRebuilt every cohort
Security Trust boundaries and least privilege for agents and tools. Threat modeling. Treating model output as untrusted input. The newest attack routes and their fixes, such as injection through tool results and retrieved documents, or leaks through agent memory.
Efficiency Cost structure set in the design. Evaluation before optimization. Context budgets, and routing each task to the cheapest model that can do it. What shipped since the last cohort, such as new model tiers and pricing, caching and batching features, and faster inference options.
Frontier Refresh

Weeks 3–4 are built to be retaken. Alumni can rejoin them in any later cohort at an alumni rate and catch up on what changed. See how returning works
You leave withYour system hardened, benchmarked and cheaper to run, with the practice to keep it that way
Then:come back for each new frontier
How it builds

Each module makes you something. The program makes you all three.

One program, three capabilities, built in sequence. You don't choose between them — by the end of the intensive, all three are yours.

After the 1Design module

The designer

Design and specify AI systems with rigor. You can hand a build to a team, an agent, or your future self — precisely.

2.5 weeks in
After the 2Systems module

The systems builder

Design it, then architect and deploy it yourself — choosing RAG, graphs or workflows because you can say why, not because a tutorial did.

6–6.5 weeks in
After the 3Engineering module

The Agentic AI Engineer

The full stack: designed, deployed, then secured and optimized at scale. The complete discipline, in the order that makes each layer last.

9–10 weeks · the whole program
The three modules are one program, taken together, for one fee: $3,995 at the early bird rate, reduced from the $4,500 list price. Modules are not sold separately.
Designed for return

Take it once. Come back for the parts that move.

Your first cohort covers the whole program. After that, you retake only what changed, at an alumni rate.

Your first cohortThe full program, 9–10 weeks
Frontier RefreshAny later cohort: weeks 3–4 of the Engineering module
Systems refresherWhen the industry shifts paradigm

1You never retake the Design module. The principles stay yours.

Faculty

Taught by the people whose research this is

This curriculum isn't assembled from the industry's content. The Design module comes from the Software Design Group's own research on concept design, and the Systems and Engineering modules bring in MIT researchers who work in those fields.

Prof. Daniel Jackson
1Design module anchor · Concept design's inventor

Prof. Daniel Jackson

Associate director, MIT CSAIL · author of The Essence of Software

One of the most cited researchers in software design, Daniel created concept design as a rigorous way to describe what systems do, in language every stakeholder — human or agent — can build from. The Design module is that method, taught from the builder's seat by the person who invented it.

Eagon Meng
23Program co-lead · Systems & Engineering modules

Eagon Meng

PhD candidate, MIT CSAIL Software Design Group

Eagon co-leads the intensive with Daniel. His doctoral research looks at the translation layer between design intent, agent behavior and running systems. In the Systems and Engineering modules, he teaches alongside fellow MIT researchers who work on architecture, security and efficiency.

Why this matters: when a program's later modules must refresh with the industry, the question is who does the refreshing. Here, it's MIT researchers selected for those modules, and the group can change as the field moves.
Who this is for

If you recognize one of these, this was built for you

You're the engineer who gets handed the AI projects, and you're tired of every one starting from a blank prompt and a prayer
You've built prototypes that impressed everyone and shipped nothing, and you suspect the gap isn't your code
You're a technical leader who needs your team choosing architectures by reasoning, not by whatever launched last month
You completed the Agentic AI Intensive as a leader, and now you want the builder's version of the same rigor
You want a skill set with compounding value — where next year's learning stacks on this year's instead of replacing it

What this is not

Not a tool tour

No survey of frameworks, no catalog of vendors, nothing that expires with the next release cycle. Technologies appear where the design demands them — as consequences, not curriculum.

Not built for a moment

This optimizes for the tenth year, not the first sprint: principles that hold, systems judgment that transfers, and a frontier module built to be retaken as the field moves.

Not a lecture series

Every module is applied to the one system you're building. You leave the Design module with its design, the Systems module with it deployed, and the Engineering module with it fast, cheap and hardened. The exercises are your work.

Not a fixed curriculum

Anything designed once is a snapshot of a moving field. This intensive is versioned like the systems it teaches: evergreen at the base, refreshed at the pace of the industry above it.

Format & details

The details

Starts
December 2026. Live online, cohort-based. 20 early bird places are open now, and a $200 deposit holds yours.
Structure
Three modules, one program. The Design, Systems and Engineering modules, taken together and in sequence. Modules are not sold separately.
Duration
Design: 2.5 weeks. Systems: 3–4 weeks. Engineering: 3–4 weeks. The full program runs 9–10 weeks, live online, all sessions recorded.
Commitment
9–12 hours per week, a portion of it live. Every exercise is applied to the system you're building, so the exercises are your work.
AI support
Paski, your AI tutor, works with you throughout. It holds the context of your system across all three modules, writes you a personalized recap after every live session, and works alongside you from specification through deployment to hardening.
Refresh model
Versioned like software. The Design module is nearly evergreen. The Systems module is updated as new technologies establish themselves. The Engineering module's frontier half (weeks 3–4) is rebuilt every cohort, and alumni can retake it as a Frontier Refresh.
Tuition
$3,995 for the full program at the early bird rate, reduced from the $4,500 list price. One fee covers all three modules. Invoiced by NGL; alumni rates apply to the Frontier Refresh and to Systems or Engineering module retakes in later cohorts.

Early bird rate shown · The $200 deposit is credited to tuition · Full refund available until the cohort begins.

Questions

Asked often

Do I have to take all three modules?

Yes — the intensive is one program, and the three modules are taken together, in sequence. The Design module makes you a rigorous designer of AI systems. The Systems module lets you architect and deploy what you design. The Engineering module lets you run it fast, cheap and secure at scale. Each layer stands on the one before it, which is why the modules aren't sold separately.

How does applying and the deposit work?

Two quick steps, about two minutes: your details, then a few questions on the next page. You're approved instantly if you meet the cohort criteria, then a $200 deposit by card holds your place at the $3,995 early bird rate (standard rate $4,500). The deposit is credited to your tuition and fully refundable until the cohort starts.

I took the Agentic AI Intensive. Is the Design module the same thing?

It's the closest mirror — the same concept design method, from the same group — but redesigned for the builder's seat. The Agentic AI Intensive teaches leaders to specify systems others will build. The Design module teaches builders to specify the systems they will build themselves, which changes what precision is for and what you do with it in the Systems and Engineering modules.

Won't the technical content go stale?

Parts of it will — on schedule, by design. The program is versioned the way good software is: the Design module is nearly evergreen, the Systems module refreshes periodically once technologies establish themselves, and the Engineering module is split between a stable core and a frontier half rebuilt every cohort. Most programs pretend their content doesn't age. This one is architected around the fact that it does.

Can I come back and retake modules?

Yes, and the program expects you to. The Design module's principles never need retaking. The Systems module is worth a refresher when the industry shifts paradigms. The Engineering module's frontier half is new every cohort, and alumni can come back for those two weeks as a Frontier Refresh, at an alumni rate. That's how you stay current on the latest optimizations and security concerns.

How technical do I need to be?

The Design module requires no engineering background — if you can describe how a system should behave, you can design it. The Systems and Engineering modules are hands-on builder modules: you should be comfortable working with code and modern AI tooling, though the point is the reasoning, and Paski works alongside you throughout.

What do I bring?

One system you genuinely want to build — a product, an internal tool, an agentic workflow. Everything in all three modules is applied to it: you design it in the Design module, deploy it in the Systems module, and harden it in the Engineering module. You will not work on toy examples.

How does this stay relevant when the field moves so fast?

There is a lot of good AI engineering material available, and every program faces the same structural challenge: the field moves faster than any curriculum designed upfront. This program doesn't try to outrun that — it's structured so it doesn't have to. The principles you learn in the Design module barely age, and everything above them is a technology transfer refreshed at the pace of the industry, seamless because it builds on principles you already own. Staying current means learning only the genuinely new: syntax, flows, this cycle's tools. The structure is the difference.

December 2026 cohort · Early bird

20 early bird places. $200 reserves yours.

Two quick steps, about two minutes. Approved instantly if you meet the cohort criteria, then the $200 deposit by card holds your place.

Early bird rate: $3,995 · Standard rate $4,500 · One fee, all three modules.
Reserve your place →See the three modules

The $200 deposit is credited to your tuition and fully refundable until the cohort starts.

Reserve your place →