How to Run an AI Agent for $0 in 2026: Models, Search and Vector DB

An agent is a loop: the model reads the task, asks for a tool (search the web, look something up in your notes, call an API), your code runs the tool and sends the result back, and the model decides the next step until it can answer. Every piece of that loop has a free tier: an LLM API that accepts tools, a search API, a vector database for memory, and a host. The tool-calling agent stack picks one of each from our catalog and exports a ready-to-run config; this guide explains the choices and the limits you will hit.

Every number below comes from the linked offer page; OpenRouter's model list was re-checked on 2026-10-26.

The free agent stack at a glance

1. A free LLM that accepts tools

The model has to support tool calling (also called function calling): you send a list of tools with a JSON schema each, and it answers with a tool name and arguments instead of text. How that works: how does it call a function it can't run?

Count model calls, not tasks. Each step of the loop is one request: a task that searches twice, reads a page and answers is about 4 or 5 calls. At OpenRouter's 50 requests a day that is roughly 10 such tasks; with Requesty and Routeway as fallbacks (200 a day each) about 90 (our arithmetic). Every limit you hit comes back as a 429: why does the free tier say 429?

Minimal agent loop with the OpenAI SDK against OpenRouter:

# pip install openai
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
MODEL = "nvidia/nemotron-3-super-120b-a12b:free"
tools = [{"type": "function", "function": {
    "name": "search", "description": "Search the web",
    "parameters": {"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]}}}]

def search(query):
    return "results for " + query  # call Exa, Firecrawl or Serper here

messages = [{"role": "user", "content": "What changed in the latest Python release?"}]
for _ in range(5):  # cap the steps: every step is a request
    reply = client.chat.completions.create(model=MODEL, messages=messages, tools=tools).choices[0].message
    messages.append(reply)
    if not reply.tool_calls:
        print(reply.content)
        break
    for call in reply.tool_calls:
        result = search(**json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": result})

2. Free web search

A search tool hands the model text it did not write, and a page can contain instructions aimed at your agent. Treat tool results as data, never as orders: why can a web page hijack my AI agent? The free web search API guide compares these in detail.

3. Memory: a free vector database

Long-term memory for an agent is usually a vector store: you save notes or document chunks as embeddings and look up the closest ones before each step (why does it find "car" when I searched "automobile"?).

Free embeddings to fill it: Jina (the same 10M tokens, 100 requests a minute on embeddings) or the models in the free embeddings API guide. More databases: free vector databases.

4. A free host

Use the exported config

Open /stack/agent, set your country if you want only offers available there, and replace any pick you don't like. The Use this stack block then gives three files built from the LLM picks that have a public API base URL in our catalog:

• config.yaml for a LiteLLM proxy: one OpenAI-compatible endpoint at http://localhost:4000; a 429 on the first free tier goes straight to the next one.
• .env.example with one key per provider.
• chat.py: the same fallback with the OpenAI SDK and no proxy. Add tools= and the loop above to turn it into an agent.

A pick without a recorded base URL is listed as "no public base URL yet"; use its offer page for the endpoint.

Limits and the catch

• Free models change. OpenRouter's free list changes every few weeks; keep two providers in your fallback list and check that the model still accepts tools.
• Small daily caps. 50 requests a day is enough to build and test an agent, not to run it for users. Cap the number of steps per task.
• Your prompts may be used. Some free endpoints train on what you send; keep secrets and personal data out, and read each offer's data note.
• Cold storage. Qdrant and Supabase pause idle free projects after a week; a weekly ping or a cron job keeps them awake.
• What an agent is and isn't: what's an "agent"?