Projects

One commercially shipped product. Here's what it took — and what I can replicate for your stack.

Selected case studies in AI systems, automation, and agents — each framed as Problem → Solution → Architecture → Outcome.

I build a mix of production AI systems and experimental agent prototypes. Only production-ready systems are shipped and maintained.

Production Systems

Shipped

Deployed, maintained AI systems with real users.

Agent SystemsCommercially launched

Profesor Abelton — AI Copilot for Ableton Live

A standalone desktop AI that turns natural language into Ableton Live actions — built to feel like a friend who actually knows Ableton.

Problem

Ableton Live has a steep learning curve and most learning resources are cold, slow, and abstract — beginners get stuck Googling basics and watching 45-minute tutorials for 30-second questions.

Solution

A local desktop copilot connected to Ableton via an official Control Surface Remote Script. It streams full session state (tracks, clips, devices, tempo) to a dual-LLM engine (Claude with a custom MCP of 35 schema-validated tools, plus Groq for sub-second responses). A hardened command pipeline enforces a 40-action allowlist, parameter sanitization, and a 12-command batch limit. A 5-step First Launch Wizard auto-installs the Remote Script, encrypts API keys (Fernet), and activates a machine-bound Gumroad license.

Architecture

A desktop app (PyInstaller) talks to a local FastAPI + WebSocket engine, which connects to Ableton through an official Control Surface Remote Script. A dual-LLM router sends complex reasoning to Claude — over a custom MCP of 35 schema-validated tools — and quick queries to Groq for sub-second responses. Every requested action passes a hardened command pipeline before it ever reaches Ableton.

Engineering challenges

  • Streaming full Ableton session state (tracks, clips, devices, tempo) in real time without blocking the UI.
  • Designing 35 schema-validated MCP tools so the LLM can act safely and predictably.
  • Hardening the command pipeline: a 40-action allowlist, parameter sanitization, and a 12-command batch limit.
  • Making it a real product: Fernet-encrypted API keys, machine-bound Gumroad licensing, and a 5-step first-launch wizard.

Outcome

A commercially launched (v2.0.1) desktop product on Windows and macOS. Static analysis via Bandit (zero medium/high findings) plus a structured security audit before release.

In production

Shipped to paying users in less than 3 months from first line of code — music producers running it inside their day-to-day Ableton Live sessions.

The users are music producers who keep Profesor Abelton open next to Ableton Live while they work. Instead of pausing to search forums or watch tutorials, they ask it in plain language — “add a MIDI track”, “how do I add a device”, “analyse my session” — and it reads the live session state and either answers or performs the action directly in the project. The assistant sits inside the creative loop rather than in a separate tab.

Engineering impact

  • Real-time session sync: full Ableton state (tracks, clips, devices, tempo) streams over WebSockets, so answers reflect the project as it is right now — not a stale snapshot.
  • Stays usable mid-session: a Groq fast-path answers quick queries in under a second while Claude handles complex reasoning.
  • Safe to run in a live project: a 40-action allowlist, parameter sanitization, and a 12-command batch limit stop the AI from damaging a producer's work.
  • Resilient in real use: failures from Ableton, the LLM APIs, or the network are caught and surfaced instead of crashing the session.
  • Local-first and private: it runs on the user's machine with Fernet-encrypted API keys — nothing about their projects leaves the device except the LLM calls they trigger.

Iteration loop

The product is shaped by how this small group actually uses it. Real sessions surface edge cases demos never do — unusual project layouts, unexpected phrasings, device combinations — and those drive the fixes and new tools in each release. It evolves through live usage feedback, not a roadmap written in isolation.

Tech stack

PythonMCPClaudeGroqWebSocketsFernetPyInstaller
v2.0.1
Commercially launched
35
Schema-validated MCP tools
2 LLMs
Claude + Groq routing
Passed
Structured security audit
Win + macOS
Distributed via Gumroad
0
Bandit medium/high findings

Static analysis via Bandit (0 medium/high findings) + structured security audit. Supplementary LLM-assisted review checks were also run as part of the audit methodology (GPT-4o: 88/100, Grok: 80/100).

AIProduction · Live

AI Career Assistant (this site)

A grounded RAG assistant that answers recruiter questions about my work.

Problem

Static CVs don't let recruiters ask questions or evaluate role fit — they have to infer everything from a flat document.

Solution

A retrieval-augmented assistant grounded strictly in my profile data: questions are embedded, relevant chunks are retrieved via vector search, and the LLM answers only from that context. A dedicated Job Fit mode analyzes a pasted job description and returns a fit score, experience mapping, gaps, and interview positioning.

