The Barefoot Freelancer AI Hub

How an LLM answers you — in 5 steps

1. Your text is split into tokens

   A token is roughly ¾ of an English word. "Freelancer" might be 2–3 tokens. Pricing and limits are counted in tokens.

2. Tokens go into the context window

   The context window is the model's short-term memory: your instructions, the conversation, any documents you paste. Anything outside it, the model can't see.

3. The model predicts the next token — repeatedly

   It generates one token at a time, each based on everything before it. That's why clear, well-structured input produces better output.

4. Settings shape the output

   temperature controls randomness (low = consistent, high = creative). max_tokens caps output length. System prompts set persistent behavior.

5. It has no built-in access to the live world

   A plain LLM only knows its training data up to a cutoff date. To check today's prices, read your files, or send an email, it needs tools — which is exactly what turns a chatbot into an agent.

Chatbot vs. Workflow vs. Agent

Before → After

Write a post about our coffee shop.

You are a social media copywriter for Barefoot Café,
a cozy co-working coffee shop in Iloilo City.

<task>Write 3 Facebook post options announcing our
new Sea-Salt Cold Brew (₱160), launching this Friday.</task>

<context>Audience: freelancers and students, 18–35.
Brand voice: warm, witty, a little Taglish is OK.</context>

<rules>
- Max 60 words each, 1–2 emojis
- End with a clear call to action
- Don't invent promos or prices not listed here
</rules>

10 techniques that consistently work

⚡ Interactive prompt builder

Fill in the fields — a structured, copy-ready prompt assembles itself on the right.

↺ repeat steps 02–05 until the goal is met, a limit is hit, or approval is needed

The 6 building blocks of every agent

Build your first agent (Python + local model, ~30 lines)

1. Install Ollama and pull a tool-capable model

   See Module 05 for full install steps. Qwen3 and Llama 3.1+ support tool calling well.

   terminalcopy

   ollama pull qwen3
   pip install ollama

2. Write your tools as normal Python functions

   Type hints and docstrings become the tool description the model reads — so write them clearly.

3. Run the agent loop

   Call the model → if it requests tools, run them and feed results back → repeat until it replies with plain text.

   first_agent.pycopy

   import ollama
   
   def check_invoice(invoice_id: str) -> str:
       """Look up the payment status of an invoice by its ID."""
       fake_db = {"1042": "unpaid, 12 days overdue, ₱18,500", "1043": "paid"}
       return fake_db.get(invoice_id, "not found")
   
   def get_client_email(invoice_id: str) -> str:
       """Return the client contact email for an invoice."""
       return "maria@example.com"
   
   TOOLS = {f.__name__: f for f in [check_invoice, get_client_email]}
   
   messages = [
       {"role": "system", "content": "You are a back-office assistant. Use tools to get facts. Never invent amounts."},
       {"role": "user", "content": "Is invoice 1042 paid? If not, draft a polite reminder email."},
   ]
   
   for step in range(8):                      # guardrail: max 8 steps
       resp = ollama.chat(model="qwen3", messages=messages, tools=list(TOOLS.values()))
       messages.append(resp.message)
       if not resp.message.tool_calls:         # no tools requested → final answer
           print(resp.message.content)
           break
       for call in resp.message.tool_calls:
           fn = TOOLS[call.function.name]
           result = fn(**call.function.arguments)
           print(f"🔧 {call.function.name}({call.function.arguments}) → {result}")
           messages.append({"role": "tool", "content": str(result), "tool_name": call.function.name})

4. Run it and watch the loop

   You'll see the agent call check_invoice, then get_client_email, then write the email. Swap the fake functions for real ones (Google Sheets, your accounting API) and you have a genuine back-office agent.

   terminalcopy

   python first_agent.py

Common agent design patterns

▲ An AI lead-response workflow. Typical result: replies go from hours to minutes, and no lead falls through the cracks.

Build it yourself in n8n — step by step

1. Run n8n for free

   Self-host with Docker (free), or use n8n Cloud's trial. Then open http://localhost:5678.

   terminalcopy

   docker volume create n8n_data
   docker run -it --rm --name n8n -p 5678:5678 \
     -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

   No Docker? npx n8n also works if you have Node.js installed.

2. Add a trigger

   Create a new workflow → add an n8n Form Trigger (or Webhook) with fields: name, email, message, budget.

3. Add an AI step

   Add an AI Agent or Basic LLM Chain node. Connect a chat model — Ollama (local, free), or a cloud model via API key. Use a prompt like the one below and enable structured JSON output.

   classifier_prompt.txtcopy

   Classify this inquiry for a web design freelancer.
   Return ONLY JSON: {"intent": "...", "budget_php": number|null,
   "urgency": "low|medium|high", "lead_score": 0-100, "summary": "..."}
   
   Inquiry: {{ $json.message }}  Budget field: {{ $json.budget }}

4. Branch with an IF node

   Route on lead_score >= 70. Hot leads go to fast-track; others get a friendly auto-reply with your portfolio link.

5. Log it

   Add a Google Sheets (or HubSpot / Airtable / Notion) node to append the lead with the AI's fields.

6. Draft + human approval

   A second AI node drafts a personalized reply. Send it to yourself on Telegram or Slack with approve/edit buttons — only then does the Gmail node send it.

