# Marcin Walendowski · full career reference

Principal AI Native Product Engineer | ProductMaxxing | async culture, spec driven, high agency

Location: Warsaw, Poland
Email: kontakt@marcinwalendowski.pl
Book a call: https://calendly.com/marcin-walendowski/30min
LinkedIn: https://www.linkedin.com/in/marcinwalendowski/
GitHub: https://github.com/MarcinWalendowski

Source: generated from career/cv.html#long + knowledge-base.md §2 (bio) and §3-§8 (detail). Everything below is public CV material.

## Summary

Hand me a product and I'll own it end to end, from discovery and spec to architecture, build, and launch. I take responsibility, move proactively, and ship. I bring startup DNA: high agency, full ownership, and an async culture.

## How he works

These days I mostly orchestrate code rather than write it by hand. Voice memos drive an agent loop that pulls context from my knowledge base and codebase, drafts a spec I iterate on, then implements it, landing either fully autonomously (spec to deploy) or as reviewable, spec-backed PRs, one or several depending on how the spec is scoped. I stay in the loop for the judgment calls.

## Full bio

Hand me a product and I'll own it end to end, from discovery and spec to architecture, build, and
launch. I take responsibility, move proactively, and ship.

How I work: These days I mostly orchestrate code rather than write it by hand. I capture intent as
voice memos; an agent loop transcribes them, pulls context from my knowledge base and the codebase,
and turns each into a spec I iterate on before anything is built. The loop then implements the ready
specs. Depending on the work, that lands either as a fully autonomous path (spec to implementation to
deploy) or as reviewable, spec-backed PRs, one or several depending on how the spec is scoped. I stay
in the loop for the judgment calls. The scarce skill isn't the typing; it's the curation, the specs,
and knowing when a human steps in.

I bring startup DNA: high agency, full ownership, and an async culture. If you want someone who'll take
a product and own it end to end, let's talk.

The breadth behind it:
- Mobile: React Native and Expo at the core, plus native iOS (Swift, Objective C), Android
  (Kotlin), and enterprise App Clips.
- Backend and platform: Node.js services and architecture scaled to 100k+ RPS. I moved a CI/CD
  fleet onto bare metal M1 Macs and cut build costs by around 20,000 USD a month.
- MarTech and data: CDPs, Segment, Braze, Salesforce, Snowflake, and clean attribution across
  the stack.
- Fintech and onchain: Plaid, Yodlee, Robinhood, and Coinbase, plus loop based trading agents on
  Solana and Polymarket, now productized as Predicts: an onchain prediction markets agent that
  trades Polymarket by text on Privy self-custody wallets, settling gaslessly on Polygon.

I've been a CTO, a mobile lead, and a founding engineer.

Building the AI native way means the intelligence is the product, not an add on. I design what
makes AI features reliable: how it is orchestrated, what it sees, how it is evaluated, and when a human
steps in. And I build with AI too, running fleets of coding agents in parallel.

