🤖 Advanced & 24/7 Agents

You speak in natural language, and it loads models, routes between machines, and assembles the pieces.

It's the vision that organizes all advanced use: a conductor above the models.

Orchestrator, natural language, task automation.

An LLM combined with tools (running commands, reading/writing files, calling APIs) and a loop that decides the next step.

Without this loop, it’s just a chat; with it, it becomes an autonomous executor.

Agent, tools, ReAct loop.

Code agents (CLIs) and frameworks connected to your local endpoint from Track 3.

Translates the video’s terms into tools that actually exist today.

Code agent, framework, local endpoint.

Use Tailscale + a local API to send each task to the ideal machine (large model on the Mac, fast model on the GPU).

Makes use of all your hardware as a personal cluster.

Routing, tailnet, fan-out by machine.

Limit scope, isolate in a sandbox, and confirm destructive actions before executing them.

An agent with too much power and no limits is a real risk.

Scope, sandbox, confirmation.

An instruction that has a local agent summarize a folder of notes or organize files.

Moves from concept to delivering a tangible first result.

Instruction, verification, tangible result.

An unlimited, always-on local model enables ambient/continuous use that's impossible in the cloud because of the cost.

It's the mental framework for the next three step-by-step guides.

Always-on, ambient use, unlimited.

Cloud services charge per call; running 24/7 × many calls becomes unaffordable. Local costs only electricity.

Understanding the cost explains why this can only start locally.

Cost per call, marginal cost, energy.

Scheduler (cron/loop) + task + local model + output (file/notification).

It's the skeleton you'll repeat for each solution.

Scheduler, task, output.

cron (time-based scheduling), folder watch, and a job queue trigger the task.

Choosing the right trigger determines the worker's behavior.

cron, watch, queue.

Logs, idempotency, limits, and recovery from failures so the worker doesn't become a problem.

A fragile 24/7 worker costs more time than it saves.

Logs, idempotency, recovery.

Orchestrate several workers (recap 4.1), each with a role; preview of 4.3/4.4/4.5.

Shows where the learning path leads: your own team of agents.

Fleet, specialization, orchestration.

A worker that continuously scans the repository for secrets, unsafe patterns, and anomalies.

It's the first real use case and the easiest to justify.

Secrets, insecure patterns, continuous.

Sources (code, dependencies) → local agent with checklist → prioritized report.

Seeing the pipeline first prevents messy code.

Sources, checklist, prioritized report.

Run inexpensive tools (gitleaks/secret grep, npm audit/pip-audit) before the LLM.

Deterministic tools catch the obvious quickly and cheaply.

gitleaks, npm audit, pip-audit.

Prompt that tells the local model to triage the findings and explain the risk and fix.

The LLM adds context and prioritizes what the tools returned.

Triage, risk, correction.

cron every X hours (recap 4.2), a dated report, and alerts only for what's new.

Turns a one-off script into continuous monitoring.

cron, dated report, new-item alert.

Handle false positives, define scope, keep everything local, and include human review.

Poorly implemented security creates noise or leaks your own code.

False positives, scope, human review.

Worker that monitors Reddit/forums/RSS and extracts pain points/opportunities, ranked and linked to their sources.

Shows local AI generating market intelligence for you.

Pain points, ranking, source citation.

Respect the ToS/robots, rate limits, and use official APIs when available.

Collecting data the wrong way can break accounts and violate laws; it’s worth doing it right.

ToS, robots, rate limits.

Pull from an allowed source (Reddit RSS/JSON, API) and normalize the items.

Clean data is half the quality of the result.

RSS, API, normalization.

Prompt that classifies each item (is it a real pain point? what product solves it? score 0–10) and returns JSON.

Structured output is what makes ranking and automation possible.

Classification, score, structured JSON.

Sort by score, deduplicate, save with source/citation, and notify only about items that passed the threshold.

Without filtering and deduplication, you’ll drown in noise.

Sorting, deduplication, threshold.

Schedule every N min (4.2), output file/dashboard, and refine the prompt over time.

The watcher improves as you calibrate the criteria.

Scheduling, dashboard, prompt iteration.

A local personal assistant with a personality (system prompt), interface, and voice.

It's the most personal use case and the natural conclusion of the course.

Personality, interface, voice.

Modelfile/SYSTEM defining the "buddy's" name, tone, and rules.

The system prompt is what gives your assistant its identity.

system prompt, Modelfile, identity.

Reuse Open WebUI (3.2) or a simple HTML page that calls the local API (3.5).

A custom interface makes everyday use enjoyable.

Open WebUI, HTML, local API.

TTS (text-to-speech, e.g., Piper) turns the model’s response into speech.

Voice makes the assistant natural and hands-free.

TTS, Piper, audio pipeline.

STT (speech-to-text, e.g., whisper.cpp) so you can talk to the assistant.

Complete the voice conversation cycle, without the cloud.

STT, whisper.cpp, two-way voice.

Combine embeddings/RAG (3.6) so it remembers you and Tailscale (2.4) to access it from your phone.

Memory + remote access are what make it a true companion.

RAG, memory, Tailscale.

Measure tokens/s, latency, and memory usage (ollama ps) and define “good enough.”

Without measuring, you’re optimizing in the dark.

tokens/s, latency, memory usage.

Large model on one machine, fast model on another; routing (recap 4.1/2.4).

Scaling turns standalone machines into a personal cluster.

Multi-GPU, multi-machine, routing.

Peak intelligence, rare use, and maintenance may call for cloud or hybrid.

Knowing the limit prevents costly stubbornness.

Peak intelligence, rare use, hybrid.

Estimate consumption, ensure ventilation, and run the lab 24/7 responsibly.

Heat and power are the hidden costs of always-on operation.

Power consumption, ventilation, thermals.

OOM, slow model, broken driver/CUDA, port in use, Tailscale offline.

A map of common problems gets you out of a jam quickly.

OOM, driver/CUDA, port in use.

Evolution roadmap, communities, and keeping models up to date; recap of the 4 tracks.

Closing with a plan keeps the lab alive after the course.

Roadmap, community, updates.