Summary

LEVR was founded in 2026. The platform is live, it is serving paying customers, and the technology estate is eight production systems built on one consistent architecture rather than eight one-off builds.

What we built

A thin edge control plane on Cloudflare — routing, authentication, tenancy, and state — paired with a separate execution plane on dedicated servers that runs the long agentic builds. Around that spine sit the commercial core (workshop capture, transcription, same-day strategy delivery), the client deliverable dashboard, the multi-tenant content platform, the customer agent harness, the knowledge-base and site-editor connectors, the voice companion, and the weekly market-intelligence routine.

What we have proven

• 171 agentic builds executed on the production runtime, producing strategy dashboards and full marketing showcases for real clients.
• 29 consecutive weekly market-intelligence runs — continuous from June to August 2026 with no missed week — and 21 published editions.
• 23 client workshops recorded, transcribed, and processed end to end through the capture pipeline.
• 5,537 voice-companion messages across 128 conversations. Built for internal use, it became the most-used surface in the estate and is now being commercialised.
• 2,620 automated test cases on the two newest codebases, running in credential-free CI on every push and pull request.
• Smoke-gated production deploys. The platform's first production deploy passed a preflight credential gate and a credential-free behavioural smoke gate; the execution runtime has run 78 automated deploys at 97% success.
• Zero security incidents, breaches, or notifications in the company's history.
• Strong, proven margins on delivered engagements, on an infrastructure cost base of roughly €30 per month of servers plus AI subscriptions.

What is next

LEVR is in a deliberate 100-day window: shaping the product alongside the ICP cohort, with customer touch-points multiple times a week, so that the facilitators and clients using it every day set the Q4 roadmap. That cohort is already paying and already responsible for a meaningful share of the product decisions made this quarter.

The technology priority after financing is to grow the core engineering team around the architecture already in place — the platform, the execution plane, and the facilitator tooling — and to mature the operational layer alongside it.

Architecture principles

Four principles are applied consistently across every LEVR system: a thin edge control plane, a separate execution plane, deterministic logic wherever a deterministic answer exists, and a structural human gate before anything reaches a client.

Shared primitives across products

• Tenant identifier on every row, with tenant-prefixed indices and a tenant-scoped data access layer.
• Append-only audit and event logs.
• Redundant capture on anything that cannot be re-recorded.
• Tokenised capability URLs for one-off external access.
• A shared skill and agent library reused across the marketing pipeline, the harness, and the routines.
• A voice interface and an MCP surface on the systems that need machine-to-machine access.

Managed primitives in use: Workers, D1, R2, KV, Queues with a dead-letter queue, Durable Objects, Workers AI, Access, Secrets Store, and Tunnel.

Application portfolio

Eight production systems. Each entry gives function, stack, hosting, and a proof point.

1. LEVR Platform — the commercial core

The facilitator runs the one-day session and records it on an iPhone. Audio uploads in chunks, is transcribed, and drives the agentic build that produces the strategy dashboard the same day and the go-to-market dashboard within 48 hours. The design goal is that a non-technical facilitator runs the entire pipeline from a browser and a phone.

Stack

npm workspaces monorepo on Node 22 across four Cloudflare Workers — auth (Hono, Better Auth as OAuth provider, Kysely over D1, JOSE), clients-api, pipeline (cron- and queue-driven, no public hostname), and web (Vite 8, Alpine.js 3.15, Tailwind 4.3). Mobile is Expo 57 / React Native 0.86 / TypeScript, iOS first, with background audio, local SQLite, secure storage, and over-the-air updates.

Hosting

LEVR corporate Cloudflare account on the levr.live zone: two D1 databases (28 tables, 24 migrations, ownership split enforced by an invariant test), two R2 buckets, a speech-to-text queue with a dead-letter queue, one-minute cron, and Cloudflare Secrets Store. Mobile ships through EAS to TestFlight.

Proof point

23 client workshops captured and processed end to end. Live probes on the day of writing: JWKS 200 in 0.25–0.52s, API health 200 in 0.21–0.35s, admin surface 200 in 0.33s.

2. LEVR Bridge — the agentic execution runtime

A job API that runs an agent in a per-client sandbox scoped to that client's repository. It produces the strategy dashboard (capped at roughly one hour) and the full marketing showcase build (a seven-session pipeline with a 16-hour timeout).

Stack

