299 tools. 8 specialist agents. 54 AI models.
A complete AI-powered infrastructure assistant built from scratch.
Every conversation, every tool call, every inference β stays on one machine.
Why build something that already exists in the cloud? Because the cloud isn't yours.
Every major AI assistant runs on someone else's infrastructure. Your prompts travel through their servers. Your code is tokenized by their models. Your infrastructure diagrams β the ones showing every password, every internal IP, every architectural weakness β are processed on machines you'll never audit.
This bothered me.
So I built my own. Not a toy. Not a weekend project that gathers dust. A production-grade AI assistant that runs 24/7 on a Dell Precision Tower 7910 with 88 threads, 503 GiB of RAM, and an RTX 4060 Ti. It manages my entire infrastructure β 154+ Kubernetes pods across 58 namespaces, a MikroTik router, Synology NAS, mail server, DNS, monitoring, security, and everything in between.
The assistant has three faces:
The CLI β lsn-agent or just la. A terminal REPL that feels like talking to a senior engineer who happens to have kubectl, ssh, and root access. Type a question, get an answer β with tool calls, model routing, and context awareness baked in.
The Web UI β The same brain, exposed through a FastAPI server and integrated into OpenWebUI. Chat with your infrastructure from any browser. Share conversations. Upload documents for analysis.
The Cron β Autonomous scheduled tasks. Morning reports, health checks, security audits, backup verification β all running unattended, all sending results to Telegram.
No API keys. No rate limits. No "we've updated our privacy policy." Just a machine in a room in IaΘi, Romania, thinking about your pods at 2 AM.
299 tools across 6 specialized servers. The agent's hands.
MCP β Model Context Protocol β is how the AI models interact with the real world. Instead of generating text about what could be done, the model calls tools that do things. Read files. Execute commands. Query Kubernetes. Scan for vulnerabilities. Generate diagrams.
The tools are organized into 6 specialized servers, each running as a separate Kubernetes pod. This isn't a monolith β it's a microservice architecture for AI capabilities:
The key insight: not all tools are loaded at once. The Smart Tool Router analyzes each message, detects the intent (Kubernetes? Networking? Security?), and dynamically loads only the relevant tool categories. This keeps the token window clean β the model sees 15-20 tools, not 299.
Not every question needs a 26-billion-parameter model. The agent knows the difference.
When you ask "what's my disk usage?", you don't need the same computational power as "redesign the authentication pipeline." The auto-model selector classifies every query into one of four tiers β before any LLM inference happens. Pure pattern matching. Zero latency.
| Tier | Model | When | Speed |
|---|---|---|---|
β‘ FAST |
gemma4:e2b | Status checks, simple lookups, greetings, quick kubectl commands | ~7s |
π΅ MEDIUM |
gemma4:e4b | Configuration, troubleshooting, moderate reasoning, YAML generation | ~13s |
π£ HEAVY |
gemma4:26b | Complex coding, architecture design, multi-step analysis, code review | ~20s |
π΄ BEAST |
deepseek-coder-v2:236b | Entire codebase analysis, large-scale migrations, production-grade architecture | ~120s (CPU) |
The classification uses weighted keyword matching across four pattern sets β fast, medium, heavy, and beast. Each pattern has boost words that increase confidence. If the message length exceeds 200 characters or contains multiple complexity markers, it automatically bumps up a tier.
The result: 85% of queries hit the fast tier and return in under 10 seconds. The 236-billion parameter beast only wakes up when you explicitly invoke it or when the classifier detects a genuinely massive task. No GPU needed for the beast β it runs on CPU across all 88 threads, using ~180 GB of RAM. Slow, but unstoppable.
$ la "check disk space" # β auto-select: gemma4:e2b (FAST, confidence: 0.92) Filesystem Size Used Avail Use% /dev/nvme0n1p2 916G 687G 183G 79% / /dev/sda1 458G 301G 134G 70% /mnt/ssd500gb Total: 1.37TB used of 2.2TB $ la "write a python script to migrate all configmaps from namespace A to B" # β auto-select: gemma4:26b (HEAVY, confidence: 0.87) # β tool routing: kubernetes + files loaded #!/usr/bin/env python3 """Migrate ConfigMaps between K3S namespaces.""" import subprocess, json, sys ... $ la --fast "what pods are crashlooping?" # β forced: gemma4:e2b (--fast override)
One agent, eight personas. Each with its own model, tools, and personality.
Complex problems aren't solved by a single generalist. They're solved by specialists collaborating. The agent chain system lets you delegate to specialist personas or run full multi-step chains where a scout plans the work and specialists execute in parallel.
# Delegate to a specific specialist lsn-agent> /delegate security "audit all exposed services for CVEs" # Full chain: scout plans β specialists execute β synthesize lsn-agent> /chain "investigate why prometheus metrics are delayed" β‘ Scout: Analyzing... 3 investigation paths identified π Analyst: Checking Prometheus targets and scrape intervals... π§ Ops: Examining pod resource limits and node pressure... β Synthesis: Root cause β prometheus PV 94% full, compaction failing # Beast mode β full power, no shortcuts lsn-agent> /deep "review the entire lsn-agent codebase for security issues" π¦ Loading deepseek-coder-v2:236b (180GB)... this will take a while π¦ All 299 tools available. Full codebase in context. Analyzing...
From raw documents to intelligent answers. Crawl, parse, chunk, vectorize, retrieve.
The agent doesn't just run commands. It knows things. Behind the scenes, a full RAG (Retrieval-Augmented Generation) pipeline crawls, parses, and vectorizes documents from dozens of sources β turning raw data into searchable knowledge.
The pipeline feeds into both the CLI agent and OpenWebUI. Ask a question about Kubernetes networking β the agent doesn't just search its training data. It queries your documents: the 28,279 ebooks, the 131,390 indexed files, the ZIM archives, the internal wikis. Then it generates an answer grounded in your knowledge base.
"Nice! What does it come out to (TB)? Do you have indexing or searching on top?"
β Bogdan Filip, Cybersecurity Leader
Yes, Bogdan. This is what's on top.
Ask for a diagram. Get a Draw.io XML file. Open it anywhere.
One of the more unexpected capabilities: the agent can generate architecture diagrams. Not ASCII art. Not Mermaid syntax you have to render yourself. Actual Draw.io XML files with proper nodes, edges, styling, and layout.
Say "create a diagram showing the traffic flow from internet through Traefik to backend pods" and the agent:
1. Detects the intent β loads the diagrams tool category
2. Routes to the diagram_custom MCP tool
3. Generates structured JSON (nodes + edges + styles)
4. The MCP server converts it to Draw.io XML
5. Saves the .drawio file locally
Open it in diagrams.net, VS Code, or the Draw.io desktop app. Edit, export, embed. The diagram is yours.
~/diagrams/request-flow.drawioIt works for anything β network topologies, Kubernetes architectures, CI/CD pipelines, database schemas, even non-technical flowcharts. The model reasons about the structure, and the MCP tool handles the XML mechanics.
The same capability powers the OpenWebUI integration. Chat with the web UI, ask for a diagram, and it generates the Draw.io file in your conversation β downloadable, editable, shareable.
Scheduled tasks that run without you. Morning reports. Security scans. Backup verification.
The agent doesn't need a human at the keyboard. Through lsn-agent-cron, scheduled tasks run autonomously β using the same skills, tools, and model routing as the interactive session. Results land in Telegram.
# Every morning at 7:30 β full infrastructure report 30 7 * * * lsn lsn-agent-cron morning # Every 4 hours β health check (alerts only) 0 */4 * * * lsn lsn-agent-cron health # Daily at midnight β security audit 0 0 * * * lsn lsn-agent-cron security # Daily at 6 AM β backup verification 0 6 * * * lsn lsn-agent-cron backup
The morning report alone summarizes: pod health across all 58 namespaces, CPU/memory/GPU utilization, disk space on all drives, recent CrowdSec bans, Velero backup age, certificate expiration dates, and any anomalies detected in the last 24 hours. All in one Telegram message. Every morning. Before coffee.
Three interfaces. One brain. Consistent tool access everywhere.
The CLI talks directly to Ollama and MCP. The web agent wraps the same logic in a FastAPI server deployed on Kubernetes, exposing it as a Pipe Function in OpenWebUI β which means anyone on the local network can chat with the infrastructure. The cron agent uses Skills β pre-built prompt templates that produce consistent, structured output.
The OpenWebUI integration deserves its own mention. It's not just a chat wrapper. It has:
β’ Voice input/output via Speaches (Whisper STT + Piper TTS, both GPU-accelerated)
β’ Document upload for PDFs, code, configs β parsed by Tika/Docling, vectorized by Qdrant
β’ Web search via SearXNG when the model needs external knowledge
β’ Browser rendering via Playwright for JavaScript-heavy pages
β’ Git-aware context β automatically detects the repo you're working in and includes branch, status, recent commits
This is what a one-person infrastructure team looks like in 2026.
No vendor lock-in. No subscription fees. No data leaving the building. Just a machine, some open-source models, and the stubbornness to build something that works exactly the way you need it to.
The Workshop is not a product. It's not open source (yet). It's not looking for investors. It's a craftsman's toolbench β built over months of midnight sessions, debugged through real incidents, refined by daily use.
Every tool exists because a problem existed first.
Built with π§ by LiΘneanu Dumitru-Cristian in IaΘi, Romania.
Running 24/7 on a Dell Precision Tower 7910.
The Human Document Β· The Knowledge Vault Β· The Defense Report Β· The Intelligence Platform