Kihagyás

AI Agents in 2026: Build, Deploy, and Scale — a teljes builder's roadmap

Szerző: AI Builder Club
Dátum: 2026. május 11.
Forrás: aibuilderclub.com/blog/ai-agents (8 perc olvasás)
Típus: single-page pillar guide ("AI Agents 101" kurzus 1.1 lecke)

A szerző központi tézise

Az AI agent nem framework, nem termék, nem buzzword — hanem egy 60 soros Python-minta: LLM + tool-ok + loop. A cikk célja, hogy a teljes 2026-os agent-fejlesztési tudást egy helyre gyűjtse: mit jelent az agent, hogyan működik a loop, mikor éri meg a framework használata, memóriakezelés, multi-agent rendszerek, MCP. Aki megírta a 60 soros loopot saját kezűleg, az minden keretrendszert trade-off-számításként lát, nem fekete dobozként.

A kurzus négy modulból áll: (1) Fundamentals — agent-definíció, function calling, memory, ingyenes AI Agents 101 sorozat; (2) Build From Scratch — a 60 soros Python loop, multi-agent koordináció, LangChain vs CrewAI vs raw API; (3) Tools & Infrastructure — MCP, context engineering; (4) Production — permission módok, sandboxing, harness engineering.

A cikk struktúrája

1. Mi az AI agent valójában?

Az AI agent három dolog + egy loop:

  • LLM, ami támogatja a tool use-t — Claude (Sonnet/Haiku/Opus), GPT-4o, Gemini 2.0+. A modell képes "az X függvényt Y argumentumokkal akarom hívni" típusú választ adni, nem csak szöveget.
  • Tool-ok — Python függvények, API-k, vagy MCP szerverek (read_file, search_web, query_db, charge_card).
  • Loop — user üzenet küldése, szöveg vagy tool hívás fogadása, tool végrehajtása, eredmény hozzáfűzése, visszaküldés, ismétlés amíg a modell kész nem nyilatkozik.

A memory, a planning, a reflection, a multi-agent orchestration — mindezek erre a három primitíve épülnek. A primitíveket először elsajátítani. Aki megépítette a loopot, annak minden framework érthetővé válik.

2. Hogyan működik az agent loop?

A minta minden implementációban azonos. A pszeudokód:

while not done and step < max_steps:
    response = llm.call(messages, tools)
    messages.append(response)
    if response.stop_reason == "end_turn":
        return response.text
    if response.stop_reason == "tool_use":
        for tool_call in response.tool_calls:
            result = execute_tool(tool_call)
            messages.append(result)

Öt sor a tényleges munka. A többi hibakezelés, observability és kényelmi funkció. A teljes Python implementáció a "how to build an AI agent from scratch" leckében.

A legfontosabb kezdő tanács: mindig cappingeld a max_steps-t. Egy összezavarodott agent capping nélkül örökké loopol és pénzt éget. 10-25 általában elég; riasztás, ha túllépi.

3. Framework-ök: mikor melyiket?

Három valódi opció 2026-ban:

  • Raw Anthropic/OpenAI SDK — single-loop agentekhez, tanuláshoz, full control-t igénylő produkcióhoz. Alapértelmezett választás. ~60 sor egy működő agenthez. Nincs vendor lock-in.
  • CrewAI — role-based multi-agent crew-okhoz ("Researcher → Writer → Editor"). ~30 sor egy működő pipeline-hoz. Content/research workflow-kra kiváló; minden másra kényszeredik.
  • LangChain — nehéz RAG-hez multi-store retrieval-jel, vagy 5+ előre épített tool integrációt (Notion, Slack, GitHub) igénylő projektekhez. Legnagyobb ökoszisztéma; legnehezebb dependency lábnyom; absztrakciós adósság.

Döntési fa: tanulsz vagy 1-3 ügynököt építesz → raw API. Role-based crew? → CrewAI. Nehéz RAG vagy sok tool integráció? → LangChain. Default: raw API.

4. Memory: mikor kell és mit használj?

Három minta, komplexitás szerint növekvő sorrendben:

  1. In-context memory — csak hozzáfűzöd a messages listához. Single-session agentekhez jó. Ingyenes.
  2. External file memory — JSON vagy markdown fájlba írsz, amikor az agent tanul valamit. Következő session elején beolvasod. Cross-session perzisztencia ~50K token memóriáig. Olcsó.
  3. Vector database memory — ChromaDB, Pinecone, Weaviate. Ha több száz tényt kell szemantikusan visszakeresni sok sessionön át. Csak akkor fizess érte, ha a fájlok kezelhetetlenné válnak.

A legtöbb első agent #1-nél megáll. A legtöbb produkciós agent #2-nél megáll. Vector DB-t a nap első napján bevezetni 90%-ban idő előtti optimalizálás.

5. Multi-agent rendszerek