Python 3.11, FastAPI, Pydantic, 19 pinned dependencies, SQLite in WAL mode; the agent runs in a bubblewrap sandbox. Provisioning creates a private repository and a deployment project per client. Vendored: the marketing pipeline bundle (98 skills, 93 agent definitions) and the dashboard template.

Hosting

Hetzner CX33, Ubuntu 24.04, backups on, loopback-bound — public access exclusively through a named Cloudflare tunnel with a bearer token. Health probe 200 in 0.84s. Bounded by design: three concurrent jobs, turn caps, hard timeouts.

Proof point

171 agentic builds executed between June and August 2026 — 91 strategy dashboards, 67 ad-hoc marketing builds, and 13 full marketing builds.

3. Virtual Departments (formerly LEVR Loops) — multi-tenant content platform

A weekly agentic routine drafts on-brand social content into a brand-themed approval queue. Approved on-strategy work publishes directly to Instagram and Facebook. Off-strategy work requires a Slack card, a tokenised approval page, and a PIN held by a named person at the client — peer-visible by design, so going around the strategy is a visible act rather than a silent one.

Stack

Cloudflare Pages in Advanced Mode with a hand-written ES-module worker — no framework, no npm dependencies, a 227-line entry point — with Alpine.js and Tailwind on the front end. Workers AI provides Llama 3.3 70B for strategy-alignment scoring (publish threshold 0.6) and LLaVA for media tagging.

Hosting

Cloudflare Pages with D1, R2, KV sessions, and Workers AI. Access gated by Cloudflare Access email OTP, with bypass applications protected by service tokens or HMAC. Producer runs on a Monday 08:00 cron.

Proof point

Ten consecutive weekly production runs. A tenant identifier on every row across 10 tables, 14 tenant-prefixed indices, and an 841-line tenant-scoped data layer. The decisions table is append-only and serves as the canon training signal.

4. LEVR Dashboard — the client deliverable platform

The client-facing deliverable and the client's primary interface. It holds all marketing artifacts and the go-to-market strategy cards, and is the consolidation point for the activation layer: the Virtual Departments, sub-account access, and the voice functionality through which assets are interrogated, edited, and created.

Stack

Vanilla JavaScript with a vendored copy of Alpine and no build step: one shared shell renders both the asset dashboard and the strategy dashboard, from JSON content packs emitted by nine standard-library Python builders against a strategy contract with nine block primitives. An audio Worker streams ElevenLabs text-to-speech from an object-store cache in 0.35s.

Hosting

Cloudflare Pages, one project per client instance. Live instances respond 200 in 0.29–0.35s.

Proof point

Live client instances in production across multiple sectors, each covered by a 2,402-line Playwright QA harness that asserts the instance end to end before it ships.

5. LEVR Agent Harness — customer agentic teams

A customer's marketing team receives an AI agent preloaded with a curated go-to-market execution library, deployed and maintained by LEVR.

Stack

An open-source coding agent on Node 22 running GLM-5.2 on a flat-rate plan, with 53 curated skills and 43 subagent definitions converted to the harness format. A custom skill-router keeps the system prompt to roughly one line instead of loading 30,000–50,000 tokens of skill definitions.

Hosting

Dedicated Hetzner CX23, hardened: root SSH disabled, key-only authentication, host firewall, fail2ban, named sudo with I/O logging.

Proof point

Reference deployment running today. High-blast-radius credentials are deliberately kept off customer agent boxes, on the basis that anything reachable by the agent is exfiltratable by prompt injection; model identity is pinned rather than trusted.

6. Knowledge-Base MCP and site editors

The knowledge-base MCP server exposes a per-client marketing corpus to the client's own AI tools. The site editors are MCP edit connectors: propose → preview → promote, with strategy-affecting changes routed to a named human approver.

Stack

Cloudflare Worker, TypeScript, MCP SDK, Workers OAuth provider, Hono, Zod, and a Durable Object. Site editors are git-backed through the source-control API, with a Workers AI strategy-change classifier alongside a deterministic zone lock, and Slack plus email for approver routing.

Proof point

Two live client corpora with per-corpus bearer tokens, two live client sites under editor control, and a named human approver in the loop. Live probes 200 in 0.22–0.39s.

7. Walk-and-Talk — voice companion

A voice agent for executive input and deliverable feedback: a brief is handed off, the conversation runs over WebRTC, and the transcript is distilled back into the workflow. Multi-tenant with per-user and per-location siloing. It is the mechanism behind the voice-led product direction — clients speak what they want rather than learning an interface — and the candidate backend for the dashboard voice agent.

