Forward Deployed Engineer
I help companies put Claude into production.
So I built an operating system that runs my life on it.
Rees Calder. Cape Town. For the last year I have been doing the Forward Deployed Engineer job, for my own companies, before I knew it had that name.
Why I am writing to you
Your Forward Deployed Engineers embed with customers and turn Claude from a model behind an API into systems that create value in production. That is the most interesting job in the company, and it is the one I have quietly been doing for myself.
I did not set out to build a product. I set out to stop dropping things. I have ADHD, run several businesses, and have two kids under three. So I built Kern: a single Claude agent that runs my life and my companies, around the clock, across voice, mobile, chat, and a button on my desk.
Along the way I learned exactly what breaks when you push Claude from a chat window into a real operating system: memory, orchestration, tool reliability, cost, trust, and the interface a human actually uses to drive it. I have shipped answers to all of them. That is the work. I would like to do it for your customers next.
Meet Kern
An agent operating system, built by one person, on your stack.
Memory that survives
Postgres + pgvector with hybrid search, automatic entity extraction, temporal validity windows that know when a fact stopped being true, and self-running cron jobs that consolidate and decay it. It does not forget what you told it last week.
A harness that orchestrates itself
Kern is an orchestrator. It spawns specialist sub-agents in parallel, briefs them like colleagues, reviews their work in a three-tier triage, and loads specialised skill playbooks on demand.
One brain, many doors
The same agent answers in a custom web and mobile interface, in a Discord workspace, over real-time voice through AirPods, and through a physical hardware button on the desk.
Built on the Claude Agent SDK
Not a wrapper around a chat box. A long-running operating system on Claude Opus with a million-token context, Sonnet and Haiku for the cheaper sub-tasks, and MCP tools wired into everything it touches.
Autonomous, with consequences
Scheduled routines fire without being asked: daily intel briefings, outreach sequences, follow-ups, reminders. It triages the inbox, handles what it can, and escalates only what genuinely needs a human.
Real economic output
This is not a demo. Kern runs a lead-gen agency, CMO work for a marketplace with millions of monthly visitors, and a stack of content businesses. It produces products, sites, and campaigns every week.
Architecture, briefly
Four layers. One agent.
Claude Opus, 1M-token context
Sonnet and Haiku for cheaper sub-tasks.
Orchestrator, sub-agents, skills, MCP
Spawns specialists, reviews their work, loads playbooks, holds the tool layer.
Supabase pgvector, hybrid search
Entity extraction, temporal validity, write-time dedup, self-maintaining crons.
Web, mobile, Discord, voice, a physical button
One brain, reachable from anywhere, always on.
The interface
An agent is only as good as the surface you drive it from. So I designed and built one.
Kern has a custom web and mobile app. Channels per project, live dashboards that pull straight from GA4 and Search Console, a missions board, a production line of running agents, and real-time voice. The same thing a customer would need: not a terminal, a product.
Live per-project dashboards
Every product gets traffic, search, and activity widgets, refreshed daily by an auto-discovering cron.
Missions + production line
Long-running agent work is visible: what is queued, what is running, what shipped.
Voice + push, anywhere
Talk to it through AirPods, get pushed the things that matter, reply from your phone.
And for other companies
I do not just build my own. I ship bespoke interfaces for clients.
Custom dashboards, internal tools, and microsites wired into a client's own data and workflows. This is the same muscle a Forward Deployed Engineer uses: walk in, learn the operation, hand back something they can actually run on.
GoTyme — a bespoke interface built for a client engagement.
Mack — custom tooling built around a client's workflow.
What it runs
Real products, live in the world, managed day to day.
These are not side projects gathering dust. They get content, outreach, analytics, and fixes shipped to them every week, much of it by Kern.
RegShield
Reg S-P compliance for advisers
A one-time compliance toolkit pivoted toward exam-prep as the SEC named Reg S-P a 2026 exam priority. Document engine plus guidance, sold as a product.
The fit
What the role needs, and where I have already done it.
Turn Claude from an API into production systems that hold up in the real world.
Kern is exactly that: a production agent OS on the Agent SDK, running 24/7, doing real work with real stakes.
Embed with a customer, learn their workflows, rebuild their operations around the model.
I run four businesses on Claude. Each one got pulled apart and rebuilt around what the model is actually good at.
Be full-stack and fast. Ship solo when there is no team to wait for.
Around 100 repos of production apps, sites, interfaces, and automations. Idea to deployed without an engineering team behind me.
Design the surface, not just the backend. Customers need something they can actually use.
I build the interfaces too: Kern's own web and mobile app, plus bespoke dashboards and tools for client companies.
Handle ambiguity. Own the outcome, not just the ticket.
Kern sends real outreach, manages real calendars, spends real money, and makes real calls. I own all of it.
Teach it. Write the patterns down so others can run them.
Kern runs on playbooks I wrote: skills, agent-routing rules, a memory protocol. The system is the documentation.
How I work
The rules Kern runs on are the rules I run on.
Build it right.
Treat dev resource as unlimited. Choose the elegant, durable approach over the cheap hack. Invest in foundations so nothing needs reworking later.
Act, do not describe.
Every move makes progress or delivers a result. No “I will now” followed by silence. Do the thing.
Verify everything.
Never assume a change landed. Check the output, not the intent. Trust, then verify, every time.
Let me show you Kern live.
Thirty minutes. I will run it in front of you and you can decide if this is the kind of person you want in front of your customers.