Amikor egy agent nem elég, a működő minta a coordinator + workers, nem "agent-ek beszélgetnek egymással free-form chatben":

  • A coordinator agent fogadja a célt, eldönti mely specializált worker agenteket dispatcheli (gyakran párhuzamosan), összegyűjti az eredményeket, kezeli a hibákat, és szintetizálja a végső választ.
  • A workerek fókuszált promptokkal és specifikus tool-okkal dolgoznak — élesebb output, mint amikor egy generalista agent mindent megcsinál.

Három jel, hogy multi-agent kell:

  1. A feladat természetesen specializált szerepekre oszlik (research + writing + editing).
  2. Az al-feladatok ütköző system promptokat igényelnek.
  3. Az al-feladatokat párhuzamosan kell futtatni sebességért.

A multi-agent jellemzően 3-8x annyiba kerül, mint egy single-agent futás, és koordinációs felhajtást ad. Csak akkor fizess, ha mérhető wallclock- vagy minőség-nyereség van.

6. MCP és a tool-ökoszisztéma

Az MCP (Model Context Protocol) egy nyílt Anthropic standard, amely lehetővé teszi, hogy bármely LLM kliens konzisztens interfészen keresztül töltsön be custom tool-okat. 2024 végén jelent meg, 2026-ra támogatja a Claude Desktop, Claude Code, Cursor, Continue, Cody, Zed és egyre több kliens.

Miért fontos ez agent builder-eknek: ahelyett, hogy minden modell API-hoz custom integrációt írnál, építesz (vagy telepítesz) egy MCP szervert, és minden MCP-kompatibilis agent használhatja. A tool reuse compounds.

Gyakori hasznos MCP szerverek:

  • GitHub MCP — issue-k, PR-ek, commitok olvasása/írása
  • Linear MCP — feladatkezelés
  • Postgres MCP — adatbázis lekérdezés
  • Brave Search MCP — webes keresés
  • Filesystem MCP — kiterjesztett fájl-hozzáférés

Sajátot is építhetsz — a protokoll JSON-RPC stdio-n, és egy Python MCP szerver ~60 sor. Az MCP 101 a teljes walkthrough, az MCP internals a protokoll wire-szintű működését mutatja be.

7. Költség és produkciós szempontok

Az agent-ek valódi pénzt költenek produkcióban. Három költségkategória:

  • Per-session token költségek. Egy single-loop agent $0.05-$0.50 egy Sonnet 4.5 futáson. Multi-agent rendszerek $0.50-$5 per koordinációs futás.
  • Skála költségek. 1000 session/nap Sonnet-en = ~$30-$300/nap. Nagy léptékű produkciós agentek cost monitoring infrastruktúrát igényelnek (Datadog, Anthropic billing API alerts).
  • Mérnöki költségek. Observability matters. Logolj minden tool hívást, minden hibát, minden token költést. Erre szükséged lesz, amikor hajnali 2-kor elromlik valami.

Három legnagyobb költség-kar:

  1. Prompt caching — 90% kedvezmény a cached input token-ekre. Stabil system prompt + tool-ok = masszív megtakarítás multi-turn session-ökön.
  2. Model routing — Haiku egyszerű feladatokra (3x olcsóbb mint Sonnet). Opus csak akkor, ha kell.
  3. max_steps cap — megakadályozza a runaway loop-okat. Mindig cappingelj.

8. Gyakori buktatók (amiket el kell kerülni)

  1. A from-scratch lépés kihagyása. Ha LangChain-nel kezdesz, soha nem fogod mélyen érteni, mi történik. Először építsd meg a 60 soros loopot.
  2. Nincs max_steps cap. Összezavarodott agentek örökké loopolnak. Mindig cap 10-25.
  3. Homályos tool leírások. A tool leírás mondja meg a modellnek, mikor hívja az adott tool-t. "Read a file" rendben van. "Read a file using advanced parsing" félrevezeti a modellt.
  4. Python objektumok visszaadása a modellnek. A tool eredmények stringek (vagy JSON-szerializálható struktúrák) kell legyenek. Ne adj vissza nyers dict-eket objektumokkal.
  5. Framework-öket "best practice"-nek tekinteni. A legtöbb cég, ami produkciós agent-et futtat, kézzel írt loopot vagy vékony wrapper-t használ, nem framework-öt. A framework-ök eszközök, nem alapkövetelmények.
  6. Free-form agent-to-agent chat. Két agent nyílt beszélgetésben loopolni, hallucinálni fog, vagy tokent éget. Mindig legyen koordinátor explicit handoff-okkal.
  7. Observability figyelmen kívül hagyása. Az agent-ek csendben, finom módon hibáznak. Logolj minden tool hívást, minden eredményt, minden költséget. Auditálj, ha valami gyanúsnak tűnik.