Architecture

Next.js 15 App Router (TypeScript) with an API route that streams responses token by token. A provider-agnostic layer routes chat to Claude, Groq, or OpenAI; a retrieval layer either passes the full profile as context or runs vector search. Per-IP and global rate limits cap abuse and cost.

Engineering challenges

  • Keeping answers strictly grounded so the assistant never invents experience.
  • Streaming responses while rendering Markdown (tables, lists) incrementally.
  • Staying provider-agnostic so it runs on Claude, Groq, or OpenAI without code changes.

Outcome

A live, queryable career interface with a Q&A mode and a Job Fit mode that scores a pasted job description against real profile data.

Tech stack

Next.jsTypeScriptOpenAISupabasepgvector

Work in Progress

In development

Actively built and evolving — not yet shipped as products.

Agent SystemsIn development

Zvonko — Family Call Agent

A private, Croatian-speaking family assistant on ordinary phone calls — no app, no menus, no new technology for the family to learn.

Problem

Older family members need reminders (medication, appointments, household safety) without learning a smartphone app. Existing assistants assume screens, English, and always-on personal devices.

Solution

One phone number. Family members call, ask for a reminder, and confirm what Zvonko understood. FastAPI validates transports; LangGraph manages dialogue in Croatian; typed tools validate arguments; domain services enforce authorization, confirmation, idempotency, and medication rules. Speech uses Deepgram Nova-3 (hr) and Azure hr-HR TTS over Twilio Voice / Media Streams. Language understanding defaults to deterministic Croatian rules; an optional OpenAI layer can paraphrase into the existing parser but cannot invoke tools or bypass confirmation.

Architecture

Phone → Twilio Voice / Media Streams → Deepgram STT → LangGraph (identify caller, classify intent, extract arguments, confirm writes) → typed tools → domain services → PostgreSQL. Azure TTS returns audio to Twilio. An ARQ worker on Redis materializes due calls, retries unanswered attempts, and reconstructs jobs after interruption. Repositories encapsulate SQLAlchemy; provider adapters never simulate a successful production call. Single-family architecture, not multi-tenant. Audio stays in memory; the app does not record live calls.

Engineering challenges

  • Croatian speech on the phone: short confirmations (da/ne) are still unreliable; barge-in and turn boundaries remain open work.
  • Safety-critical writes: medication inventory decrements only on an explicit taken-dose report; ringing, silence, and 'not taken' do not subtract stock; idempotency prevents double subtraction.
  • Delivery vs. outcome: a completed call never proves a dose was taken or a safety task finished; voicemail counts as answered, never as confirmation.
  • Reliable scheduling: SQL outbox + ARQ, one-off/daily/weekly reminders, appointment offsets, bounded snoozes, and escalation (Branko, then Nataša) after two unanswered medication/safety attempts.
  • Replaceable providers (Twilio/Infobip, Deepgram, Azure, OpenAI/deterministic) without letting adapters fake success in development.

Outcome

A live-tested Hetzner pilot with a full domain layer (reminders, inventory, appointments, audit), unit/graph/integration tests without paid calls, and a Croatian deterministic eval suite. Remaining work includes recognition quality, conversational coverage of existing tools, monitoring/backups, and affordable local inbound numbers. Public source: github.com/Oknarbo/family_call_agent.

Tech stack

PythonFastAPILangGraphTwilioDeepgramAzure SpeechPostgreSQLRedisARQSQLAlchemy
Pilot
Live on Hetzner
LangGraph
Dialogue + typed tools
hr
Croatian STT + TTS
Half-duplex
First audio bridge
SQL + Redis
Outbox + ARQ worker
Allowlist
Caller-ID access control

Pilot as of September 2026. Not a commercially launched product. Medication records reflect what a person reports, not physical verification. Zvonko does not give medical advice or provide emergency response.

Agent SystemsIn development

Profesor David — AI Companion for Avid Pro Tools

The Profesor Abelton architecture, adapted for Pro Tools and xAI Grok.

Problem

Pro Tools users need contextual, conversational help without leaving their session — but no local, session-aware assistant existed.

Solution

A local AI companion using a FastAPI server (127.0.0.1:8766) and the Pro Tools PTSL gRPC connector, powered by the xAI Grok API. It receives live session state and answers conversationally, reusing the proven Profesor Abelton architecture.

Architecture

A local FastAPI server (127.0.0.1:8766) bridges the Pro Tools PTSL gRPC connector and the xAI Grok API, reusing the session-aware pattern proven in Profesor Abelton.

