AI Orchestrator

Background

I run all of my projects (audio plugins, an AV design tool, automation scripts, this site) out of one workspace, and I wanted one assistant that could work across all of it without burning money. So I built an orchestration layer around the AI tools I use: a system that decides which model handles which task, remembers what it learned, and runs a few jobs on its own schedule.

The design constraint that shaped everything is cost. Frontier models are good but expensive; local models are free but limited. The interesting engineering is in the routing, not in any single model.

What it does

• A task router sends each job to the cheapest capable model: local models first (Ollama on my own machine), then free cloud tiers with automatic failover, and frontier models only for work that needs tools, file access, or hard reasoning
• A token budget meter gates every session: each prompt is stamped with current spend, and expensive paths are blocked when the budget runs low
• Persistent memory: plain-text notes as the source of truth, with a SQLite and local-embeddings layer for semantic recall across sessions
• Per-project knowledge graphs, so agents query the structure of a codebase instead of re-reading files
• Scheduled autonomous jobs, including a morning digest and a weekly evaluation loop that tunes a paper-trading strategy fleet and reports what it changed
• Slack and Telegram interfaces with an approval queue: the system proposes, I approve from my phone, and the work is picked up in the next working session
• Tool access through MCP (Model Context Protocol) integrations: calendar, mail, file storage, and design tools

Limitations

• Single machine, single user; it is a personal system, not a product
• The free cloud tiers it leans on change their limits regularly, so the router needs occasional retuning
• Guardrails are house rules (budgets, approval gates, truth files that agents must re-read), not a formal policy engine

The repository is private because the system operates my real accounts and files.

What I learned

Model routing economics: most day-to-day tasks do not need a frontier model, and a router that knows this cuts costs by an order of magnitude. And reliability in agentic systems comes from constraints, not from bigger models: hard budgets, human approval gates, and forcing agents to read the current state from disk instead of trusting their own memory of it.