AZYLUME

Principal frontend & AI agent engineering. React · TypeScript · MCP.

View work →Get in touch

Romania · Remote, EU timezone · Open to contract & part-time

Scroll

/ About

Principal-level frontend engineering. These days: AI agents, MCP and the interfaces around them.

Azylume is an independent engineering practice for React and TypeScript products, backed by 14+ years in web development, 12+ of them in frontend: leading teams, owning whole frontend codebases, and doing the unglamorous work that makes products fast (bundle size, CI/CD, test reliability).

The current focus is AI agent collaboration end to end, from the React client to Python services, Matrix/Synapse and MCP-based integrations. The projects below were built in-house: agent-editable creative software, a discovery engine, and pipelines that remove click-work.

Available for remote contract and part-time engagements. Based in Romania, working in the EU timezone.

14+
Years in web development
12+
Years in frontend
~25%
Smaller bundle · Connatix
50%
Less CI/CD resource use · BT

/ Work

Three in-house projects, each designed and built solo. Client work stays confidential; the teams are listed under Clients.

01

Crate

Personal product · soloNext.js PWA

Anonymous music discovery built around Builds: curator-authored discovery recipes (a search space, not a playlist) that generate fresh tracks per listener, per run. The north star: “how did I not know this existed?” Crate digging instead of feed consumption.

Problem

Feeds keep recommending what everyone else already hears, and playlists go stale once shared. I wanted discovery that stays generative: you share a recipe, and every listener digs up different tracks.

Technical highlights

  • Builds are generators. A Build stores sliders (obscurity, weirdness, energy) plus free text, never a track list. Each run seeds a new exploration of the same space (documented as an ADR).
  • Ratings are an append-only event stream. Current state is a fold over the latest event per user and track, and all interpretation happens downstream of storage, so gesture semantics can change without migrations.
  • One scoring vocabulary, shared by client and server: novelty from listener counts, graph-hop depth, Rare Hit multipliers and an anti-gaming Build Score.
  • Heuristic recommender: a Last.fm / MusicBrainz graph walk that records a “dig trail” for every track, shown in the player as provenance.
  • Claude-powered vibe search over your history (“forgot the title, remember the feel”), with keyword ranking as the fallback.
  • Runs at $0: keyless YouTube playback in a persistent dock that survives navigation, a graceful mock fallback without API keys, and pocket mode using the Screen Wake Lock API.

Stack

Next.js App RouterTypeScripttRPCPrismaTailwind
SQLite → PostgresVidstackClaude APILast.fmMusicBrainzPWA

Role

Solo: product concept, domain model and ADRs, UX, frontend, API and recommender. It runs locally and is not publicly deployed.

Crate: Today's Crate, the season's shared Builds
Crate: player with a Rare Hit toast after a Super Like
Crate: history with re-ratable events and vibe search
Today’s Crate · Rare Hit toast after a Super Like · History (“nothing disappears”). Local build with mock discovery data.
02

vjai

Personal · soloTauri desktop app

An agent-native desktop VJ instrument. The whole show is one JSON document that the UI, the projector windows and an AI agent all edit through the same patch path.

Problem

Closed VJ boxes on one side, node spaghetti on the other. I wanted an instrument where the show is data: inspectable, undoable, and editable by an agent as easily as by hand.

Technical highlights

  • The show is one JSON document (zod schema, additive-only). Every edit is a patch op applied by the Rust host and broadcast to every window. Undo/redo from snapshots; a slider drag coalesces into one step.
  • Render loop: audio analysis (rms, bass, mid, high, kick) → mod matrix → per-layer source → ping-pong FBO effect chain → blend onto the composite → projective warp per slice with edge blending.
  • Registries as data: each of the 21 effects is one object. Schema, shaders, UI sliders, mod targets and the agent’s prompt all derive from that list.
  • Agent-native + MCP sidecar: the chat agent edits through the same patch path. A stateless stdio MCP + WebSocket bridge lets Claude Code drive a running show with the same tools.

Stack

Tauri v2 (Rust)React 19TypeScriptWebGL2 / GLSLMCP
zustandzoddockviewWeb AudioVite

Role

Solo: architecture, rendering engine, UI, agent tooling and the MCP sidecar.

vjai: composite preview, layer stack and effect chain, chat agent panel
vjai: projection mapping with two warped, edge-blended slices
Mapping: two corner-warped slices with edge blend
vjai: the show as a node graph
The same show as a node graph
03