Engineering challenges

  • Adapting the MCP/session-aware architecture to a different DAW and a different LLM provider (xAI Grok).
  • Speaking Pro Tools' PTSL gRPC protocol to read live session state.

Outcome

Working v1.0.0 (read-only); write actions (inserts, plugin params, transport) are the next milestone.

Tech stack

PythonFastAPIxAI GrokPTSL (gRPC)Tkinter
Agent SystemsIn development

Profesorica Volca — AI Tutor for Korg Volca Hardware

Extending the agentic copilot concept from software to hardware synthesizers.

Problem

Hardware synths like the Korg Volca series have deep, non-obvious workflows and no interactive, guided tutor.

Solution

A desktop tutor for Volca Bass, Drum, and Sample with original vector panel renderers driven by JSON control maps and glow highlighting. It offers a deterministic recipe mode (no LLM) and an LLM-backed chat/explain mode bound by a strict JSON schema contract.

Architecture

A PySide6 desktop tutor with original vector panel renderers driven by JSON control maps. A deterministic recipe mode needs no LLM; an LLM-backed chat/explain mode is bound by a strict JSON schema contract.

Engineering challenges

  • Rendering accurate, interactive hardware panels from JSON control maps.
  • Constraining LLM output to a strict JSON schema so explanations map to real controls.

Outcome

An MVP showing the agentic-tutor pattern works for physical hardware via structured outputs.

Tech stack

PythonPySide6OpenAIAnthropic

Other Shipped Products

Completed

Finished, production-ready tools in data, blockchain, and automation — solid work, but outside the commercially launched AI-product flagship.

OtherShipped

Global Government Content Removal Monitor

An interactive, source-faithful map of government requests to remove or restrict online content — without treating a request as a removal.

Problem

Platform transparency reports are public but incomparable: Google, X, Reddit, TikTok, and Lumen use different units, periods, and caveats. Dashboards that sum them invent a number that none of the sources actually reported.

Solution

A source-adapter pipeline: official reports → immutable raw snapshots with SHA-256 provenance → parse → validate → normalize. Each measurement keeps its official metric, country, period, source URL, and snapshot. The map (React + MapLibre) lets visitors filter by platform, period, and metric. Lumen stays separate as notice-level research, not platform totals. Public deployment serves generated JSON snapshots with the Vercel frontend so visitors avoid API cold starts; FastAPI remains the local/demo API. The same queries generate both representations.

Architecture

Official CSV/PDF/HTML sources are snapshotted with retrieval metadata and SHA-256 hashes. Source adapters (Google, X, Reddit, TikTok, Lumen) isolate fetch/parse/normalize/validate so a new platform does not change the map model. SQLite locally or PostgreSQL in production; FastAPI exposes platforms, periods, map, country, aggregates, and sources. The Vercel frontend reads exported JSON shaped like those endpoints.

Engineering challenges

  • Never combining unlike units even when every series is a count.
  • X 2024 PDF transcription vs. older X series that are not a comparable global dataset.
  • TikTok early periods that publish only a global total, and Reddit country charts that stay off the map until fully verified.
  • Import that fails closed on upstream schema changes instead of silently corrupting normalized data.

Outcome

A shipped portfolio data product with parser tests (pytest) and a documented monthly update path. Live map plus public source.

Tech stack

PythonFastAPISQLAlchemyAlembicReactTypeScriptMapLibreTanStack QuerySQLite / PostgreSQL
5
Platform sources
SHA-256
Snapshot provenance
MapLibre
Interactive choropleth
FastAPI
OpenAPI contract
Vercel
Static JSON frontend
Monthly
Windows update task

A request is not necessarily actioned, and content named in a request is not necessarily removed. Lumen notices are voluntarily shared records, not proof of removal.

AutomationShipped

Forex Automation System

Automated trading and risk-management tooling in C#.

C#cTrader / cAlgo
AutomationShipped

X Trending Monitor

A live dashboard for the top 30 trending topics on X (Twitter).

Node.jsWebSocketsX APIElectron
OtherShipped

Branksy — The Non-Artist

A tongue-in-cheek 'degen coin' website for an artist who makes no art.

HTMLCSSJavaScriptFirebase

Experiments & Prototypes

Exploration

Proof-of-concept and exploration work — not production systems.

OtherExperiment

Unimatrix — Modular Synthesizer (Rust)

A real-time modular synthesizer engine built in Rust. In active development.

RustCPALmidirrodio