Stack

Cloudflare Pages PWA in Advanced Mode. OpenAI realtime voice over WebRTC plus whisper for transcription. Capacitor 8 iOS shell with remote loading and native push.

Proof point

The highest-volume system in the estate: 5,537 messages across 128 conversations. Built internally, adopted by clients, now being productised.

8. Weekly Pulse — market intelligence routine

A Monday re-scan of the client's market — competitors, search, AI-answer visibility, voice of customer, legal, social — producing a deterministic week-over-week delta, trend stories, battle cards, and an audio brief into the client dashboard.

Stack

A headless agent bounded at 200 turns plus 23 deterministic Python scripts — the diff is pure Python, so the model never counts deltas. Signal sources are plugins with per-client YAML validated against a JSON schema, drawing on a SEO/SERP API covering AI answers across ChatGPT, Gemini, Perplexity and AI Overviews, a crawler, a Reddit archive API, and review sites. Three validators plus a blocking humanisation gate.

Hosting

Dedicated Hetzner CX23, Monday 07:00 UTC cron, host uptime 111 days. Output is preview-only by default; promotion to production is a human action.

Proof point

29 consecutive weekly runs with no missed week, plus 21 manual runs, and 21 published editions. Running for a paying client.

Development methodology

Languages and platform choices

Testing

2,620 automated test cases run on the two newest codebases, in CI on every push and pull request. Client dashboards ship behind a Playwright QA harness with full end-to-end assertion suites per instance; the Pulse routine runs three output validators on every edition.

Environments

Client-facing work is validated through staged, self-hosted prototypes before anything reaches a client — the deliverable is built, hosted, and reviewed internally first, and promotion to a client-visible surface is a human action. Local development is complete: a single boot command brings the whole platform up and proves health.

A formal staging environment for the platform is designed, approved in an architecture decision record, and scheduled: durable but expendable, promoting an exact SHA-pinned artifact, backward-compatible migrations only, human-initiated promotion.

Continuous integration and deploys

Platform and mobile run credential-free CI on every push and pull request — the pipeline needs no secrets, so a fork or an untrusted branch cannot exfiltrate anything. Source control is a single organisation with private repositories, conventional commits, and pull-request review.

Platform deploys run a fixed sequence: preflight credential gate → dry run → pinned service order (auth → clients-api → pipeline → web) → credential-free smoke gate. The execution runtime auto-deploys through a self-hosted runner, drain-aware so in-flight jobs finish first — 78 runs at 97% success.

Three deploy controls worth naming

• Preflight probes every resource the deploy token must see before anything is written, so a scope error fails before it does damage rather than halfway through.
• The smoke gate asserts behaviour with no credentials. It proves the JWKS is usable, that an unauthenticated call returns a 401 with the correct body — proof the middleware is actually in the path — and that the web surface serves and proxies.
• Fix-forward by design, with idempotent deploys and backward-compatible migrations, so recovery is a roll-forward rather than a state rewind.

Planning system

Linear carries work tracking across an engineering team (platform, iOS, worker infrastructure, pulse automation) and a client-delivery team, with per-client delivery projects and a templated client-onboarding project.

The engineering system of record beneath it is a structured vault repository holding 461 tasks each with a priority and a test contract, 138 lessons, 86 decisions, 37 specs with acceptance criteria, and 13 architecture decision records. Work follows a blocking verification step before implementation begins. It exists to make engineering context transferable as the team grows.

Infrastructure and operations

Fleet

All compute is Cloudflare's managed edge plus four Hetzner servers, all in Nuremberg, all Ubuntu 24.04, all with backups enabled. The client-facing surfaces sit on Cloudflare's distributed edge; the servers carry only the execution plane.

Monitoring

Host-tier monitoring is in place across the whole fleet. A sentinel runs on all four servers every five minutes, checking for out-of-memory events, disk at or above 85%, sustained swap use, and failed systemd units, and alerting to Slack. Health endpoints are meaningful across services and are probed by the deploy smoke gate.

Operational discipline: incidents produce structural fixes

No production incident has involved customer data or a security breach. Each one is recorded with the structural fix it produced, because the fixes are the point.

Cost base

The infrastructure cost base is deliberately efficient: €29.46/month of servers, effectively zero Cloudflare spend at current volume, and AI subscriptions. The AI execution layer runs on subscription-based authentication today; migration to metered API access is planned, and unit-economics modelling has already been re-baselined onto metered pricing so the commercial model does not depend on the subscription rate.