Flyer → Resolume composition builder

Personal · soloPython pipeline

A manifest-driven pipeline that turns an event flyer into a show-ready Resolume Arena composition: graded footage, type idents and one deck per act, in three commands.

01 · INPUT
Flyer + manifest

Flyer images and a manifest.yaml: acts in flyer order, palette, idents, stills and footage buckets per act.

02 · GRADE
Zine grade

Footage → 1080p, grayscale, contrast crush, threshold / posterize / halftone, xerox jitter and grain, then a ping-pong loop. Optional duotone in the flyer palette.

03 · IDENTS
Type + stills

Act names set in type with pango and given the same zine treatment, tinted. Flyer stills become slow push-in “breathing” loops.

04 · COMPOSE
Arena .avc

Resolume Arena 7.26 composition: layers that mirror the rig, one deck per act, plus a scratch deck for live auditioning.

Problem

Every night needs its own look, taken from the flyer, and a composition that matches the line-up. Building that by hand in Arena is hours of click-work per event.

Technical highlights

  • Generates Arena’s composition XML directly: layers, decks, clips and per-layer effect chains, verified against real Arena files.
  • Self-routing masters: files named <act>_<zone>_<slug>.mov land on the right deck and layer; a scratch deck holds unsorted candidates for live auditioning.
  • Idempotent and content-only: re-run any time the masters change. Screen Setup stays in Resolume prefs, so one venue mapping keeps routing every generated show.
  • One look end to end: footage and type idents share the same zine grade (threshold, xerox jitter, grain, 12 fps) as ffmpeg filter chains.

Stack

Pythonuvffmpeg / ffprobeResolume Arena XML
YAMLpangoProRes

Role

Solo. Built for and used on my own VJ nights.

# build_composition.py (condensed excerpt) # 3 layers: the deployed rig is 1 booth projector + 1 edge-blended panorama. BOOTH_LAYER, PANO_LAYER = "booth", "panorama" LAYERS = [PANO_LAYER, BOOTH_LAYER, "idents"] # layerIndex 0..2 def build_act_columns(act, booth, pano, idents): # Spread clips across columns so each layer has many options: # the VJ triggers clips per layer (free booth x pano mixing). cols = [] for i in range(max(len(booth[act]), len(pano[act]))): col = {} if i < len(booth[act]): col[BOOTH_LAYER] = booth[act][i] if i < len(pano[act]): col[PANO_LAYER] = pano[act][i] cols.append(col) # idents layer: act name sting, event title, then the flyer stills stings = [idents.get(act), idents.get("title")] stings += [f for k, f in idents.items() if k.startswith("still_")] stings = [f for f in stings if f] while len(cols) < len(stings): cols.append({}) for col, f in zip(cols, stings): col["idents"] = f return cols
Deck planning: how clips are spread across a deck’s columns.

/ Clients

Teams I’ve built for, as an employee or contractor.

/ Services

Remote contract or part-time engagements.

Frontend architecture

Micro frontends, Nx monorepos, performance and bundle-size work.

Design systems

Tailwind/shadcn component libraries, Figma tokens, Storybook docs, style guides.

React / Next.js builds

Customer-facing apps, internal tools, e-commerce PWAs, rich animation.

AI agent & MCP integrations

Agent collaboration UIs, streamed responses, OpenAPI/MCP connectors.

E2E test reliability

Playwright E2E tests and CI/CD, sharding, retries, suite consolidation.

Mentoring & tech leadership

Team leading, code reviews, coaching in modern frontend.

/ Skills

Core tools I use daily.

AI and Agentic Engineering

AI agent platformsModel Context Protocol (MCP)LLM-assisted developmentagent harnesses and workflows

Frontend

ReactTypeScriptNext.jsReduxTailwind CSSshadcn/uiWeb ComponentsHTML5CSS3/SCSS

Design Systems

StorybookFigma tokenscomponent librariesstyle guides

Backend and Messaging

Node.jsNestJSPythonMatrix/SynapseKafkaGraphQLREST

Testing

PlaywrightCypressJestPytest

Tools and Cloud

Nrwl/Nx monoreposCI/CD (GitLab, GitHub, Jenkins)DockerAWSVercel

/ Contact

Need a frontend, AI agent or MCP engineer on contract? Get in touch.