Everything you need to build serious agentic AI.

Once you understand the building blocks (prompt → RAG → tools → guardrails → swarms), the next question is "what do I actually use to build this?" There are four broad pathways. Pick by your team's skills and how much control you need — not by hype.

Side-by-side: the major open-source frameworks

All of these are free and open-source. Most are Python-first, a few have strong JS/TS or .NET stories. None of them are "best" — they're optimized for different jobs.

AgentSwarms is the visual + code-friendly middle ground. Under the hood, every agent is a row in a database with a system prompt, a model, optional tools, and an optional knowledge base. Every swarm is a typed graph of those agents with routed handoffs. Nothing proprietary — you can export and run it elsewhere.

{
  "schemaVersion": "1.0.0",
  "name": "Research Swarm",
  "nodes": [
    {
      "id": "researcher",
      "type": "agent",
      "agent": {
        "provider": "openai",
        "model": "gpt-5",
        "systemPrompt": "You find sources and return JSON.",
        "tools": ["search_web", "fetch_url"]
      }
    },
    {
      "id": "writer",
      "type": "agent",
      "agent": { "provider": "anthropic", "model": "claude-3.7", ... }
    },
    { "id": "reviewer", "type": "agent", "agent": { ... } }
  ],
  "edges": [
    { "from": "researcher", "to": "writer" },
    { "from": "writer",     "to": "reviewer" }
  ]
}

Concept 03 introduced tools. This section goes one level deeper: the categories of tools you'll actually build, the lifecycle of a single tool call, and how to design tools that don't blow up in production.

The 6 categories of agent tools

Every tool you'll ever build falls into one of these buckets. Knowing the bucket tells you how to design it (idempotent? gated? cached?) and how risky it is.

The lifecycle of a single tool call

A "tool call" is not just function(args). It's a six-step round-trip between the model and your runtime. Skip a step and you'll ship bugs that look like LLM hallucinations but are actually plumbing.

1. 1Step 1

   Describe

   You define the tool's name, params, and a one-sentence description. The model only sees this — make it crisp.

2. 2Step 2

   Expose

   The runtime sends the tool list with every model call. Keep the list small (<15) per turn for best accuracy.

3. 3Step 3

   Decide

   The model emits a tool_call with structured arguments — no execution yet, just intent.

4. 4Step 4

   Validate

   Your runtime validates args (schema, policy, budget, HITL gate) before doing anything.

5. 5Step 5

   Execute

   Run the tool. Apply timeouts, retries, and observability. Capture cost + latency.

6. 6Step 6

   Return

   Send a structured tool_result back to the model. It plans the next step or replies to the user.

{
  "name": "issue_refund",
  "description": "Refund a customer order. Use ONLY when the user explicitly asks for a refund and you have an order_id. Refunds over $100 require human approval.",
  "parameters": {
    "type": "object",
    "properties": {
      "order_id":  { "type": "string", "description": "The internal order id, e.g. 'ord_123'" },
      "amount":    { "type": "number", "description": "Refund amount in USD" },
      "reason":    { "type": "string", "enum": ["damaged", "wrong_item", "late", "other"] }
    },
    "required": ["order_id", "amount", "reason"]
  }
}

In AgentSwarms, tools are first-class objects. You attach them to an agent, the runtime validates calls, executes them with tracing, and routes the structured result back to the model — exactly the lifecycle described above.

Agent

An LLM with a system prompt, optional tools, and memory — capable of multi-step reasoning toward a goal.

RAG

Retrieval-Augmented Generation. Inject relevant chunks from your docs into the prompt so the model can cite real sources.

Tool / Function call

A typed action the model can invoke (search_web, send_email, query_db). The agent decides when to call it.

Guardrail

Rules that filter input or output — PII redaction, profanity blocks, schema validation, cost caps.

HITL

Human-in-the-Loop. Agent pauses for human approval before doing something risky.

MCP

Model Context Protocol. A standard way to expose tools and data to any compatible agent.

Swarm

Multiple specialized agents that hand off work to each other.

Eval

A test suite for agents. Score outputs on accuracy, format, safety, cost — not just vibes.

Embedding

A numeric vector representation of text. Similar meanings → similar vectors.

Vector store

A database that indexes embeddings for fast similarity search (Pinecone, Weaviate, pgvector).

Token

A chunk of text the model reads/writes. ~4 chars in English. You pay per token.

Temperature

0 = deterministic, 1 = creative. Lower for facts, higher for brainstorming.

Few-shot

Including examples of input→output pairs in the prompt to shape behavior.

Chain-of-thought

Asking the model to reason step-by-step before answering. Improves hard tasks, costs more tokens.

Prompt injection

User input that tries to override the system prompt. Treat as inevitable; design tools defensively.

LLM-as-judge

Using one LLM to grade another's output. Cheap eval, but bias-prone.