Scalability

The edge tier auto-scales. The execution plane is the deliberate constraint — three concurrent builds per host — and the queue architecture settled in August 2026 removes it: a job queue feeding a worker fleet where concurrency equals worker count, with a pluggable agent harness. It is specified with named milestones and an owner, and is the first infrastructure workstream after financing.

Data flows and quality controls

Processing schedules

Data intake and collection

Audio arrives as standard MIME types; browser capture produces webm, mp4, or ogg. Transcripts are plain text or Markdown, knowledge-base sources arrive as JSON in three recognised formats, and strategy sources are Markdown or JSON compiled into the database.

LEVR-built collectors: the workshop recorder including locked-screen capture, the voice companion, transcript ingestion, the pre-work uploader, the research agent swarm, 23 Pulse collectors with four signal plugins, moments ingestion, the site-editor MCP, and the connector MCP with per-user OAuth and an audit trail. Third-party: speech-to-text and realtime voice, a web crawler, a SEO/SERP data provider, a Reddit archive API, a social publishing API, a website platform API, Slack, an edge access gateway, and an authentication library.

Quality controls, in order of application

AI model usage and data policy

LEVR trains no models and owns no weights. Every model in use is third-party hosted and used zero-shot or few-shot with retrieved context. What LEVR owns is the layer above the models: the skill and agent library, the evaluation rubrics, and the encoded strategy graph. Models are a swappable input; the governance layer is the asset.

Models in use

Customer data and training

• No customer data is used to train any model. LEVR does not train, fine-tune, or contribute data to model training.
• Per-client tenant isolation is enforced at the data layer — tenant identifier on every row, tenant-scoped access layer, tenant-prefixed indices.
• Learning happens at the prompt and canon level only. When a client approves or rejects a piece of work, that decision is written to an append-only decisions log and shapes future prompts for that client. It does not update model weights and does not cross tenants.

Retention, ownership and export

AI quality controls

A three-tier gate — deterministic check, then independent judge, then human — plus provenance gates on research inputs, bounded agent loops with turn caps and timeouts, and cost caps. The governance evaluation itself contains no model in the decision path: it is deterministic, and where the system is uncertain it widens constraints rather than narrowing them.

Security posture

LEVR has had no security incident, breach, or notification in its history. The controls below are live today.

In place

• Organisation-wide two-factor authentication is enforced across the engineering organisation.
• Dependency scanning with automated security-fix pull requests is enabled on every repository and defaulted for new ones.
• OAuth 2.0 with JWT verification against published JWKS, a separate OAuth client per surface, and httpOnly refresh cookies on the web surface.
• Deny-by-default authorisation. Roles are never client-settable. Tenant isolation is enforced at the data-access layer rather than at the query site.
• Cloudflare Access in front of internal and client approval surfaces, with bypass applications protected by service tokens or HMAC.
• Hardened servers: root SSH disabled, key-only authentication, host firewall, fail2ban, named sudo with I/O logging.
• Secrets in managed secret storage (Cloudflare Secrets Store), credential-free CI so pipelines cannot leak secrets, and a preflight credential gate on every deploy.
• Sandboxed execution. The runtime is loopback-bound and reachable only through an authenticated tunnel; agents run in per-client sandboxes scoped to that client's repository, and high-blast-radius credentials are deliberately kept off customer-facing agent boxes.
• Append-only audit logs across every surface.
• Automated backups across the fleet, with 24 images retained.

On the roadmap

• SOC 2 Type II: on the roadmap, beginning with Type I.
• Third-party penetration testing: planned.
• Application-level alerting and a documented incident-response plan: planned for near term.
• Repository secret scanning and code scanning: planned alongside the committed source-control tier upgrade.
• Estate-wide log aggregation and external uptime checks: planned.
• Upload size limits and antivirus scanning on the intake path: planned.
• Published retention policy, DPA template, and sub-processor list: in progress.

Engineering team and operating model

The operating model is deliberately small and deliberately senior: architecture and product decisions are made by people who also ship, and the engineering vault and Linear projects exist so that context transfers rather than living in one person's head.

Post-financing, the priority is growing the core engineering team around the architecture already in production — platform and mobile, execution-plane infrastructure, and the facilitator tooling that the 100-day ICP cohort is actively shaping. The team knows how to build enterprise technology; the next stage is staffing it to the size of the opportunity.