7. Test, then activate

   Submit 10 realistic test inquiries (including weird ones). Check the classification, fix the prompt, then toggle the workflow Active.

Which automation tool?

Step 1 — Install Ollama

brew install ollama
ollama --version

ollama --version
ollama run gemma3

curl -fsSL https://ollama.com/install.sh | sh
systemctl status ollama

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
docker exec -it ollama ollama run gemma3

Step 2 — Pick a model your hardware can handle

Rough guide for default 4-bit quantized models. New models appear constantly — browse ollama.com/library for the latest. A GPU makes things much faster, but CPU-only works for small models.

Step 3 — Essential Ollama commands

ollama run qwen3            # download (first time) + chat. Type /bye to exit
ollama pull gemma3:4b       # download without chatting
ollama list                 # models on disk
ollama ps                   # models loaded in memory right now
ollama show qwen3           # details: parameters, context length, license
ollama stop qwen3           # unload from memory
ollama rm llama3.2          # delete to free disk space
ollama serve                # start the API server manually (port 11434)

Step 4 — Use it from code (local API)

Ollama serves an API at http://localhost:11434 — including an OpenAI-compatible endpoint at /v1, so most AI tools and SDKs work with it by just changing the base URL.

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3",
  "messages": [{"role": "user", "content": "Give me 3 taglines for a surf school in Siargao"}],
  "stream": false
}'

# pip install ollama
from ollama import chat

r = chat(model="qwen3", messages=[{"role": "user", "content": "Summarize this in 3 bullets: ..."}])
print(r.message.content)

// npm i ollama
import ollama from "ollama";

const r = await ollama.chat({
  model: "qwen3",
  messages: [{ role: "user", content: "Write a 2-line product description for handmade abaca bags" }],
});
console.log(r.message.content);

# Any OpenAI-SDK-based tool can point at Ollama
from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")  # key is ignored
r = client.chat.completions.create(model="qwen3", messages=[{"role":"user","content":"Hello!"}])
print(r.choices[0].message.content)

Step 5 — Make a custom assistant with a Modelfile

FROM qwen3
PARAMETER temperature 0.3
PARAMETER num_ctx 8192
SYSTEM """
You are the Barefoot Freelancer assistant. You write clear, friendly client
emails and proposals for a Philippine-based freelance web designer.
Keep answers concise. If you're missing a fact (price, date), ask for it.
"""

ollama create barefoot-assistant -f Modelfile
ollama run barefoot-assistant

Step 6 — Add a ChatGPT-style interface with Open WebUI

Open WebUI gives you chat history, document upload (RAG), multiple users and model switching — all local.

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main
# then open http://localhost:3000 and create the first (admin) account

Other local AI apps worth knowing

Hands-on: install Hermes Agent and connect it to your local Ollama model

1. Install

   The installer sets up Python, Node.js and other dependencies for you. On Windows, there's a native PowerShell installer, or you can use WSL2. A desktop app is also available from the Hermes website.

   macOS / Linux / WSL2Windows (PowerShell)

   bashcopy

   curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
   source ~/.bashrc     # or: source ~/.zshrc

   powershellcopy

   iex (irm https://hermes-agent.nousresearch.com/install.ps1)

2. Make sure Ollama is running with a tool-capable model

   Agents need models that handle tool calling well. Give it a generous context window — agents read a lot.

   bashcopy

   ollama pull qwen3:14b     # or gpt-oss:20b if you have the memory

3. Choose your model provider

   Run the model picker and choose a custom / OpenAI-compatible endpoint, then point it at Ollama. (You can also pick a cloud provider here instead.)

   bashcopy

   hermes model
   # Provider: custom OpenAI-compatible endpoint
   # Base URL: http://localhost:11434/v1
   # Model:    qwen3:14b

4. Start chatting and give it real work

   bashcopy

   hermes
   › Read ~/clients/proposal-notes.md and turn it into a 1-page proposal in proposal.md
   › Every Friday 5pm, summarize what I worked on this week from my git commits

5. Reach it from your phone (optional)

   Run the Hermes messaging gateway and connect Telegram, Discord, Slack, WhatsApp or Signal, so your agent can take requests and report back wherever you are. Follow the gateway guide in the official docs.

Which harness should you use?

Example: give an agent safe access to one folder

Most MCP hosts accept a config like this (location differs per app — check its docs). The agent can now read and write files only inside the folder you list.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/ClientProjects"]
    }
  }
}

🧮 AI automation ROI calculator

Estimate what automating repetitive work could be worth. Adjust the sliders to match your business.

🗺️ The 90-day AI adoption playbook

✅ Is this task a good fit for AI? Quick checklist

1. Build 3 demo projects

   A chatbot, a workflow, and a local AI setup — document each as a case study with before/after numbers.

2. Pick a niche

   "AI automation for dental clinics" beats "AI services." Niches make marketing and repeat solutions easier.

3. Sell outcomes, not tech

   "Reply to every inquiry in under 2 minutes" sells better than "I'll build you an n8n LLM agent."

4. Offer a paid pilot

   A small, fixed-price 2-week pilot lowers risk for the client and proves value fast.

5. Add a monthly care plan

   Prompts drift, APIs change, models update. Maintenance is recurring income.

"Free" means free to learn/use or a genuinely useful free tier. Free plans change — check each site for current terms.