Agentic AI
16 stories tagged Agentic AI on Learning Fanatic.
- Lesson 1.2: The agent loop: observe, decide, act Follow an agent through its loop, and learn why small per-step errors compound, why context grows with every turn, and why every loop needs a limit.
- Lesson 1.1: Chatbots, workflows and agents Learn what separates a chatbot, a fixed workflow and an agent, how each handles the same request, and what the extra freedom of an agent costs.
- Lesson 1.4: The parts of an agent: model, tools, memory and instructions Learn the five parts every agent is built from, what each does, how they share a limited context window, and how to write the plan for an agent on one page.
- Lesson 4.1: Planning and breaking a goal into steps Learn how agents plan: plan first or step by step, how to write a plan with dependencies and checks, find the critical path, run steps in parallel and replan.
- Lesson 4.2: Reasoning patterns: ReAct, reflection and self-correction Learn the main ways agents reason: thinking before acting, ReAct, reflection, voting across samples and verification, and what each gains and costs.
- Lesson 1.3: Levels of autonomy and when not to use an agent Learn how much freedom to give an agent, how to compare designs by expected value per task, and when a simpler system or a person is the better choice.
- Lesson 3.1: Designing an agent from a job description Learn to design an agent the way you would define a job: duties, boundaries, tools, success measure and test cases, with the numbers that show whether it pays.
- Lesson 2.1: Tool calling and function schemas Learn how an agent uses a tool: the schema the model reads, the structured request it writes, how the harness validates it, and what invalid calls cost.
- Lesson 2.2: Designing tools an agent can use well Learn the design rules that make tools easy for an agent: one job each, sharp descriptions, small results, safe writes with idempotency keys and the right size.
- Lesson 2.3: Reading results, errors and retries Learn how an agent should handle what comes back from a tool: the kinds of error, when to retry and when not to, backoff, uncertain writes and loop guards.
- Lesson 2.4: Code execution, browsing and computer use Learn when an agent should run code, browse the web or operate a screen, what each costs in reliability and money, and how to sandbox and limit them.
- Lesson 3.2: Writing instructions and system prompts for agents Learn to write agent instructions that work: clear structure, specific rules with reasons, the right place for each rule and tests that tell versions apart.
- Lesson 3.3: Frameworks, SDKs and building without them Learn what agent frameworks and SDKs do for you, what they cost, how to choose between them and your own small harness, and how to avoid lock-in.
- Lesson 3.4: Hands-on: build a first agent step by step Build a complete first agent from scratch: tools with permissions, validation, a loop with limits, a test set and a plug-in point for a real model.
- Lesson 4.3: Managing context: short-term memory and summaries Learn to keep an agent's context useful as a run grows: trimming, sliding windows, rolling summaries, pinned notes and offloading, with the token arithmetic.
- Lesson 4.4: Long-term memory and retrieval Learn how agents remember across sessions: what to store, how to retrieve it by similarity, recency and importance, how to maintain it and how to keep it safe.