Most recently, as a founding engineer at Passage (a seed stage fintech founded by former Plaid
engineers and backed by Plaid's CEO, Max Altman, and funds Mischief and Saga):
- Passage Money: one of the first personal finance agents to live entirely inside ChatGPT and
  Claude (27+ MCP tools, an OAuth server, an agent inside a tool call), plus the evals and self tracing
  observability that keep it reliable.
- Passage Connect: an App Clip and browser automation account linking platform. I built the
  Durable Objects session engine and single handedly owned client SDKs across Swift, Kotlin, Expo, and
  TypeScript, shipping iOS App Clips for enterprise customers.
- Gravy: a gamified cashback consumer app, zero to App Store.

## Experience

### Founder · Loki Messages, Beside & Predicts

May 2026 – Present · Warsaw, Poland (Remote)

Three products built end-to-end and solo, the AI-native way — a messaging platform for agents plus two consumer apps on top of it (a live-location assistant and an onchain prediction-markets trading agent). One person from native macOS systems to the edge runtime to shipped, localized apps and a self-custody trading wallet: the generalist, full-ownership story.

**Loki Messages — iMessage as a REST API and MCP (messaging infrastructure for agents)**
**Beside Chat — live-location consumer agent (the actor)**
**Predicts — onchain prediction-markets trading agent (predicts.chat)**
**Whole agent architecture (one runtime, many actors)**

- Turned iMessage into a REST API and MCP server: a fleet of Mac agents exposes send/receive, reactions, typing, read receipts, native polls and live location as 30+ endpoints with sub-second webhooks, over real US/EU numbers and no third-party SMS gateways.
- Native systems programming behind a clean cloud API: AppleScript automation plus a private IMCore dylib injected into Messages (DYLD_INSERT_LIBRARIES) and a FindMy bridge for live location.
- Provisioned the Mac-agent fleet as code with Ansible — playbooks create each macOS user, install the agent, and bring its Cloudflare Tunnel + remote-VNC access online; a companion session-keeper service holds VNC sessions alive across the fleet.
- Shipped Beside Chat, a location-aware agent that lives as a contact in Messages and texts you the moment you're near something you care about; no app, no account, onboarding is one text. Sends native Messages carousels, remembers preferences, schedules its own reminders. 0 → live, localized into 50+ languages.
- Shipped Predicts, an onchain prediction-markets agent that trades Polymarket by text or voice: grounded live odds, a live trending board, generated market cards, and Auto Trade that turns a plain-language rule ("buy YES under 30%") into placed orders. Real markets executed through Polymarket's CLOB (@polymarket/client), settling gaslessly on Polygon in USDC.
- Self-custody trust layer: each user gets an embedded Privy MPC wallet (non-custodial — Predicts never holds the key); the agent gets only a delegated signing grant policy-locked to Polymarket's contracts, inside per-trade and daily caps, revocable in one tap. Built the onchain infra: a fiat + crypto onramp, a PII-free wallet-link web app, and a self-hosted order relay (Cloudflare Tunnel + Access) for Polymarket's geo-blocked endpoint.
- In-chat feedback loop (loop engineering): users flag issues in plain language mid-conversation; an LLM-inferred report-issue tool captures them with no keyword or command and routes each into a triage queue. An autonomous agent loop turns well-scoped reports into spec'd tasks and carries them spec → implementation → deploy with no human in the middle, often shipping the fix to production in minutes.
- Custom agent loop on Cloudflare Durable Objects — stateful per-conversation agents, MCP tool calling, model failover, proactive scheduled tasks. A transport-agnostic delivery layer lets one runtime speak any channel: started on iMessage, the same agent now plays multiple branded personas across iMessage, WhatsApp and Telegram (Beside and Predicts are two of them). Built with fleets of coding agents.

Links: https://lokimessages.com · https://beside.chat · https://predicts.chat

### AI-Native Founding Engineer · Passage

Dec 2024 – May 2026 · New York (Remote)

Seed-stage fintech founded by ex-Plaid engineers; backed by Plaid's CEO, Max Altman, Mischief & Saga. Owned three products end-to-end, the AI-native way — spec-driven, with custom agent skills and custom MCP observability/loop connectors.

**Passage Money — agentic personal finance inside ChatGPT & Claude**
**Passage Connect — App-Clip + browser-automation account linking**
**Gravy — gamified cash-back consumer app**

- Shipped one of the first personal-finance agents to live entirely inside ChatGPT & Claude — 27+ MCP tools (Zod-typed, visibility-scoped) and an agent-inside-a-tool-call running its own nested inference loop. Built on the OpenAI Apps SDK weeks after launch, then ported the widgets to the MCP Apps spec for cross-host support.
- Made a non-deterministic AI product testable: a 3-layer eval harness (deterministic assertions + LLM-as-judge + lifecycle-stage seeding) in a CI benchmark pipeline, plus self-tracing observability (MCP tools that let the agent query its own logs).
- Context & memory engineering — persistent agent memory/session state on Durable Objects, RAG (pgvector + OpenAI embeddings), document/file-search tool retrieval that scaled tool selection across 1,000+ data providers (each provider's MCP tools indexed and retrieved per query instead of loaded into context), Cloudflare Code Mode for large tool catalogs (tools exposed as a typed TypeScript API the agent writes code against and runs in a sandbox, instead of loading every tool schema into context), context-window management, function calling & structured outputs for reliable, schema-constrained agent behavior, active-state prompt injection, tool-result truncation, per-agent model failover with fallback provider/timeout, and human-in-the-loop payment flows.
- Built a Plaid-style account-linking platform where credentials never leave the device: a Cloudflare Durable Objects session engine (<50ms edge relay), client-driven WKWebView automation, and multi-tenant OAuth 2.0 (ES256 JWT, PKCE) that replaced Cloudflare Access.
- Cracked account-linking on sites that actively resist automation — Walmart, Starbucks, Marriott, Google Maps, AT&T, Verizon — with per-page agentic loops that adapt to each page, delivered through an embedded / injected WebView inside an iOS App Clip and exposed across the multi-language SDK suite, validated against world-class antibot stacks (Cloudflare Turnstile, Google reCAPTCHA).
- Owned the client SDK suite solo — Swift, Kotlin, Expo & TypeScript (plus Capacitor and web) — and shipped iOS App Clips for enterprise customers.
- Consolidated the platform onto Cloudflare (NestJS + Socket.io + GCP → Next.js + Durable Objects): cut the core auth flow 2,500 → 180 lines, dashboard polling ~98%, and infrastructure cost & operational overhead ~in half.
- Shipped Gravy, a gamified cash-back React Native app, zero → App Store (Apple Pay, Coinbase integration for crypto payouts, WebView checkout, event-triggered rewards, IP-based geofencing for regulatory compliance).

### Staff Software Engineer · Checkatrade

Sep 2023 – Dec 2024 · London (Remote)

Contract · UK's #1 home-services marketplace.

- MarTech platform engineering — scaled comms service architecture to 100,000+ RPS; drove cross-team CI/CD, release engineering, and observability improvements.
- Migrated 5M+ customer profiles from Salesforce into Segment & Braze — stood up the event-collection and activation layer that unified customer data across the marketing stack.
- Orchestrated lifecycle comms across multiple providers (incl. a migration to Brevo) and kept attribution accurate across Branch.io, Google Tag Manager, and the wider marketing stack.
- Built internal tools in Retool plus product & issue analytics on Snowflake and Starburst data, giving marketing and product teams self-serve insight.

### Head of Engineering · Astor

Sep 2022 – Sep 2023 · New York (Remote)

Community-driven personal-finance app (astor.money, backed by NFX & TMV) — aggregates bank & brokerage accounts into a single wealth view, paired with community investing.

- Built and led a top-tier team of 5 engineers; owned the engineering architecture across iOS, Android, backend & platform.
- Built financial-data integrations across Yodlee, Plaid, Robinhood — bank / brokerage / transaction sync with OAuth flows.

### Founding Product Engineer · No Big Deal SA

Sep 2021 – Sep 2022 · Luxembourg (Remote)

Mobile engagement-marketing + wellbeing/fitness app (iOS + Android).

- Led mobile development end-to-end; designed CI/CD for mobile tests/builds/deploys with Ansible + M1 Azure pipelines and Detox e2e tests.
- Integrated native HealthKit and Google Fit with background processing.
- Designed and led backend development of a Fitness service API integrating Fitbit, Strava, Garmin, Polar.

### Staff Software Engineer (Frontend Platform & MarTech) · Taxfix

Mar 2021 – Sep 2021 · Berlin (Remote)

Contract · Germany's most popular mobile tax app.

- Implemented iOS 14.5 ATT / SKAdNetwork attribution across a brownfield React Native app.
- Re-engineered mobile CI/CD — Bitrise → M1 bare-metal GitLab runners (−80% execution time, ~$20k/mo savings); created and maintained the Terraform that provisioned the bare-metal M1 Macs on MacStadium (third-party provider) with the full CI/CD toolchain, plus Ansible config; Detox e2e + CodePush.
- Built a GTM automation tool on GitLab pipelines and advanced Segment + Braze integrations (mobile + web), with Snowflake on the data side.

### Founding Senior Engineer · Flip Fit (Humans, Inc.)

Apr 2019 – Mar 2021 · Los Angeles (Remote)

Social-commerce app (social media + live shopping). Flip (Humans, Inc.) went on to raise $144M at a $1B+ valuation (~7.8M downloads).

- Prepared the mobile architecture and organization to scale: grew to two mobile engineering teams (~20 engineers), ran 100+ interviews, and owned the cross-platform iOS and Android architecture behind an app that reached #7 among US ecommerce apps.
- Shipped the app cross-platform for iOS and Android on React Native, authoring complex native modules on both platforms (Objective-C/Swift on iOS, Kotlin on Android): LL-HLS & HLS video player, RTMP live streaming (HaishinKit) with deep Akamai Video & Cloudflare Stream integration, reverse-proxy HLS segment caching (GCDWebServer), advanced push (Push Stories, action buttons, in-app messaging), deferred deep links, PINCache prefetch/caching.
- Designed mobile architecture for performance & stability with advanced JS + native profiling; Segment/Mixpanel/Braze analytics; Sentry, CodePush, Reanimated.

### Co-Founder & CTO · TeaCode.io

Mar 2016 – Mar 2019 · Warsaw / Oslo / London (Remote)

Boutique Node.js / React / React Native consultancy.

- Led and grew a team of 20 engineers; owned architecture, hiring, technical sales, and on-site business/technical workshops in Norway, Italy, and the UK. Shipped 10+ products across those clients; highlights below.
- Touchcom (Oslo) — designed and led a micro-serviced building access-control system: API, admin panel, mobile apps, an Electron app on an IoT device, plus logging and custom monitoring.
- Autopilot (US) — highly scalable marketing-automation integrations (Mailchimp, Segment, Mixpanel, Intercom).

### Full-Stack / Front-End Developer · MU Interactive Media

Mar 2013 – Mar 2016 · Warsaw

- Built a custom JS presentation player for a PepsiCo conference with Logitech R400 presenter integration.
- Built a marketing & mailing-automation system for IBM Poland, a no-code visual website builder, and a JS video player for VOD & live-streaming.
- Full-stack across JS/HTML5/CSS3/Sass/jQuery/WordPress and PHP/Node.js/MySQL/MongoDB; managed LAMP/LNMP stacks.

## Products

- Loki Messages (https://lokimessages.com): iMessage as a REST API and MCP server for agents.
- Beside (https://beside.chat): Live-location consumer agent that lives as a contact in Messages.
- Predicts (https://predicts.chat): Onchain prediction-markets agent trading Polymarket by text or voice.

## Skills

### AI / LLM

AI-native product building (intelligence as the product), agents & agent loops, LLM orchestration, MCP (Model Context Protocol), ChatGPT / MCP Apps, tool calling, context & loop engineering, evaluation & observability (LLM-as-judge, deterministic assertions), non-deterministic/probabilistic quality, provider-agnostic model routing / failover, guardrails & human-in-the-loop, multi-provider AI fluency, RAG/pgvector, Anthropic & OpenAI APIs.

### Mobile / Web / Desktop

React Native / Expo (core), native iOS (Swift/Obj-C) & Android (Kotlin), enterprise iOS App Clips, Capacitor, React / Next.js, Electron desktop apps, browser extensions, WebView / WKWebView automation, Apple Pay, EAS / TestFlight, deep linking, OTA; multi-platform SDK authoring (Swift/Kotlin/Expo/TS), TypeScript, JavaScript, Python, SQL, PHP.

### MarTech / Data / Fintech

CDPs, Segment, Braze, Salesforce, Brevo, Snowflake, Starburst, Apache Airflow, Retool (internal tools), Branch.io / Google Tag Manager (attribution), product & issue analytics, SKAdNetwork/ATT, Adjust, Mixpanel, Plaid, Yodlee, Robinhood, Coinbase, Stripe, Apple Pay, onchain agents (Solana, Polymarket CLOB, Privy self-custody wallets, Polygon/USDC, gasless settlement).

### Backend / Cloud

Node.js, Hono, NestJS, tRPC, GraphQL, Postgres/Drizzle, Redis, WebSockets, Cloudflare Workers / Durable Objects / D1 / R2, GCP (Cloud Run, Memorystore) & AWS (ECS/ECR), Terraform, GitHub Actions CI/CD. Leadershipfounding engineer, team lead (up to ~20), hiring (100+ interviews), CTO, technical sales, stakeholder workshops.

## Education

- Warsaw University of Technology — Engineer's degree, Electronics & Information Technology · 2011–2015 | exchange at Universidad de Las Palmas de Gran Canaria · 2013–2014 (research: h.264 vs h.265)

## Detail

### Founder · Loki Messages, Beside & Predicts (current role)

Loki Messages, Beside & Predicts · Founder · May 2026 – Present · Warsaw, Poland (remote) My own company. Three products, built end-to-end and solo, the AI-native way: a messaging platform for agents plus two consumer apps on top of it (a live-location assistant and an onchain prediction-markets trading agent). The generalist / full-stack / full-ownership story — one person from native macOS systems programming to the edge agent runtime to shipped, localized consumer apps and a self-custody trading wallet.

One-paragraph summary:
Founded Loki Labs and shipped three products end-to-end, solo, over one shared agent runtime. Loki
Messages turns iMessage into a REST API and MCP server for agents: a fleet of Mac agents exposes
send/receive, reactions, typing, read receipts, native polls and live location as 30+ endpoints with
sub-second webhooks, over real US/EU numbers and no third-party SMS gateways. Beside is a consumer
assistant on that platform — a live-location-aware agent that lives as a contact in Messages and texts
you the moment you're near something you care about; no app, no account, localized into 50+ languages.
Predicts is a second consumer actor — an onchain prediction-markets agent that trades Polymarket by
text or voice, with grounded live odds and Auto Trade on a Privy self-custody wallet settling gaslessly
on Polygon. Designed the whole agent architecture: one runtime on Cloudflare Durable Objects where
every conversation is a stateful agent, tools run over MCP, and a single agent plays multiple branded
personas across iMessage, WhatsApp and Telegram (Beside and Predicts are two of them). Went deep on the native
layer where it mattered: AppleScript automation plus a private IMCore dylib injected into Messages, and a
FindMy bridge for live location.

Why it matters for hiring a generalist, AI-native, full-stack engineer (lead high-level):
- 0→1 whole-product ownership, solo: platform + consumer app + billing, from the metal to the edge to the App Store, one person.
- Full-stack range in one project: native macOS / Swift systems programming, an edge runtime (Cloudflare Workers + Durable Objects), a developer REST API + MCP, and a localized consumer app.
- AI-native by construction: the agent loop, tools, personas, evals and tracing are* the product, not a bolt-on; and it was built with* fleets of coding agents at founder velocity.

Loki Messages — iMessage as a REST API and MCP (messaging infrastructure for agents)
- iMessage infrastructure from the metal up: a fleet of always-on Mac agents turn Messages into a programmable two-way channel and push events to a Cloudflare Worker (D1 storage, webhook delivery, REST API) over a per-agent Cloudflare Tunnel.
- 30+ REST endpoints + MCP: messages, native iMessage polls (live vote webhooks), tapback reactions, typing indicators, read receipts, attachments, threaded replies, live-location requests — inbound events arrive as structured JSON in under a second.
- Own fleet, own numbers, no gray routes: real registered US/EU numbers, no third-party SMS gateways.
- Fleet provisioning as code (Ansible): playbooks (add-mac-users.yml, deploy-agent.yml; roles mac-user, imsg-agent) create each macOS user, install the agent, and bring up its Cloudflare Tunnel + remote-VNC access; a companion session-keeper service holds VNC sessions alive across the fleet. (Accuracy note: Ansible provisions the agents; the Cloudflare Tunnel is minted by the Worker API + a bash-installed cloudflared launchd daemon, and the session-keeper is a separate Dockerized service on GCE — there is no Terraform in the repo.)
- Native systems programming: a Swift imsg CLI/RPC server with two send paths — AppleScript (public, no private APIs) and a private IMCore dylib injected into Messages.app via DYLD_INSERT_LIBRARIES (typing, receipts, reaction threading, multi-file send, contact/location) — plus a FindMy dylib that swizzles the XPC Trampoline to serve live location over file-based IPC; NSKeyedArchiver balloon messages for native polls; reverse-engineered APNs keepalive for delivery. Watchdog/restart, serial-lock, session-keeper for uptime.
- Loki Chat: stand up a chatbot that lives as a contact — system prompt + MCP servers, pinned to a real number, every reply shipped as iMessage.

Beside Chat — live-location consumer agent (the actor)
- Agent as a contact: shares your live location via Apple's own Messages location sharing, checks it on a schedule, and texts you when you're near something you asked to watch for (coffee, deals, a bakery, a course). Sends photos/menus as native Messages carousels, remembers preferences, joins group chats to run polls and pick plans, and schedules its own reminders.
- Zero to live, no app, no account: onboarding is one text; free to start with 1,000 credits; plans/credits + enforcement live. Localized into 50+ languages.

Predicts — onchain prediction-markets agent (the trading actor · predicts.chat) The crypto / onchain story. A second consumer actor over the same Loki runtime — no new codebase — that takes the agent from "answer questions" to "hold and move real money onchain, safely."
- Trades Polymarket by text: ask any prediction market by text or voice, get grounded live odds, a live trending board (highest 24h volume), generated market cards, and alerts on new or moving markets. Auto Trade turns a plain-language rule ("buy YES under 30%", "every hour back the underdog for $1") into placed orders.
- Polymarket integration: real onchain markets executed through Polymarket's CLOB via the @polymarket/client SDK — gasless transaction preparation (prepareGaslessTransaction) and CLOB order placement. Settlement is on Polygon in USDC/pUSD, gasless (no network fees for the user to manage).
- Privy self-custody wallets (the trust layer): each user gets an embedded MPC wallet minted inside Privy's secure hardware (Privy is the wallet infrastructure behind Polymarket itself, now owned by Stripe). Non-custodial: Predicts never sees or stores the key. The agent holds only a delegated signing grant policy-locked to Polymarket's trading contracts, inside caps the user sets; it cannot move funds anywhere else. Withdrawals can be signed only by the user; the grant is revocable in one tap; login by email, phone or passkey.
- Financial guardrails (human-in-the-loop money): per-account per-trade and daily caps (hard ceilings); small trades auto-confirm under a user-set limit, larger ones require explicit iMessage confirmation; caps are enforced in placeOrder/checkCaps, editable from chat or the wallet page.
- Onchain infra I had to build: a fiat + crypto onramp (fund with card, Apple Pay, Coinbase, or crypto from any chain via Privy onramps — Stripe / MoonPay / Coinbase), a PII-free wallet-link web app (trade.predicts.chat), and a self-hosted order relay (a box + Cloudflare Tunnel + Access) so the geo-blocked Polymarket order endpoint can be reached reliably from the edge runtime.
- Live: loki@predicts.chat in production; Auto Trade live for accounts that link a wallet; same runtime reachable on iMessage, WhatsApp and Telegram.

Multi-channel surface area

The one-line claim: deep experience building AI agents that run across many channels at once, off many data sources. iMessage is the deepest piece of engineering, but leading with it undersells the work and reads as a single-platform specialism. Every item below is already documented elsewhere in this file.

- Chat transports, one runtime: iMessage, WhatsApp Cloud API and Telegram, same agent, same state. A transport picker on the web surface routes a user to whichever one they use.
- Inside other assistants: Passage Money ran entirely inside ChatGPT and Claude over MCP, with no app and no website. That is another channel, and an unusual one.
- Web: beside.chat, predicts.chat and the PII-free wallet-link web app trade.predicts.chat (Astro / Next.js on Cloudflare), plus Passage's session-replay dashboard as a React SPA.
- Mobile: React Native and Expo at the core with native iOS (Swift, Obj-C) and Android (Kotlin) modules, enterprise App Clips, and a consumer app taken zero to the App Store.
- Desktop: AnyMail ships a real native macOS app (Xcode project, universal signed DMG, Sparkle 2 auto-update) wrapping a local engine that gives agents IMAP/SMTP access across Gmail, iCloud and Fastmail. Public MIT repo, github.com/MarcinWalendowski/anymail-mcp.
- Voice / telephony: the Oslo SIP door intercom, 2016-2019 - real-time voice and video a decade before the voice-agent wave.

- Referral program end-to-end (SPEC-256/258/260 + platform migration 0052_referral_granting.sql): invite codes on shareable onboarding cards, an invite landing banner on the homepage (/?invite=CODE), and a granting backend — +500 credits to the referrer at attribution (capped at 5) plus +2,000 per referred paid invoice, with a ledger↔balance invariant.
- Web→chat attribution (SPEC-084): short codes carried from the marketing site into the first iMessage so a web visit is attributable to the conversation it becomes; also used for campaign CTAs.
- Programmatic localized page generation (Beside i18n): the marketing site is generated into 54 languages (53 picker languages + English) — translated page dictionaries + localized onboarding-card PNGs in R2, keyed by a content version (I18N_CONTENT_VERSION), with cold-generation on first request for missing packs. This is a real "localization framework for international audiences" + programmatic-SEO build, solo.
- Marketing boards with live data: predicts.chat renders a live trending-markets board (24h-volume ranked, min-prob display band) with SVG market cards generated server-side and CTA pills that deep-link into the chat with a market-ref token so the bot skips search (SPEC-230).
- Analytics: PostHog per-product projects (three EU projects: LokiMessages / Beside / Predicts) wired via a shared PostHogScript component, behind a consent banner; GA4 on the marketing site (stripped in local deploys). Funnels and event capture are his own instrumentation.
- Content ops / automated distribution: LinkedIn autopost loops for Predicts (~3h cadence) and Beside (daily, ledger-gated; SPEC-300) publishing data-driven card templates (1200×627 + 1080×1350, headless-Chrome rendered) — a ledger file is the no-repeat guarantee. Plus a manual social-comment skill (Reddit/LinkedIn) with a cross-product account-safety gate.

Whole agent architecture (the runtime behind all three)
- Agent harness on the Vercel AI SDK, self-hosted on Cloudflare Durable Objects. The agent loop is the AI SDK's generateText multi-step tool-calling loop (bounded by stopWhen: stepCountIs(...)), run once per conversation inside a stateful DO (SQLite + alarms). Per turn: inbound, multimodal content build (text/images/polls/locations), group-chat respond/clarify/ignore decision, the model with tool calling, tool execution, persist, deliver. The loop primitive is the framework; the routing, MCP client, state, caching, tracing, cost metering, and money guardrails are all custom code. (Not Anthropic Managed Agents, not the Tool Runner, not a hand-rolled loop.)
- Provider-agnostic model routing with failover. One resolver over four providers (Anthropic, OpenAI, Google, Cloudflare Workers AI) with a three-role picker (chat, scheduled-check, fallback) and automatic primary-to-fallback failover on timeout or error. Default chat model Claude Sonnet, cheaper Claude Haiku for scheduled-check and fallback turns. Had to make tool-call ids portable across providers so a fallback to a non-Anthropic model does not poison the replayed history.
- MCP client over the AI SDK (@ai-sdk/mcp). Connects to provider MCP servers per turn over streamable HTTP, merges their tools into the model's tool set, and runs a full OAuth flow (dynamic client registration + PKCE) with tokens persisted in the DO. Provider MCP servers (Sweetgreen, Fandango, GolfNow, …) plus a media package, with an OAuth bridge for authenticated MCP.
- Context and loop engineering. Anthropic prompt caching with a byte-stable, quantized history window so the cached prefix survives across turns; stable-vs-volatile system-prompt sections; tool-result truncation; per-turn tracing that snapshots the exact model input; token and cost metering every turn.
- One agent, many actors. Personas are pure config + branding over a single runtime (Beside and Predicts are two actors); no separate codebase per product.
- Reliability. Scheduled proactive tasks with catch-up-storm guardrails, idempotent/replay-safe delivery, a per-conversation rate limiter, and full request tracing across services. Fixed an infinite alarm loop (SQLite datetime mismatch in the DO scheduler).
- Money guardrails (Predicts). Trades pass through a closed-grammar confirmation and fail-closed per-trade and daily caps; fills, OTP, and cap rejections are authored deterministically, never by the model, so the agent can never claim a trade filled unless it did.
- Substrate / platform: identity, orgs, API keys, JWT issuance and billing behind the products.

Tech: TypeScript, Swift, Objective-C, Cloudflare Workers/Durable Objects/D1/KV/R2/Browser Rendering, Hono, Zod, Vitest, pino, SQLite, Astro, Apple IMCore/APNs/FindMy, MCP, Vercel AI SDK, Anthropic/OpenAI, Privy (embedded self-custody wallets), Polymarket @polymarket/client CLOB SDK, Polygon/USDC, Telegram Bot API.

### Passage  ·  AI-Native Founding Engineer

Passage (Passage Money) · Full-time · Dec 2024 – May 2026 · New York, US (hybrid) Seed-stage fintech (ex-Plaid team; $2.5M from Mischief & Saga). Solo/founder-level engineering ownership across three products, AI-augmented.

One-paragraph summary (business-first):
Founding engineer building Passage's agentic finance products end-to-end. Shipped Passage
Money — a personal-finance assistant that lives entirely inside ChatGPT and Claude
via 27+ MCP tools, an OAuth authorization server, and an agent-inside-a-tool-call
(ask_passage) — plus the eval harness and production observability that keep a
non-deterministic AI product reliable. Built Passage Connect, an App-Clip + browser-automation
data-connectivity platform with 20+ merchant integrations and a session-replay dashboard, and
Gravy, a gamified cash-back mobile app taken from zero to the App Store. Consolidated the
stack onto Cloudflare Workers + Durable Objects, cutting one auth flow from 2,500 → 180
lines and dashboard polling by ~98%.

Method & platform:
Built spec-first: a spec-driven flow with custom agent skills and custom MCP connectors
for self-tracing observability and loop control (MCP tools that let the agent query its own logs).
Provider-agnostic across Anthropic & OpenAI. Runs on Cloudflare Workers + Durable Objects —
incl. persistent agent memory / session state on Durable Objects, context-window management.
and Cloudflare Code Mode (the agent calls its 27+ tools as code* instead of chaining tool calls).
RAG: semantic retrieval with pgvector + OpenAI embeddings (text-embedding-3-small, 1536-dim).
hybrid prefix/substring/semantic search.

### 4a. Passage Money — Agentic personal finance ("the agents")

The flagship AI product. Personal finance that lives inside ChatGPT / Claude — no app, no website.

⭐ First-wave differentiator. Passage Money is one of the first
full-featured consumer apps built on the OpenAI Apps SDK (ChatGPT Apps) and the MCP Apps spec.
I was building on the OpenAI Apps SDK in Nov 2025 – Jan 2026 — weeks after its Oct-2025
launch — then drove the migration to the MCP Apps SDK for cross-host support. Very few
engineers have shipped a production ChatGPT App and* MCP app of this depth this early.

Architecture & agent design
- MCP server exposing 27+ tools for financial queries, account management, budgeting, goal tracking — each with Zod input schemas and visibility flags (["app"] vs ["llm"]) to hide internal widget-plumbing tools from the model.
- ask_passage — an agent inside a tool call. The host LLM (ChatGPT/Claude) calls one tool, which spawns its own nested inference loop that calls other MCP tools (transactions, balances, goals), accumulates context across turns, and returns a synthesized answer with a requestId for feedback correlation. Agent-in-agent, hand-rolled (no LangChain).
- Standalone OAuth 2.0 Authorization Server with PKCE + Dynamic Client Registration (RFC 7591) so any MCP host can register and authenticate.
- Interactive widgets in chat — widget↔server communication routed through internal MCP tool calls (get_widget_data, widget_action, hidden from the LLM).
- Human-in-the-loop payments: agent-initiated payment flows that pause for explicit user approval, including crypto payments through Coinbase.

Context engineering (the part interviewers probe)
- Active-state injection: live polls (with current tallies), scheduled tasks, and recent data injected directly into the system prompt so the agent always knows current state without an extra retrieval hop.
- Tool-result truncation: 8k-char cap on tool results before they enter conversation history — added after a tool returned full HTML and blew the context window on the next turn.
- Format-for-tokens: switched a data-heavy tool response from JSON → Markdown specifically to cut token consumption and stop the LLM truncating list items.
- Full tool-call history preservation: stored complete response.content arrays including mcp_tool_use / mcp_tool_result blocks (not just text) so multi-turn replay keeps tool context.
- Debug-field stripping: all 10 agentic wrapper tools were leaking internal fields (trace, toolCalls, hasErrors) back to the model, which then referenced them to users — systematically stripped at the transport boundary.

Evaluation — 3-layer harness (strongest area)
1. Deterministic content assertions (arrayContains, fieldEquals, hasField) verify tool responses have the right structure/UI elements/data — no LLM flakiness.
2. LLM-as-judge for open-ended quality, with per-judgment token-cost tracking.
3. Lifecycle-stage testing — IncrementalSeedContext seeds the DB progressively (empty → connected → transactions → goals); 38 cases assert the same tool returns stage-appropriate content.
- CI benchmark pipeline: async batch execution (HTTP 202 + poll), historical benchmark storage with charts/comparison tables, path-based skip detection (saves ~7 min on unrelated PRs), session warmup for reproducibility. 294+ tests across webapp + mcp-server + mcp-handlers.

Provider & platform migrations
- OpenAI Apps SDK → MCP Apps SDK: migrated 184 files + 12 widget bundles for cross-host compatibility (ChatGPT + Claude).
- OpenAI Responses API → Anthropic SDK: structured-completion utility (zodOutputFormat + messages.parse), LLM judge, QA agent, multi-turn history with full tool-call context.
- Model routing for cost: Haiku for cheap structured extraction (column mapping, judging), Opus for complex reasoning.

Infra & data
- GCP infrastructure-as-code (Terraform): 3 Cloud Run services, Memorystore Redis over VPC, Artifact Registry, Secret Manager, Cloudflare DNS, plan-on-PR / apply-on-merge CI/CD.
- Data import pipeline: CSV (drag-drop, multi-file, AI column mapping + merchant categorization), Google Sheets (OAuth, multi-spreadsheet picker), native spreadsheet import (.xlsx/.xls/.ods/.numbers via SheetJS) with nonce-based replay prevention + OOM guards.
- Chrome extension (WXT): MCP setup automation for ChatGPT/Claude, connector status detection, programmatic window.passage.connect() API, structured logger replacing 200+ console.* calls.

Observability so the AI debugs itself
- Full MCP tool-call request/response logging; per-query SQL timing with colored badges; tool-call-viewer UI; user feedback joined to logs via requestId.
- query_logs / get_log_trace MCP tools — the agent can search and trace its own logs.
- Sentry with postgresIntegration() for automatic SQL spans, per-operation transaction naming.

Tech: TypeScript, Next.js (App Router), Cloudflare Workers, Hono, Terraform, GCP Cloud Run, Memorystore Redis, PostgreSQL/Drizzle, Inngest, Auth0 + custom OAuth AS, Plaid, Sentry, Segment, Chrome Extension (WXT), SheetJS, pgvector, Anthropic + OpenAI SDKs, MCP.

### 4b. Passage Connect — App-Clip + browser-automation data connectivity ("scraping service")

Lets users link real accounts (AT&T, T-Mobile, Uber Eats, Sweetgreen, Fandango, betting apps, …) to third-party apps via Apple App Clips with real-time browser automation. Plaid, but for the long tail of consumer accounts that have no API.

Public positioning (getpassage.ai): *"Connect to any account. An account-linking API for
developers. Your users log in on their own device — credentials never touch your servers."
Zero-knowledge by design — passwords/tokens never leave the phone. Flow: backend
POST /v1/links → claim code + iOS App Clip URL → user authenticates in the App Clip →
backend receives an ES256-signed webhook with validated, structured results. Sessions run on
Cloudflare Durable Objects at the edge with <50ms relay latency. Pre-built provider
automations + a Playwright-like Sessions API (navigate/click/fill/wait) for any site.
Developer preview.

- Session orchestration: Cloudflare Durable Objects coordinate browser-automation commands over WebSocket with a client-driven Swift SDK running WKWebView. Server-side script injection decouples telemetry from SDK releases. <50ms edge relay latency.
- Browser-automation engine: Browserbase-backed headless automation for server-side merchant flows (Amazon, DoorDash, Netflix, Spotify, Airbnb, Grubhub, Target, Walgreens, …); WebSocket command/control (later migrated to HTTP long-polling for mobile reliability), script injection, network interception, HAR processing with atomic Redis/Lua scripts; command idempotency via SET NX; subscribe-before-emit to kill races. Live telemetry (console/network/screenshots) streamed to the dashboard; ES256-signed webhooks for result delivery.
- Multi-tenant OAuth 2.0 (ES256 JWT, PKCE, magic-link login, refresh-token rotation, RBAC) — replaced Cloudflare Access with a purpose-built auth layer.
- Session-replay dashboard (React SPA): screenshot filmstrip, timeline, interaction capture via perceptual-hash dedup, sensitive-data masking, dynamic automation-flow visualization. Cut polling overhead ~98% (1,500 → ~10 subrequests/min).
- Architecture migration: NestJS + Socket.io + GCP → Next.js 15 + Cloudflare Durable Objects; reduced the main auth flow 2,500 → 180 lines and cut infrastructure cost & operational overhead ~in half.
- "Unscrapable" merchant coverage (signature framing): cracked account-linking on sites that actively resist automation — Walmart, Starbucks, Marriott, Google Maps, AT&T, Verizon — the AI-native way with agentic loops that adapt per page, delivered through a Plaid-style connect flow in an embedded/injected WebView inside an iOS App Clip, exposed across the multi-language SDKs.
- CI/CD: tag-triggered production releases, git-cliff changelogs, Sentry source maps. 48 tests.

Tech: TypeScript, Swift, Cloudflare Workers/D1/R2/Durable Objects, Hono, React, Vite, WKWebView, Redis, Playwright, pino, Vitest, Sentry.

### 4c. Gravy — gamified cash-back consumer app ("betting app")

React Native (Expo) consumer app: gamified cash-back rewards that trigger on events (incl. sports). Taken from zero to App Store submission.

- Full-stack delivery, zero → App Store: Expo/EAS build pipelines, GitHub Actions CI/CD, TestFlight distribution, OTA updates.
- Shop / checkout: WebView-based merchant checkout (Chipotle, DoorDash, Starbucks), Apple Pay, Stripe payment methods, gift-card fulfillment, order tracking.
- Gamification: "free throws" reward mechanics, contests with configurable cron schedules, surveys, promotional banners — the mechanics behind event-triggered cash-back.
- Betting integration + real-time data: Gravy's cash-back triggers on real-time sports-event data — rewards fire the moment game conditions hit — and users' betting accounts are linked through the Connect account-linking platform (betting apps are one of Connect's provider categories).
- Account-connection platform: WebView merchant-connection flows with background sync, cookie management, provider-config v2 migration enabling 15+ merchants.
- Regulated-product infra: IP-based geofencing (FL, WA, CT, UT) for regulatory compliance — the kind of state-by-state gating sweepstakes/betting-adjacent products require.
- User infra: Clerk auth with userId migration, Adjust deep-link attribution (replaced Branch), Intercom, Sentry session replays, Axiom logging.
- Payments backend (shared w/ Connect): Stripe-integrated gift-card purchasing (59 files, 5,500+ LOC) — payment-intent lifecycle, webhook handling, Fluz provider abstraction, and payment-aware automation that pauses for user payment then resumes with the gift-card code.

Tech: React Native (Expo SDK 53), TypeScript, tRPC, Drizzle ORM, PostgreSQL, Stripe, Apple Pay, Tamagui, Clerk, Sentry, Adjust, Intercom.

Moved to Loki Labs. The native iMessage platform, the Durable-Objects agent runtime, and
the provider MCP-server catalog (Sweetgreen / Fandango / GolfNow) are my own Loki Labs work, not
Passage — see the Loki Labs section above. Passage Money reached users through ChatGPT and Claude.
its own finance tools stay.

### 4d. Passage Money Chrome extension

The browser-extension story, verified against a private repository git history. Marcin is the largest single contributor to the extension (43 of 109 commits) and the sole author of the MCP connector-automation subsystem (lib/mcp-setup/, 13/13 commits).

- Shipped product: "Passage Money" on the Chrome Web Store (MV3, WXT, TypeScript, v1.10.0, ~8.7k LOC extension + 4.6k LOC companion SDK).
- Connector-on-install automation (his flagship piece): chrome.runtime.onInstalled → onboarding flow → drives the ChatGPT and Claude web UIs end to end to add Passage as an MCP connector: settings navigation, enabling ChatGPT Developer Mode, custom-connector form fill from server-delivered OAuth client config (/api/mcp/config, cookie-authed, 4-origin CORS allow-list), auto-clicked OAuth consent, per-tool "Always allow" permissions on Claude, and a welcome prompt typed character-by-character with human-like delays to trigger ChatGPT's @-mention autocomplete. Idempotent (finds and removes stale connectors — on ChatGPT via its private backend API with Bearer token + principalId; on Claude via DOM) and resumable across OAuth redirects and full page reloads (sessionStorage + chrome.storage flags + MutationObserver + URL polling); 15s-stall fallback overlays escape to a manual guided path.
- Engineering internals: MAIN/ISOLATED world split exposing a page-level window.passage API (MAIN world can't touch chrome.*, relays via postMessage to an ISOLATED sibling); CSP-safe script execution via chrome.scripting.executeScript({world:"MAIN"}); origin validation on every inbound message, sender authorization in the service worker (messages from tabs without a live session are dropped); 41 runtime type guards in a shared-types package with ESLint switch-exhaustiveness as an error; multi-session automation popups (per-session Socket.IO, three reverse indexes) driven by server-delivered scripts; network interceptor injected before first page byte (webNavigation.onCommitted); SPA navigation detection via history patching; batched structured logging routed through the service worker (zero console output in prod); Sentry shared-environments pattern so the extension can't pollute host-page error handling.
- Plaid integration (server + webapp, not in the extension): Plaid Link (react-plaid-link, client_name "Passage Save", 730-day transactions), public-token exchange, Transactions Sync, Investments, Liabilities, Recurring/Income streams, Institutions, Balances; webhook verification done properly — ES256 JWT via JWKS, 5-min maxTokenAge, SHA-256 body hash compared with crypto.timingSafeEqual; async Inngest pipeline; daily balance snapshots. The extension's role is the handoff: window.passage.connect(integrationId) opens the Plaid Link popup.

### 4e. Passage SDK platform (6 platforms)

Built and maintained the browser-automation/session SDK across every major client:
- Swift — v2 session architecture, 21 WebView commands, yield-condition evaluation, telemetry interceptors, WebSocket transport, 63 unit tests.
- Kotlin/Android — WebView commands, network interceptor, JitPack publishing.
- React Native — provider pattern, recording mode, scroll/interaction tracking, CI releases.
- Expo module — native bridge wrapping the Swift SDK, CocoaPods integration.
- Capacitor plugin — iOS + Android, analytics, remote logging.
- Web React — modal/embed modes, WebSocket status updates, App-Clip support, analytics.

### 4f. Signature stories

1. Agent inside a tool call (ask_passage) — nested inference + tool calling, hand-rolled.
2. 3-layer eval harness — deterministic + LLM-judge + lifecycle seeding, all in CI.
3. Context-window blow-up — tool-result truncation + JSON→Markdown after a tool returned full HTML.
4. Sentry connection drops — ripped out pool.query monkey-patch for postgresIntegration().
5. 2,500 → 180-line auth flow — NestJS+Socket.io+GCP → Next.js + Durable Objects.
6. Tool retrieval at scale — 1,000+ providers' MCP tools indexed and document/file-searched per query (RAG-MCP-style) so the context window stays small; function calling + structured outputs keep behavior reliable.

### 4g. Impact metrics

- 3 products shipped as founding engineer (Passage Money, Passage Connect, Gravy), AI-augmented, founder-level scope.
- 27+ MCP tools + agent-in-a-tool-call; 184 files / 12 widgets migrated cross-host.
- 1,000+ data providers / sources made agent-callable via document/file-search tool retrieval (tool catalogs indexed, retrieved per query — not loaded into context); function calling & structured outputs for reliable, schema-constrained agent behavior. Named examples: SaaS/CRM and comms sources like Slack, Salesforce, HubSpot and Gmail, alongside custom-built connectors for sources with no API such as Walmart and Amazon.
- 20+ merchant integrations; 15+ merchant connection flows in the consumer app.
- ~98% dashboard polling reduction (1,500 → ~10 subrequests/min).
- 2,500 → 180 lines on the main auth flow via architecture migration.
- One of the first full-featured consumer apps on the OpenAI Apps SDK (ChatGPT Apps) and the MCP Apps spec — shipped weeks after the SDK's launch.
- ~$2.5M seed raised by the company (public); founding Plaid engineers; backed by Plaid's CEO
 + Max Altman + Mischief + Saga.
- Supporting activity (internal): 2,249+ commits, 908+ PRs, 37 repos in ~14 months.

### Prior Roles

### Checkatrade — Staff Software Engineer (Platform / MarTech) Contract · Sep 2023 – Dec 2024 · London, UK (remote) UK's #1 home-services marketplace.
- MarTech platform engineering — scaled architecture to 100,000+ RPS; drove cross-team CI/CD, release engineering, and observability improvements.
- Migrated 5M+ customer profiles from Salesforce into Segment & Braze — stood up the event-collection and activation layer that unified customer data across the marketing stack.
- Lifecycle comms & attribution — orchestrated messaging across multiple providers (incl. a migration to Brevo) and kept attribution accurate across Branch.io, Google Tag Manager, and the wider marketing stack.
- Internal tooling & analytics — built internal tools in Retool plus product & issue analytics on Snowflake data, giving marketing and product teams self-serve insight.

### Astor — Head of Engineering Full-time · Sep 2022 – Sep 2023 · New York (remote) Astor (astor.money) — a community-driven personal-finance app founded 2021 by Lindsay Dorf (ex-BlackRock Aladdin, ex-Google). Aggregates bank & brokerage accounts into one wealth picture and pairs it with community-investing (a gamified "Path to Wealth"); audience skews women 20–35. Backed by NFX, TMV, Stellation Capital, and MBA Fund.
- Built and led a top-tier team of 5 engineers; owned the engineering architecture across iOS, Android, backend & platform (NestJS); built mobile + backend.
- Built financial-data integrations across Yodlee, Plaid, Robinhood — bank/brokerage/transaction sync and OAuth flows.

### No Big Deal SA — Founding Product Engineer Sep 2021 – Sep 2022 · Luxembourg (remote) Mobile engagement-marketing + wellbeing/fitness app (nobigdeal.io; iOS + Android).
- Led mobile development; designed CI/CD for mobile tests/builds/deploys with Ansible + M1 Azure pipelines; built & maintained Detox e2e tests.
- Worked with native HealthKit and Google Fit APIs + background processing.
- Designed and led backend development of a Fitness service API, integrating Fitbit, Strava, Garmin, Polar.
- Stack: React Native, Reanimated v2, Expo, Fastlane, Ansible, Azure, GCP, NestJS, ECS/ECR, Stripe, Segment v2, Adjust, Leanplum, UXCam, Lottie, Firebase, Tableau.

### Taxfix — Staff Software Engineer (Frontend Platform & MarTech) Contract · Mar 2021 – Sep 2021 · Berlin, Germany (remote) Germany's most popular mobile tax app.
- Implemented iOS 14.5 ATT / SKAdNetwork attribution across a brownfield React Native app.
- Re-engineered mobile CI/CD: Bitrise → M1 bare-metal GitLab runners — created and maintained the Terraform that provisioned the bare-metal M1 Macs on MacStadium (third-party provider) with all the tooling/frameworks to run the pipelines, plus Ansible for configuration — total execution time −80% (~$20k/mo savings); unit + e2e (Detox) + CodePush.
- Built a GTM automation tool on GitLab pipelines; advanced Segment + Braze integrations (mobile + web). Stack incl. Snowflake, Fastlane, Adjust.

### Flip Fit (Humans, Inc.) — Founding Senior Engineer → Head of Mobile Engineering Oct 2019 – Mar 2021 (Head) · Apr 2019 – Oct 2019 (Founding Sr) · Los Angeles (remote) Startup merging social media with e-commerce.
- Led two mobile engineering teams (~10 each, ~20 engineers total) by the end of tenure; ran 100+ interviews, hired 2 RN core contributors.
- Shipped the app cross-platform for iOS and Android on React Native, authoring complex native modules on both platforms (Obj-C/Swift on iOS, Kotlin on Android): LL-HLS & HLS video player, RTMP live streaming (HaishinKit) with deep Akamai Video & Cloudflare Stream integration, reverse-proxy HLS segment caching (GCDWebServer), native logging (CocoaLumberjack), advanced push (Push Stories, action buttons, in-app messaging), deferred deep links, SDWebImage tuning, data normalization + prefetch/caching (PINCache).
- Segment + Mixpanel + Braze analytics; Sentry, CodePush, Reanimated, RxJS/Redux-Observable. Designed mobile architecture for performance & stability with advanced JS + native profiling.

### TeaCode.io — Co-Founder & CTO Mar 2016 – Mar 2019 · Warsaw / Oslo / London (remote) Boutique Node.js / React / React Native consultancy.
- Led a team of 20 engineers; owned architecture, hiring, technical sales, on-site stakeholder workshops. Shipped 10+ products for clients in Norway, the US, the UK, and Italy. Highlights:
- Touchcom (Oslo) — building access-control system: micro-services API, admin panel, mobile apps, Electron app on IoT device, logging + custom monitoring. Telephony / real-time layer: the door-entry side was a voice + video intercom built on SIP (SIP trunking / signalling between the door panel and residents' phones), VoIP push notifications to wake the iOS app for an incoming door call, and FaceTime as a call path to residents. So: SIP, VoIP push (PushKit-style silent wake), and FaceTime/native call integration in production, in 2016–2019 — a decade before the current voice-agent wave.
- Autopilot (US) — high-scale marketing-automation integrations (Mailchimp, Segment, Mixpanel, Intercom); CoffeeScript, Redis, CloudantDB, SproutCore.
- Broad cross-client stack: React, React Native, Node.js, Electron, Next.js, TypeScript, Meteor, Express, Sails, Koa, Feathers, MongoDB, Redis, RabbitMQ, MySQL/AuroraDB, Rancher, k8s, ELK, Prometheus, DataDog, serverless.

### MU Interactive Media — Full Stack Developer / Front End Developer Mar 2013 – Mar 2016 · Warsaw, Poland
- Custom JS presentation player for PepsiCo with Logitech R400 presenter integration.
- Marketing & mailing-automation system for IBM Poland; a no-code visual website builder; a JS video player for VOD & live-streaming. Backend + frontend for decyzje-it.pl.
- Full-stack across JS/HTML5/CSS3/Sass/jQuery/Bootstrap/WordPress + PHP/Node.js/MySQL/MongoDB; managed LAMP/LNMP stacks.

### Personal / onchain projects Applying the same agent-loop + guardrail patterns from Passage to financial decisioning onchain.
- Solana — built a loop-based trading agent: an autonomous strategy loop that monitors state, decides, and executes trades on-chain, with guardrails and human-in-the-loop for irreversible actions.
- Polymarket — a loop-based agent for prediction markets (probability-driven positioning). This is the direct precursor to Predicts, where the pattern became a shipped consumer product with Privy self-custody wallets, per-trade/daily caps, and gasless Polygon settlement.
- Reinforces the AI-native thesis (intelligence as the product) in a live, adversarial, money-on-the-line domain.

### Education

- Warsaw University of Technology — Engineer's degree, Electronics & Information Technology, 2011–2015 · Poland. Projects: OpenCV augmented-reality in Python (marker detection + rendering a physics-accurate glass of water), a multiplayer network game in Java, SOAP/WSDL services, and an Android app using the DJI SDK.
- Universidad de Las Palmas de Gran Canaria — Engineer's degree, Electronics & IT, 2013–2014 · Spain. Research: h.264 vs h.265 comparison via automated FFmpeg scripts (slideshare.net/mwalendo/h264vs-hevc).
- XIV LO im. Stanisława Staszica — High School, 2009–2011 · Warsaw, Poland.

### Skills & Tags Matrix

surface the right evidence. Format: category:: tags.

- AI / LLM::  AI-native product building (intelligence as the product, not bolt-on), agents, agent loops, LLM orchestration, agentic orchestration, MCP (Model Context Protocol), MCP Apps SDK, tool calling, context engineering, prompt engineering, evaluation & observability layer, LLM evals (LLM-as-judge, deterministic assertions), non-deterministic/probabilistic quality, drift monitoring, human-in-the-loop, guardrails & fallback logic, provider-agnostic model routing / failover, multi-provider AI fluency, RAG-ish state injection, Anthropic API (Claude), OpenAI API, Vercel AI SDK, cost/latency optimization, pgvector.
- Languages::  TypeScript, JavaScript, Swift, Objective-C, Kotlin, Python, PHP, SQL.
- Frontend::  React, React 19, Next.js (App Router), Vite, Tamagui, React Native, Expo, Chrome Extensions (WXT).
- Mobile::  React Native + Expo/EAS (core expertise), complemented by native iOS (Swift/Obj-C) and Android (Kotlin) module implementations and enterprise iOS App Clips; Capacitor, WebView/WKWebView automation, App Store / TestFlight, Apple Pay, deep linking, OTA, multi-platform SDK authoring (Swift/Kotlin/Expo/TS).
- MarTech / Data::  CDPs, Segment, Braze, Salesforce, Brevo, Snowflake, Starburst, Apache Airflow, Retool (internal tools), Branch.io / Google Tag Manager (attribution), product & issue analytics, SKAdNetwork / ATT attribution, Adjust, Mixpanel, marketing automation.

Passage used Segment, Customer.io, Branch.io, Mixpanel; at Checkatrade he was the MarTech tech lead (role framing on top of Staff SWE) and the attribution stack also included Adjust; Astor ran Segment, GTM, Branch.io, Mixpanel; Flip Fit also used Branch.io (fits the deferred-deep-links bullet). Customer.io is his third core CDP/lifecycle tool alongside Segment and Braze. Starburst belongs to Checkatrade (alongside Snowflake on the analytics side).
- Backend::  Node.js, Hono, NestJS, tRPC, Drizzle ORM, PostgreSQL, Redis, WebSockets, REST, GraphQL (client), Inngest.
- Cloud / Edge::  Cloudflare Workers, Durable Objects, D1, KV, R2, Browser Rendering; GCP (Cloud Run, Memorystore, Secret Manager, Artifact Registry); AWS (ECS/ECR); Azure; Render.com.
- Infra / DevOps::  Terraform, GitHub Actions, CI/CD, blue-green deploys, Docker, Cloudflare Tunnel, observability (Sentry, Axiom, CF Observability), git-cliff.
- Fintech / integrations::  Plaid, Yodlee, Robinhood, Coinbase, Stripe, Apple Pay, gift cards (Fluz), Segment, Braze, Adjust, Clerk, Auth0, Twilio, Linq.
- Onchain / trading::  Polymarket trading (CLOB, @polymarket/client SDK, gasless orders), Privy embedded self-custody / MPC wallets, delegated signing grants (policy-locked), Polygon / USDC, fiat + crypto onramps (Stripe / MoonPay / Coinbase), per-trade & daily caps, autonomous Auto Trade rules with human-in-the-loop, self-hosted order relay for geo-blocked endpoints; Solana loop-based trading agent. (Predicts is a shipped Loki Labs product; the standalone Solana/Polymarket bots are personal/side projects.)
- Security::  OAuth 2.0, PKCE, RFC 7591 (Dynamic Client Registration), ES256 JWT, JWKS, AES-256-GCM, HMAC webhook signing, timing-safe comparisons, nonce/replay prevention, RBAC.
- Systems::  dylib injection, NSKeyedArchiver parsing, XPC interception, APNs protocol tuning, HLS/LL-HLS, RTMP.
- Leadership::  founding engineer, team lead (up to ~20), hiring (100+ interviews), CTO, technical sales, stakeholder workshops.
- Practices::  spec-driven development (spec-first / SPEC-NNN before non-trivial work) · evals & CI benchmarks as first-class · test-driven against real infrastructure, no mocks · observability-first · type-safe boundaries (strict TS + Zod runtime validation) · trunk-based CI/CD · security by default · AI-augmented development (orchestrating coding-agent fleets).
- Scale/impact::  100k+ RPS, ~$20k/mo cost savings, −80% CI time, −98% polling, 2,500→180 LOC.

### Reusable Achievement Bullets

- Founded Loki Labs and shipped three products end-to-end, solo — Loki Messages (iMessage as a REST API and MCP for agents), Beside (a live-location consumer agent that lives as a contact in Messages), and Predicts (an onchain prediction-markets agent that trades Polymarket by text or voice) — spanning native macOS systems programming, an edge agent runtime, localized apps, and a Privy self-custody trading wallet.
- Shipped a self-custody onchain trading agent (Predicts): integrated Polymarket's CLOB (@polymarket/client, gasless orders) with Privy embedded self-custody wallets — a delegated signing grant policy-locked to Polymarket's contracts, per-trade and daily caps, human-in-the-loop above a limit, gasless Polygon/USDC settlement, and fiat/crypto onramps; built a self-hosted order relay (Cloudflare Tunnel + Access) to reach a geo-blocked endpoint from the edge.
- Built iMessage infrastructure from the metal up: a fleet of Mac agents exposing send/receive, reactions, typing, read receipts, native polls and live location as 30+ REST endpoints + MCP with sub-second webhooks, over real US/EU numbers and no third-party SMS gateways.
- Designed a whole agent architecture on Cloudflare Durable Objects — stateful per-conversation agents, MCP tool calling, model failover, proactive scheduled tasks, and one runtime that plays multiple branded personas (Beside Chat is one); shipped Beside Chat 0→live, localized into 50+ languages.
- Shipped a personal-finance AI agent inside ChatGPT/Claude via 27+ MCP tools and an agent-inside-a-tool-call, with a 3-layer eval harness and self-tracing observability; scaled tool selection across 1,000+ data providers/sources (Slack, Salesforce, HubSpot, Gmail, plus custom connectors for API-less sources like Walmart and Amazon) with document/file-search tool retrieval (RAG-style — each provider's MCP tools indexed and retrieved per query, not loaded into context) and function calling & structured outputs for reliable, schema-constrained agent behavior.
- Cut a core auth flow from 2,500 → 180 lines by migrating NestJS + Socket.io + GCP to Next.js + Cloudflare Durable Objects.
- Reduced real-time dashboard polling ~98% (1,500 → ~10 subrequests/min) via WebSocket + Durable Objects.
- Built an App-Clip + browser-automation data-connectivity platform (Plaid-style, credentials never leave the device) that cracks account-linking on sites that resist automation (Walmart, Starbucks, Marriott, Google Maps, AT&T, Verizon) via per-page agentic loops; 20+ merchant integrations; cut infra cost & overhead ~in half.
- Built loop-based trading agents for Solana (on-chain) and Polymarket prediction markets (personal) — the AI-native agent-loop + guardrail pattern applied to live financial decisioning.
- Reworked Checkatrade lifecycle comms across multiple providers (Brevo migration), fixed attribution across Branch.io / Google Tag Manager, and built Retool internal tools + product analytics on Snowflake.
- Diagnosed and fixed a 7× duplicate-send production bug by redesigning dependency injection for idempotent, replay-safe message delivery.
- Migrated 184 files + 12 widget bundles from OpenAI Apps SDK to MCP Apps SDK for cross-host (ChatGPT + Claude) compatibility.
- Took a React Native consumer app from zero to App Store, incl. Apple Pay, WebView checkout, gamification, and state-level geofencing for regulatory compliance.
- Scaled a MarTech platform to 100,000+ RPS (Checkatrade).
- Shipped a SIP voice/video door-intercom for a building access-control system in Oslo (Touchcom, TeaCode) — SIP signalling/trunking between door panels and residents, VoIP push notifications to wake the iOS app for an incoming call, and FaceTime as a resident call path, on a fleet of physical IoT devices. Real-time telephony in production 2016–2019, a decade before the voice-agent wave.
- Re-engineered mobile CI/CD Bitrise → M1 GitLab runners: −80% execution time, ~$20k/mo savings (Taxfix).
- Led ~20 engineers across two teams and ran 100+ interviews (Flip Fit); shipped the app cross-platform on React Native and authored native modules on both iOS (Obj-C/Swift) and Android (Kotlin), incl. an LL-HLS/HLS player and RTMP live streaming.
- Built financial-data integrations across Plaid, Yodlee, Robinhood, Coinbase (Astor, Passage).


## Writing

### ADLC: the loop that replaced my SDLC - how to become a 100x AI native engineer

2026-08-05 · https://marcinwalendowski.pl/writing/adlc-the-new-sdlc

I still write code by hand. Just not often, and not first.

Most of the time I write the intent down and a loop takes it from there. I open the editor when a change is smaller than the sentence it would take to describe, or when something is broken in a way I want to feel for myself.

What I can't do by hand is keep three products moving at once. Typing scales with the hours I have, and I don't have more hours. Getting anywhere near 100x meant designing the system so typing stopped being the main event.

That sounds like a productivity claim. It's really an architecture claim. The old lifecycle was built around a human doing the typing, and once that stopped being the main event, every stage around it had to be redesigned.

I run three live products across eight repos on my own. Two of them are agents you use by texting them. [beside.chat](https://beside.chat) lives as a contact in your Messages app and tells you what's good around you. [predicts.chat](https://predicts.chat) trades prediction markets from a text message.

The main monorepo has taken 858 commits since late April, 726 of them in the last 30 days. A good share of those are the loop's own bookkeeping, so read the number as a shape rather than a score.

Here is the shape.

## The old lifecycle was built around slow typing

Plan, design, build, test, ship. Every handoff in that list exists because writing code is slow, and because the person who wants the thing is usually not the person who writes it.

When an agent does most of the typing, the cost doesn't disappear. It moves. It moves to four places: getting intent out of my head, giving the agent enough context, deciding what done means, and proving it happened with evidence I can look at.

So I redesigned the stages around where the cost actually landed. I think of it as an agent development lifecycle, because it isn't the old one with autocomplete bolted on.

## 1. Capture is an input queue

Running several products at once means intent arrives out of order. That's the normal state of the job, not a failure mode, so I built for it rather than trying to be more disciplined about it.

Every idea goes in as one line of plain text, wherever I already am. The editor, the terminal, a chat window with an agent. No structure, no ticket, no title. Five seconds, then back to the thing I was already doing.

Notes land in one inbox that only I write to. Agents can read a note and mark it processed. They can't edit what I said. Capture belongs to me, and everything downstream of it is negotiable.

## 2. Context is the actual work

A one line note is useless on its own. The agent has to know which of eight repos I mean, what already exists, and which decisions were settled months ago and shouldn't be reopened.

So the context lives in three layers. A knowledge page holds decisions. 414 specs hold the reasoning behind each non trivial change. And 228 small memory files hold one lesson each.

The memory files do the most work per byte. One of them says a green test suite proves nothing after you delete code, because the test that would have caught it got deleted too. Another says a shipped fix is not a verified fix. Each one exists because something broke and I decided not to pay for it twice.

## 3. The spec is the unit of work

The agent turns a note into a spec. Problem, solution, phases, risks, and how the thing will be verified. Then I take the design apart and put it back together, usually across a few passes.

That's where my judgement goes now, and it's the right place for it. A paragraph is cheap to change. A merged branch is not.

Even numbering the specs needed a rule. Two sessions listed the directory in the same minute, got the same next number, and both shipped it. That happened twice in one day. So I wrote a small tool that unions every branch, every worktree and the working tree before it answers.

## 4. Rules go in code, not in prose

Writing a rule in a document and trusting the agent to follow it does not hold up. I have a measured failure for it: two applications to the same job, seven minutes apart, with contradictory answers, from a system whose rules were all prose.

The rules that matter are executable now. A gate returns an exit code and the run stops. Guards fail closed, so a missing input is a block rather than a pass.

The unattended loops work the same way. My social comment loop cannot post to the same thread twice, because a ledger refuses it, not because an agent remembers. A run that posts nothing is a good run.

## 5. Autonomous where it's safe, human where it isn't

Not everything should run alone. The split I use is simple: humans own only the irreversible.

A production watcher runs every five minutes across five workers and two Mac services. It pulls the errors, dedupes them against what it has seen before, fixes the clear cut low risk ones, and escalates the rest as tasks. It has a circuit breaker so it can't deploy in a tight loop.

Well scoped work runs the whole way, spec to deploy, with no PR in between. Anything touching money, migrations or someone's data stops and waits for me.

## 6. Done means it ran for real

Green gates are necessary and not sufficient. A typecheck cannot tell me a message actually arrived on a phone.

So every change runs end to end before it deploys, not after. Where there's a surface, that run is visual. An agent drives the real UI in a real browser, screenshots each step, and records the session. I watch the recording rather than read a summary of it. A screenshot is evidence. "Tests passed" is a claim, and the two are not the same thing.

For the messaging products the rule is the same and the surface is a phone, so a feature sits in QA until someone sends a real message to the real bot and reads the real reply. Until that has happened it's shipped, not done. Keeping those two words apart is most of what stops velocity from turning into damage.

## What carries over

If you want to try this across your own projects, three things do most of the work.

One inbox you never let a tool edit, so capture stays honest. One file per lesson, written the day it hurt, because that's the context an agent can't infer from your code. And one executable rule in place of each paragraph you keep re-explaining.

None of that needs a new platform. It's a text file, a ledger and an exit code.

## What actually got better

Context switching got cheap. That's the clearest result.

The cold start cost of picking a project back up was never the code. It was the decisions: what we settled, what we ruled out, and why. That state lives outside my head now, in files an agent can read, so resuming a project is reading a summary instead of rebuilding a model.

What I do all day now is orchestrate, plan and verify. I decide what gets built, set the work running in parallel, and check every result against what I actually asked for. That's the job I wanted.

The scarce skill isn't the typing. It's the architecture, the specs, and knowing exactly where a human has to stay in the loop.


## Scope

This document covers professional experience and the technology behind it.
It contains no personal contact details beyond the business email and booking link above.