9. Karrier: agent engineer-ként számító skill-ek

Az "agent engineer" felvevőpiac 2025-ben robbant be. Amit a cégek fizetnek, sorrendben:

  1. Agent-ek from-scratch, folyékonyan építése. A #1 felvételi jel. Ha nem tudod megírni a 60 soros loopot framework nélkül, nem tudod igazán hogyan működnek az agent-ek.
  2. Tool design. Jól definiált tool-okat írni a mérnöki munka fele. Rossz tool-ok = rossz agent-ek, a modellől függetlenül.
  3. Produkciós minták. Hibakezelés, max_steps cap, költség monitoring, observability, hibás kezelés. Ezek ritkábbak, mint kéne.
  4. Multi-agent orchestration. Koordinátor minták, párhuzamos dispatch, handoff protokollok.
  5. MCP szerver design. Újrahasználható tool szerverek építése, amelyek kliensek között működnek. Jövőbiztos skill.
  6. Framework literacy (LangChain, CrewAI, AutoGen). Kevésbé fontos mint az előzőek, de hasznos kódbázisok olvasásához és trade-off-ok értékeléséhez.

A "vibe coder, aki egyszer csinált egy chatbotot" nem kap felvételt. A mérnök, aki 3 produkciós agent-et szállított (hibakezeléssel, monitorozással, tiszta költség-fegyelemmel) — igen.

10. Kinek valók az AI agent-ek?

  • Szoftver mérnökök belső workflow-k automatizálására: code review agent-ek, test generátorok, deploy botok, customer support triage. Legmagasabb ROI 2026-ban — az agent-ek egész kategóriákat váltanak ki a glue code-ból.
  • Indie hackerek és solo alapítók: agent-ek drága SaaS-t helyettesítenek szűk workflow-kra (research, lead gen, data extraction). Olcsó leverage, ha meg tudod építeni.
  • Operations és analytics csapatok: data analysis agent-ek, reporting agent-ek, dashboard agent-ek. Multi-agent mintákkal jól játszik.
  • Kutatók és írók: research-and-write pipeline-ok masszívan profitálnak CrewAI-stílusú multi-agent beállításokból.

Nem mindenkinek való: az agent-ek még mindig flakysak magas megbízhatóságot vagy alacsony latenciát igénylő feladatoknál. Voice agent-ek, real-time customer support, bármi ahol 90%-os pontosság nem elfogadható. Építs nyitott szemmel.

11. Mit tanulj legközelebb?

  • Teljes kezdő: kezdj a "how to build an AI agent from scratch" - 60 sor Python, teljesen érthető. Aztán olvasd az AI Agents 101 Part 1-et a konceptuális mélymerüléshez.
  • Már építettél egy agent-et: olvasd el a framework összehasonlítást, mielőtt LangChain után nyúlsz. A legtöbb agent nem igényli.
  • Produkciós agent-eket építesz: adj memóriát (AI Agents 101 sorozat), és observability-t. Olvasd a "reduce API costs"-t — a minták átvihetők.
  • Multi-agent-re kész: Multi-agent system tutorial a koordinátor mintát 200 sorban.
  • Standardizált tool-ökoszisztémát akarsz: tanuld az MCP 101-et.

12. A lényeg (Bottom Line)

Az AI agent-ek nem framework, nem termék, nem buzzword. 60 sor Python-minta: LLM, tool-ok, loop. Ha egyszer megépítetted ezt a loopot saját magad, minden "agent framework" trade-off-számítás lesz fekete doboz helyett.

A skill-ek compound-olnak: from-scratch agent → framework literacy → memory → multi-agent → MCP. Minden lépés az előzőre épül. A legtöbb érték az első kettőből jön; minden ami ezen túl van, specifikus problémaformákra való.

Ha ezen a héten semmi mást nem teszel: írd meg a 60 soros agent loopot. Futtasd egy valódi feladaton. Hadd csináljon valami hasznosat a loop. A klaszter többi része itt van, amikor készen állsz.

A cikk gyakorlati kulcsmondatai

"An AI agent is a program that loops between calling an LLM and executing tools the LLM picks, until a goal is reached." — a szerző definíciója

"The 'agent' part is the loop, not the model." — a chatbot és az agent közötti különbség

"A chatbot replies with text. An agent replies with actions — calling APIs, querying databases, writing files, running code, executing transactions in the real world." — a chatbot vs agent

"The 'vibe coder who once made a chatbot' doesn't get hired. The engineer who has shipped 3 production agents (with error handling, monitoring, and clear cost discipline) does." — karrier-tanács

"Multi-agent typically costs 3-8x a single-agent run and adds coordination overhead. Pay it only when you get measurable wallclock or quality wins." — multi-agent ROI

"Default to raw API." — framework-döntés alapértelmezettje

Forrás

Vissza a tetejére