Start Here: Local AI and Agents Without Wasting a Weekend

A site lives behind a Cloudflare Tunnel, not inside Hermes. Hermes runs an agent. If you need a site, the Cloudflare Tunnel setup guide is separate.

The problem

Most “get started with AI agents” pages do one of two things: dump 60 terminal commands you’ll never finish, or sell you a tool. Neither gets you a working agent tonight. The real gap is a decision fork — you don’t need to choose between cloud API and local model forever. You need to know which one removes your first blocker, and what “done” looks like before you quit for the night.

ABS already has deep guides on every piece below. This page is the hub — it tells you which one to open next, in what order. It does not re-teach them. If a step takes more than a paragraph here, it deserves its own guide, and there’s already a link to it.

The rule / frame

Start with the smallest thing that proves the loop works. A chat reply is not an agent. An agent is: it takes an input, calls a tool or model, and produces an observable result you can find in a log. Get that loop closed first. Everything else — memory tiers, routing, fancy UIs, multi-agent orchestration — is a later optimization.

Decision fork: which path first?

If your blocker is…	Start here	Why
”I just want it to answer and do one task”	API agent — Hermes setup v2	Fastest to a working chat + one tool. No GPU needed.
”I don’t want usage bills or want data local”	Local model — find/eval local models	Runs on your own machine; cost is electricity, not API fees. Hermes connects to Ollama/vLLM/LM Studio/llama.cpp.
”I want both — cloud for hard tasks, local for cheap ones”	Both, via routing — cost-aware model routing	Start API, add local later when the routing math makes sense.
”I want to host a website too”	Wrong guide — see Cloudflare Tunnel	Hermes is not a web host. Sites are a separate path.

You can change your mind after night one. The fork is about what to install first, not a lifetime commitment.

The first-night path

If you have a fresh machine and an evening, this is the order. Timings are illustrative, not benchmarks; what matters is the order.

Step	What you’re doing	What proves it worked
1. Install Hermes	Follow the setup v2 guide. Chat from the terminal. No tools yet.	You can talk to it from the terminal and it answers. (Telegram is a separate, later setup — Gateway comes after CLI works.)
2. Wire one tool	Give the agent one real capability (file write, web search, message send).	You see one tool call in the log, not just the agent describing a tool.
3. Cap the cost	Read Why every agent needs a cost cap on day one. Set a hard daily/spend ceiling. The cited guide opens with an $80-in-an-hour story — cap the model call before it happens.	A test run that crosses the limit stops cold.
4. Add the log line	Add the 1-line observability hook. One JSONL line per model call.	tail -f ~/.cache/agent-obs.jsonl streams structured lines for every call.
5. Read the context loop shape	Skim the three-phase context loop. Don’t implement it tonight; understand grounding / messy middle / landing.	You can name the three phases for any prompt.
6. (Optional) Add a local model	Use the local-models guide to pull a model with Ollama and connect Hermes.	A small model answers a prompt without an API call.

If you finish steps 1–4, you have a real agent. Steps 5–6 are improvement.

One example first-run

Pick one. Don’t try all three tonight.

A. Morning brief from RSS (API path, ~30 min after setup) Schedule a cron at 8:00. Hermes reads 5 RSS feeds, summarizes them, posts the result to Telegram. You now have a daily brief that’s yours, not a SaaS’s. Requires: step 1 (chat), step 3 (cap), step 5 (context — to keep the prompt tight).

B. Scrape-and-summarize a single URL (API path, ~15 min after setup) One tool: HTTP fetch. Hermes pulls a URL, summarizes, writes to a file. You now have a re-runnable research primitive. Requires: step 2 (one tool), step 4 (observability — so you can see the fetch size). Re-run the same URL tomorrow and the result file is identical.

C. Local 8B Qwen on your laptop (Local path, ~45 min after setup) Use the local-models guide to pull a model with Ollama (the guide’s worked example is llama3.1:8b; a Qwen 8B Q4 also works if your VRAM fits — this is illustrative, not benchmarked). Wire Hermes to talk to it. Confirm you can ask it one thing without an API call. Requires: step 1 (harness), step 4 (observability), step 6 (local model).

Common first-night mistakes

• Install-rabbit-hole. You read five guides and installed nothing. Fix: do step 1 only, then stop and test.
• No cost cap. A loop that runs unattended can rack up spend while you sleep. Fix: step 3 is mandatory, not optional.
• “Chat works” mistaken for “agent works.” A chat that summarizes text is not an agent. Fix: require at least one tool call in your test.
• Buying a GPU before proving the loop. Local is great, but prove the API path works first — it’s free of hardware risk.
• Configuring memory before you need it. Tier 1 (working memory — the in-context window for the current request) is always on. Tier 2–4 are for when you actually need to remember past this turn. Fix: skip the memory guide tonight; read it tomorrow when you have a real “why does it remember that but not this?” moment.
• Routing before you have two things to route. Adding the cost-aware router with one model is configuration overhead. Fix: come back to routing when you have a real second model.
• Picking a framework fight at 1am. Hermes vs OpenClaw is a decision for tomorrow, with daylight and a clear task list.

Done means (end-of-night checklist)

• Chat works (you can talk to the agent)
• One tool is connected and was actually used (visible in a log line)
• One capped run completed (spend limit set and not exceeded)
• One log line exists from that run (JSONL, model call, tokens, cost)
• (Optional) One read-through of the three-phase context loop shape (you can name grounding / messy middle / landing)

If those four (or five) are true, you have a real agent. Everything else is improvement.

Skip list (do NOT buy/install first)

• A new GPU — prove the API path first.
• A vector database — you don’t have enough state to need one yet.
• A fancy frontend / dashboard — terminal + chat is enough to start.
• Three different agents “just to compare” — one working agent beats three half-built.
• Any tool you haven’t first reproduced the core behavior of for free. Cap a free run before you pay.
• Hermes plugins for tools you don’t have. Wait until you actually need the tool.

What this hub deliberately does NOT cover

• Multi-agent orchestration (multiple agents arguing). Skip until you have one solid agent.
• Voice, image generation, browser control. Each is its own guide; none is required for night one.
• Selling access to your agent. Come back when you understand the cost math.
• A detailed framework comparison. That’s its own article: Hermes vs OpenClaw: pick a path.

Related guides (internal links only)

• Hermes Agent setup v2
• Why every agent needs a cost cap on day one
• The 1-line observability hook that fits any agent
• The three-phase context loop
• How to find, download, evaluate local models
• The four tiers of agent memory
• Cost-aware model routing for agents
• Cloudflare Tunnel setup for a static site (if you also need a website)
• Your agent reviewing its own work is not a check (read this before you add a “review” step)
• Hermes vs OpenClaw: pick a path (tomorrow, not tonight)

Sources / what we ran

• Hermes setup, cost cap, observability hook, context loop, memory tiers, local-model guide: documentation-verified against the cited ABS guides; ABS operates Hermes on Linux (we have not personally tested the daily-driver path on macOS).
• Local-hardware tier recommendations (8GB / 16GB / 24GB / 48GB): inferred from community norms and the local-models guide; we have not run our own GPU benchmarks.
• OpenClaw comparison: see the canonical research dossier for primary sources.
• ABS operates Hermes on Linux for production. Daily macOS driver claim was not retained because it is not source-attested.