Month 1 · LLM Applications
Day 1 — The Capability Map and a Working Lab
Published September 14, 2026
This is day one of a public bootcamp: 180 days of learning to build AI agents, one article per day, written as I work through the material. The goal of the series is not to collect tutorials but to produce a job-ready portfolio — and to show the learning path itself, including what gets confusing and what finally makes it click.
Day 1 has two jobs. First, replace the vague idea of "working with AI" with a map of what an AI Agent Engineer actually builds. Second, get a real environment running: a Python project, a key managed properly, and one successful call to an LLM API. Everything in the next 179 days stands on these two things.
The short answer
An AI Agent Engineer designs, orchestrates, evaluates and ships LLM-powered systems instead of training models. Day 1 maps the six layers of an agent system — model, tools, orchestration, knowledge, evaluation, safety — and gets a Python lab running with a first LLM API call.
What an AI Agent Engineer actually does
The role is application-layer engineering. An ML engineer trains and fine-tunes models; an agent engineer takes a model as a utility — the same way a web engineer takes a database — and builds reliable systems on top of it: designing how it plans, which tools it may call, what knowledge it can retrieve, how its output is evaluated, and what happens when it fails.
A useful mental model is six layers, each with its own concerns: the model layer (which LLM, which parameters), the tool layer (what the agent can do), the orchestration layer (how steps are sequenced and looped), the knowledge layer (RAG for documents plus memory for context), the evaluation layer (is the output actually good), and the safety layer (guardrails, approvals, rate limits). When something breaks in production, you debug by layer rather than staring at a prompt.
The learning path in one line
The full sequence for this bootcamp reads: Python → LLM API → Tool Calling → RAG → LangGraph → Memory → MCP → Multi-Agent → Evaluation → Observability → Safety → Production. The order is deliberate: tool calling before frameworks, RAG before agents, evaluation before production. Frameworks are the easy part; knowing why each layer exists is what interviews and incidents test.
| Month | Theme | Flagship output |
|---|---|---|
| Month 1 | LLM applications + RAG | Research agent + enterprise knowledge base |
| Month 2 | Agent engineering | Customer-service agent on a graph runtime |
| Month 3 | Production + job hunt | Observability, safety, portfolio polish |
Today's hands-on task
The lab takes under an hour if the steps are done in order. Create a dedicated repository (the series uses one repo for the whole bootcamp), set up an isolated Python environment with uv or venv, and add a .env file for secrets — the key goes there and nowhere else, and .env is in .gitignore before anything else happens.
Then make the first API call: a plain HTTP request or minimal SDK call that sends one prompt and prints the response, along with the token usage from the response metadata. That usage number is the day's real prize — from here on, every experiment has a visible cost.
- New repo, isolated environment (uv or venv), interpreter pinned.
- .env for the API key, .gitignore committed first — never a key in source.
- One LLM call from a script; print the text and the token usage.
- Write three sentences explaining what an agent engineer does, in your own words.
How an interviewer asks about today
Two questions come up on day one of almost every agent-engineering interview.
| Question | What a strong answer covers |
|---|---|
| How is an agent engineer different from an ML engineer? | Application layer vs model layer: design, orchestration, evaluation and shipping of agent systems — no model training involved. |
| What are the layers of a complete agent system? | Model, tools, orchestration, knowledge (RAG + memory), evaluation/observability, safety — with one sentence on each layer's job. |
Common mistakes on day one
- Starting with a framework. LangGraph makes sense on day 36, not day 1 — hand-rolling first is what makes frameworks legible later.
- Committing the API key. The .gitignore-first rule exists because rotated keys cost money and leaked keys end up in public scrapes within minutes.
- Skipping the usage field. From day one, every call should print tokens — cost awareness is an engineering skill, not an accounting chore.
Tools for this lesson
Frequently asked questions
- Do I need a GPU or an ML degree to become an AI agent engineer?
- No. The role is application engineering on top of hosted models — a normal laptop and an API key cover the entire learning path. What matters is engineering discipline: clean interfaces, evaluation, cost control and honest failure handling.
- How long does it take to become job-ready?
- This bootcamp budgets 180 days at four to six hours a day, built around three portfolio projects. The realistic range is three to six months of consistent work — the portfolio of working, documented systems is what gets interviews, not certificates.
- Which programming language should I use?
- Python. The ecosystem for LLM work — SDKs, RAG libraries, evaluation tools — is Python-first, and job descriptions expect it. JavaScript appears at the presentation layer, but the agent logic belongs in Python.
Part of a public learning journal — general educational content, not professional advice. See our disclaimer.