このページの主な内容は英語です。このページを翻訳

AIと注目トピック

AI Agents roadmap

AI agents are models in a loop that can call tools, observe results and decide what to do next. Learn the agent loop from scratch, add tools, memory and guardrails, evaluate agents properly, and build multi-agent systems only when they help.

時間: ⏱ 3–4 weeks
Level: Intermediate
Steps: 6 steps
Progress: 0/6 done

The roadmap

Click a step to open the full guide.

Best architecture: a production AI agent

An agent loop wrapped in guardrails, memory and observability.

Agent architecture

Task intake (UI / API / schedule)
Agent loop: plan → act → observe
Tools (MCP) · retrieval · code sandbox
Policy & approval layer
Memory / state store
Tracing · evals · budgets

Why it's built this way

The policy layer sits between the agent and any tool with side effects.
State is saved so tasks can pause for approval and resume.
Budgets (steps, tokens, money) are enforced outside the model.
Traces of every step feed debugging and evals.

AI Agents cheat sheet

The essentials on one screen. Bookmark it for revision.

Agent anatomy

Model	The 'brain' that decides the next step
Instructions	Goal, rules, when to stop, output format
Tools	Functions it can call (via API or MCP)
Loop	think → act → observe → repeat
Memory	Context + summaries + long-term store
Guardrails	Limits, approvals, validation, logs

Design rules

Start simple	Workflow first; agent only where needed
Few good個のツール	One job each, clear descriptions
Hard limits	Steps, time, tokens, money
Approve writes	Human yes for send/pay/delete
Trace everything	Debug from the first wrong step
Evaluate	Task suite with success rate

Improve performance

Use a smaller, faster model simple routing or extraction steps and a strong model for planning.年版
Run independent tool calls in parallel when the model requests several at once.
Keep tool outputs short and summarise long histories to control context size.
Cache tool results (e.g. the same search) within a task.
Stop early: tell the agent exactly what 'done' looks like.

Security checklist

Least-privilege tools: read-only by default, scoped credentials per user.
Human approval for any action with real-world effects.
Treat all external content as untrusted (indirect prompt injection).
Run agent-written code only in an isolated sandbox with no secrets.
Budgets and step limits on every task, plus a manual kill switch.
Log full traces for auditing and incident review.

Most important interview questions

Click a question to see a strong answer. Each step also has its own questions.

1an AI agentとは？

A system where an LLM runs in a loop with tools: it decides which action to take, observes the result and continues until the goal is complete.

2What are the core components of an agent?

A model, instructions, tools, a control loop, memory/state, and guardrails (limits, approvals, validation, logging).

3the ReAct patternとは？

Interleaving reasoning and acting: the model thinks about what to do, takes an action with a tool, observes the result, and repeats.

4Why do agents fail, and how do you fix it?

Common causes: unclear goals, poorly described tools, too much context, missing stop conditions, and tool errors. Fix by tightening instructions, improving tool descriptions, summarising context and evaluating on a task suite.

5How do agents use MCP?

The agent's host connects to MCP servers, discovers their tools and offers them to the model, so the agent can use many external tools without custom integrations.

6How do you control the cost of an agent?

Step and token budgets, smaller models for simple steps, short tool outputs, caching, parallel calls, and clear stop conditions.

7Agent frameworks: when to use one?

After you understand the basic loop. Frameworks help with tracing, memory, retries and multi-agent orchestration, but add abstraction; keep the core logic simple and testable.

Related件のロードマップ

MCP: Model Context Protocol

5 steps · 2–3 weeks · Intermediate

Connect AI apps to tools and data with one open standard.

View roadmap →

RAG: Retrieval-Augmented Generation

6 steps · 3–4 weeks · Intermediate

Build AI that answers from your own documents.

View roadmap →

AI Engineer

6 steps · 4–6 months · Intermediate

Build products on top of large language models.

View roadmap →

Forward Deployed Engineer (FDE)

6 steps · 4–6 months (for working developers) · Intermediate

Build AI solutions directly with customers.

View roadmap →

AI Agents · Step 2 of 6 · 3 days

Build the agent loop from scratch

Understand every moving part.

Most model APIs support tool calling: you describe tools, the model replies with a tool call, you run it and send back the result, and the model continues. Wrap that in a loop with a maximum number of steps.

Writing this yourself once makes every agent framework easy to understand and debug.

What you'll learn

Tool definitions (name, description, schema)
Sending tools to the model
Executing tool calls
Feeding results back
Stopping conditions
Step and cost limits

Think → act → observe

Model reads goal + history
Chooses a tool
Your code runs it
Result added to history

Repeats as a loop

Key concepts

Tool call: A structured request from the model: tool name + arguments.
Tool result: What your code returns, sent back so the model can continue.
Step limit: A maximum number of loop iterations to prevent runaway cost.

Step by step

2.1
Describe個のツール
Name, description and JSON schema for each tool's inputs.
2.2
Call the model with個のツール
Send messages plus the tool list.
2.3
Execute requested個のツール
Validate arguments, run the function, capture the result or error.
2.4
Loop with limits
Append results, call the model again; stop on final answer or limit.

# The agent loop (pseudo-code; adapt to your provider's tool-calling API)
messages = [system("You are a helpful agent."), user(task)]
for step in range(8):                      # hard step limit
    reply = llm(messages, tools=TOOLS)
    messages.append(reply)
    if not reply.tool_calls:               # model is done
        print(reply.text); break
    for call in reply.tool_calls:
        result = run_tool(call.name, call.arguments)  # validate inputs!
        messages.append(tool_result(call.id, result))
else:
    print("Stopped: step limit reached")

Notes

Always cap the number of steps and total tokens.

Tips & tricks

Log the model's tool choice and arguments at every step.

Interview questions

Walk me through how tool calling works.

You send the model the conversation and tool schemas. It replies with a tool call (name + arguments). Your code validates and executes it and sends the result back. The model continues until it returns a final answer.

How do you handle a tool error inside the loop?

Catch it and return a short, clear error message as the tool result so the model can retry with different arguments or choose another approach, while counting it toward the step limit.

The quick way to study this

Implement the loop below with a calculator and a search tool.

Practice project

A research agent that searches the web and writes a cited summary.

How to build an AI agent (full guide) →