How to build and train an agentic AI agent.

An agentic AI is a model that doesn't just answer a single prompt — it perceives a goal, plans the steps to reach it, calls tools, observes the results, and self-corrects until the task is done. Think of the difference between a calculator (one input, one output) and an apprentice who can be told "file these invoices and flag the duplicates" and figure out the rest.

Building one of these agents is less about a single magical model and more about a disciplined training loop: a clear task, a capable base model, well-curated practice data, tight feedback, and ruthless evaluation. The fundamentals are the same whether you're training a customer-support agent, a code-review bot, or a research assistant.

Every agent we've shipped on Kojen — and every successful agent our customers have shipped — has gone through roughly the same seven steps:

1. Define the task with measurable success criteria.
2. Pick a base model that fits the task's reasoning and latency budget.
3. Curate data — instructions, tool traces, and demonstrations.
4. Train through katas — small, repeatable practice exercises.
5. Run sensei feedback loops — supervised correction from a stronger model or a human.
6. Evaluate against a held-out test set before shipping.
7. Deploy and continuously learn — capture real traffic, label edge cases, retrain.

The rest of this guide unpacks each step.

Most failed agents fail here, not in training. A useful task definition answers four questions in writing:

• What input does the agent receive? A user message, a webhook payload, a row in a queue?
• What tools and data can it call? Be exhaustive — every API, every read-only datastore, every action it can take in the outside world.
• What does "done" look like? A returned JSON object? A closed ticket? A pull request merged?
• What's the explicit failure mode? When should the agent escalate, refuse, or hand off?

Write a one-page task spec. If you can't, the agent can't either.

You almost never train an agent from scratch. You start from a capable open-weight base (Llama, Mistral, Qwen, etc.) or a hosted frontier model with fine-tuning support, and you specialize it. Three things determine the right base:

• Reasoning depth — multi-step planning needs a model that scores well on reasoning benchmarks, not just chat quality.
• Tool-use fluency — pick a base that already speaks function-calling cleanly; teaching the format from zero burns a lot of compute.
• Latency and cost ceiling — an agent that calls itself 10 times per task multiplies your token bill by 10. Profile before you commit.

When in doubt, start small. A well-trained 7B model beats a badly-prompted 70B model on a narrow task, and it ships at a tenth of the cost.

Agentic training data is not just question-answer pairs. It's full trajectories: a goal, the agent's intermediate thoughts, every tool call, every observation, and the final outcome. You'll typically combine three sources:

• Expert demonstrations — humans (or a frontier model) doing the task end-to-end, captured as trajectories.
• Synthetic rollouts — let a capable model attempt the task in a simulated environment, then filter for successful runs.
• Production traces — once you ship a v0, real user interactions become the richest dataset you'll ever have.

Quality matters far more than quantity. A thousand clean trajectories with verified outcomes will outperform a hundred thousand noisy ones every time.

A kata is a small, repeatable training exercise that targets a single capability — the same way martial artists drill the same stance until it becomes reflexive. Instead of training one giant model on one giant dataset, you compose the agent's behavior from many tightly-scoped katas:

• A tool-selection kata: given a goal, pick the right tool.
• A recovery kata: given a failed tool call, decide whether to retry, switch tools, or escalate.
• A format kata: produce strictly valid output for the downstream consumer.
• A refusal kata: when the task is out of scope, refuse cleanly.

Each kata has its own dataset, its own success metric, and its own pass/fail bar. Models that train kata-by-kata generalize better and regress less than models trained on one undifferentiated pile.

A sensei is the stronger model (or human) that grades the student's attempts. The training loop looks like:

1. The student model attempts a kata.
2. The sensei reviews the trajectory and produces a critique plus a corrected version.
3. The corrected trajectory is added to the next round of fine-tuning data.
4. Repeat until the student passes the kata's bar on a held-out set.

This is the same idea behind RLHF, DPO, and the various self-improvement loops in the literature — the sensei is just a concrete name for "whatever produces the preference signal." Pairing a fast student with a careful sensei is usually cheaper and more controllable than running RL from scratch.

A trained agent that hasn't been evaluated is a liability. At minimum, build three evaluation suites:

• Capability evals — does the agent succeed on held-out tasks across each kata?
• Regression evals — does the new checkpoint still pass everything the previous one passed?
• Safety evals — adversarial prompts, prompt-injection attempts, and out-of-scope requests where the right answer is to refuse.

Track every metric per checkpoint. Ship the checkpoint that wins on the eval that matters most for your task, not the one with the best loss curve.

Shipping is the start of training, not the end. Three things must be in place from day one:

• Trajectory logging — capture every input, tool call, and output, with consent and PII handling baked in.
• Failure triage — route any trajectory the agent flagged (or that the user thumbs-downed) into a review queue.
• A retraining cadence — weekly or monthly, take the new failures, run them through the sensei, fold the corrections into the next checkpoint.

Done well, the agent gets measurably better every release. Done badly, it drifts as the world changes and you don't notice until a customer complains.

• Skipping the task spec. If success isn't measurable, training isn't possible.
• Training on chat data for an agent task. Chat data teaches the model to talk, not to act. Use trajectory data.
• One giant kata. Breaking the behavior into small, drilled katas is what gives agents reliability.
• No regression suite. Every fine-tune subtly regresses something. Without a regression eval, you'll find out in production.
• Ignoring tool-call latency. A correct agent that takes 90 seconds is a broken product.