Kern

A bridge + session manager run the agent loop, manage durable sessions, and broker every tool call. No LangGraph, no CrewAI — those were evaluated and rejected so the runtime stays understandable and tunable end to end.

The main loop stays lean and delegates substantive work to specialist agents (research, dev, writing, analysis), briefed with the context they need. Their work is reviewed before it ships.

Any untrusted text (emails, scraped pages, form submissions) is read by an isolated agent that returns only validated structured data. The orchestrator acts on the JSON, never on the raw text — claimed authority inside the text is treated as a string, not an instruction.

Per-thread control over which model and reasoning effort handles a task, mirroring a code-assistant's picker. Live in the interface; the provider-agnostic gateway behind it is still being built.

A self-hosted gateway plan (direct provider keys + fallback routing) so the model under Kern can change without changing Kern. Architecture decided and documented; currently Claude-based. The durable state (memory, skills, git, bridge contract) is already model-independent.

Sessions are keyed in Postgres, not on disk, so a deploy or restart never loses a conversation. On resume the runtime continues from a DB-reconstructed context rather than starting over.

First-class access to Gmail, Calendar, Drive, Sheets, Docs and Slides, plus GitHub, Railway, Vercel, Supabase, and accounting. It reads and writes the actual systems a business runs on, not a sandbox.

448 versioned, searchable playbooks (cold email, SEO, invoicing, deploy verification, content, design and more). The agent searches for the right skill before a non-trivial task instead of improvising from scratch.

Dozens of cron tasks fire into their own threads on a schedule: morning briefings, pipeline reports, inbox sweeps, follow-ups. This is the difference from a chatbot — Kern does work when no one has prompted it.

When a service has no API or MCP, a CLI can be generated for it from recorded browser actions, then handed back to the agent as a new capability. Adopted as a standard pattern; rolled out case by case.

Stall and hard-timeout watchdogs detect a wedged session and salvage its partial output instead of leaving it frozen. A liveness heartbeat reports elapsed time and tool stats and flags a stuck session.

Because the box is ephemeral, sessions resume from Postgres after any deploy, with storm guards (caps per boot, per thread, and an age limit) so a restart can never trigger a resume cascade.

A deploy is never assumed green. Tooling triggers the redeploy, waits for terminal status, and asserts the live URL actually serves traffic. A passive monitor posts every deploy result, even ones triggered outside Kern.

After a session once silently reverted six days of work by committing stale files, a guard now refuses any commit whose local content matches an older superseded version and names the commit it would have reverted. A real incident, a permanent fix.

Interactive and autonomous work run in separate lanes with their own limits, so a burst of background cron jobs can never starve a live conversation.

Bold with internal actions, careful with external ones. Emails are drafted for approval before sending, destructive ops are avoided by default, untrusted input is quarantined, and corrections are written to memory the moment they are stated.

A web dashboard with threaded chats, pinned tabs, quick-create, a session inspector, live "needs attention" status, and a persistent open-loops list. Built as the single home for the system after Discord was dropped.

Per-thread choice of model and reasoning effort, so a cheap fast model handles routine work and a stronger one is reserved for hard problems.

Long replies end with a coloured summary block and, when relevant, a red action list. The colour is driven by meaning (a clean TLDR or a pure action list), not by fragile inline styling.

A real-time, barge-in voice mode (self-hosted media server, streaming speech-to-text and text-to-speech, full memory and tool parity). Designed and previously running; currently down at the infrastructure level pending a service rebuild. Shown here honestly rather than hidden.

Kern forked whole into a client's business: their Supabase, their Railway, their Google Workspace. Eleven people running home energy surveys, ten mailboxes, one operations director who had become the human message bus between all of it. Live since 6 May and still running. 10,715 emails triaged, 728 of them drafted for a human to send. The number that matters is not in that list: four weeks in I rebuilt the interface off a week of his real session logs, and he now runs 40 standing automations, most of which he wrote himself.

A conversational sales agent that answers inbound enquiries on SMS, WhatsApp and the phone, then books the appointment. Median eight seconds from an inbound message to its reply, nine in ten under twelve. It has outgrown the client it was built for and now runs five separate workspaces, each with its own prompt contract, including an FCA-regulated one fenced so the agent cannot advise, quote a premium or ask for bank details. The public demo will refuse to give you a figure, and you can go and push on it yourself.

A brand compiler. It reads a brand's voice and visual rules once, then every image and every caption after that comes out inside those rules rather than being nudged into them by hand. 693 brand-locked images and 527 drafts for SUPA alone, 1,525 images across eight brands on the same compiler. A human still approves everything before it ships, which is the whole design.

Not the model, which is swappable, and not the prompts, which are the cheapest part. What transfers is the shape: durable memory joined to skills joined to evaluations in one database, consequential actions held for approval by default, and every action written as a row naming who it went to so "did that actually happen" has an answer. The scar tissue is the product. A clone takes days; earning the permission to act without asking takes months.

Kern runs on the Claude Agent SDK and has deliberately studied the open frameworks. Several patterns were borrowed from Hermes on purpose: memory context-fencing, declarative-fact memory rules, and "every turn ends in a tool call or a result." Knowing the landscape and choosing what to take is the point, not a weakness.

Not a feature a framework lacks. It is the compounding loop: a memory brain with self-evaluation and a failure ledger, a skills library that grows, and a scheduler that acts unprompted, all tuned to one operator over months and joined in a single Postgres so any layer can be queried against any other.

A general framework cannot assume who you are. Kern can. It knows the operator, the businesses, the history, and the preferences, so it skips the configuration tax and acts with context a multi-tenant system structurally cannot hold. The same stack still clones into a brain for someone else when that is the goal.