Self-Hosted AI,
Automation & Media

Intel Core i5-3470

3.20GHz · 4 cores · 4 threads

31 GB RAM

DDR3 · Sufficient for everything

0.16 Load Average

Sitting idle most of the time

Milo 🐶

The labrador. Friendly, loyal, never sleeps. Running cron jobs at 3am with zero complaint. Warm, witty, gets things done without making a fuss.

• Long-term memory (MEMORY.md)
• 29 reusable skills
• Job alerts, heartbeats, reminders
• Sub-agent orchestration

Heisenberg ⚖️

The precision agent. Checks everything before it runs. Systematic, cautious, methodically breaks down risks. Named after the uncertainty principle for a reason.

• Pre-execution safety reviews
• Config hardening and auditing
• Health check automation
• Heisenberg audit skill

Jesse 🚀

The operator. Takes direction and executes. Fast, reliable, handles the heavy lifting. Name from Breaking Bad — cooks without ego, delivers without drama.

• Background task execution
• Kafka sentiment pipeline
• Data pipeline management
• Heavy compute workloads

Job Alert Agent

Daily 8am London — searches 5 job boards, emails results

Data Analyst Agent

On-demand CSV/Excel analysis with visualizations

mini-llm — Legal Q&A Bot

Fine-tuned 4-layer GPT for UK legal questions. Intent classifier + 1032 stock answers = reliable answers at zero marginal cost.

class MiniGPT(nn.Module):
    def __init__(self, vocab_size, dim=1024, heads=16, layers=4):
        self.embed = nn.Embedding(vocab_size, dim)
        self.layers = nn.ModuleList([TransformerBlock(dim, heads) for _ in range(layers)])
        self.norm = nn.LayerNorm(dim)
        self.head = nn.Linear(dim, vocab_size, bias=False)

    def forward(self, x):
        x = self.embed(x)
        for layer in self.layers:
            x = layer(x)
        return self.head(self.norm(x))

• 4-layer transformer (1024 dim, 16 heads)
• 252 intent classes — all dummies resolved
• 1032 stock answers — zero fall-through
• Repetition penalty 1.05 prevents collapse

crypto_dashboard_multi

LSTM price predictions + RAG playground. Upload PDF, ask questions, get KG-powered answers from your documents.

class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_size=128, num_layers=2):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

model = LSTMModel()
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

• LSTM price predictions (BTC, ETH, BNB)
• RAG playground with KG-powered retrieval
• Google Sheets Q&A activity logging
• Kafka producer/consumer sentiment pipeline

Job Alert System

Daily automated job search for Account/Finance roles in London. Searches 5 job boards, emails results.

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

def send_alert_email(subject, body_path):
    with open(body_path, 'r') as f:
        html_body = f.read()

    msg = MIMEMultipart('alternative')
    msg['Subject'] = subject
    msg['From'] = GMAIL_USER
    msg['To'] = GMAIL_TO

    part = MIMEText(html_body, 'html')
    msg.attach(part)

    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
        server.login(GMAIL_USER, GMAIL_APP_PASSWORD)
        server.send_message(msg)
    return msg['Message-ID']

• Runs 8am London time daily
• Searches 5 job boards simultaneously
• Logs message ID for tracking

n8n Workflows

Visual workflow automation. PDF processing, Google Sheets logging, data integrations.

• PDF processing via webhooks
• Google Sheets activity logging
• Visual workflow editor — no code
• Data webhook integrations

Architecture Decisions

Key GitHub Repos

• mini-llm — Fine-tuned GPT, Streamlit UI
• crypto_dashboard_multi — LSTM + RAG
• python_kg — Knowledge graph API
• openclaw workspace — Automation scripts

Lessons Learned

• Stock answers > model quality. The real product in mini-llm is the fallback system. 1032 deterministic answers mask training collapse.
• Caching is everything. KG generation is expensive; MD5 cache keys = instant retrieval.
• Repetition penalty tuning. 1.2 was too aggressive (crushing term reuse). 1.05 is gentle but effective.
• Intent classifier bugs > model bugs. Fixing a pattern match improves reliability more than retraining.
• n8n for glue, not logic. Keep workflows simple; complex logic belongs in Python.