KERN Code

Coding help that proves it works before calling the job done, instead of just sounding confident. KERN Code pulls working code straight from KERN's library, reads your project's own rules first, and proves the result before calling the job done.

The modes

Coding help that proves it works before calling the job done:

• Plan: tells you exactly what it found and what it would do. No writes.
• Manual: hands you the matching code to paste in. No writes.
• Auto: writes the files and verifies the result. If something's wrong, it fixes and retries automatically. Confirms with you first.
• Audit: checks the open file against your project's own tools and flags known issues.
• Ask: a normal chat, grounded in KERN's library first.

Answers come from KERN's own library. If the library has nothing on your question yet, KERN Code fetches the real source for it and keeps going, instead of guessing. No AI involved: no model runs inside KC's own code.

How to use it

1. Install and connect

1. Install the extension, click the KERN Code icon in the activity bar.
2. Click Sign in with kernbot.com on the card that appears. This opens your real browser to log in with your existing kernbot.com account (including your two-factor code if your account has 2FA); it then sends you straight back to the editor. No API key to find or paste. Prefer an API key instead? Run KERN Code: Set API Key (get one from kernbot.com, Integrations, API keys).
3. Pick a mode from the toolbar and go.

2. Write an AGENTS.md first (strongly recommended)

KERN Code respects your project's own rules before writing anything. Drop them in AGENTS.md, .cursorrules, or a similar file at your repo root, and Auto will follow them: which paths are off-limits, which are the only ones it should touch, and what always needs to run to verify a change. No rules file yet? It uses a plain scan of your repo instead. You can also just ask KERN Code to write or grow the file for you.

3. Run a batch of tasks

Drop in a list and KERN Code works through the whole thing, one task at a time, checking each before moving on. By default nothing is committed; applied tasks land in your working tree with a report of what happened. Turn on kernCode.git.commitEachChange to give every successful write its own commit so any single change can be undone (kernCode.git.autoPush can also push them, and skips main/master unless you allow it).

• ▶ Tasks toolbar button, or KERN Code: Run Task Batch.
• Tasks come from .kern/tasks/*.md (one file per task), else a tasks.md / TODO.md at the repo root, else a pasted list.
• Each task can declare what "done" means for it, a command to run, an area of the repo it should stay within, and an order to run in relative to other tasks. In a task file the first line is the title, depends-on: other-task orders it after another task, role: QA (any label) says who should take it in a shared room, trello: <card link> names the task's Trello card, and an Acceptance heading can hold lines like - run: npm test, - files-changed-under: src/ and - forbid: console.log.
• KERN Code: Resume Saved Task Batch continues an interrupted batch.

4. Goals: give it an objective, not a task list

Type what you want done in plain language ("build a house in Blender," "make a greeting file in Node.js") instead of writing out the steps yourself. KC plans the steps from real documents in KERN's library, carries them out in your workspace, and verifies each one, the same way Auto and batch tasks do. It shows its progress as it goes (what's done, what it's learning, what it's waiting on) and does not stop or give up partway: if it hits something it needs and doesn't have yet, it fetches the real source for it and continues once that arrives, rather than leaving the goal unfinished.

5. The self-check gate

Before calling anything done, Auto (and any batch task) verifies the result against your project's own checks. Not "looks plausible," but actually passes. A failed check rolls the change back automatically.

6. Shared sessions (optional, paid)

KERN Code: Start Shared Session puts a room code on screen; teammates run Join Shared Session with it and see the same transcript, library answers and presence, each signed in with their own KERN account. A room stays open until the host ends it, and you can be in several rooms at once (a Main chat tab takes you back to your own conversation). A team space adds a lobby of every active room and an @here ping. Priced per seat (KERN Code Team, from your kernbot.com account); rooms of up to 5 are included with any paid tier.

7. Working as a team inside a room

• Room tasks lists every task with who holds it. Anyone can Claim a task or use Assign to... to hand it to any teammate; a task is held by one person at a time.
• Task map draws the tasks as a graph of what depends on what, coloured by holder.
• Agent activity shows who is idle or working, live.
• When a task batch starts in a room, the first task stays with the person who started it and the rest go automatically to idle teammates. A task with a role: line only goes to an idle teammate whose role label matches; if nobody matching is idle it stays open, it is never forced on the wrong person. Everyone sets their own role label (for example QA or Frontend) with + role next to their own name in the members panel.
• QA failures go back to the builder: if a member labelled QA runs a batch and a task fails, KERN Code moves that task's Trello card to your "failed" list (the list ID in kernCode.trelloQaListId, for example "Failed staging testing"), writes the failure note on the same card, and reassigns the task to whoever last finished it. It never creates a new card. To know which card is the task's, add a line trello: <card link> to the task file; otherwise it looks for exactly one card on the connected board with the same title, and if there is none or several it moves nothing and tells you. This uses the Trello connection described next.

8. Room connectors: Trello & Blender (inside a shared session)

Once you're in a shared session, the Connectors section (bottom of the room panel) can link the room to a real Trello board or a teammate's real, running Blender. No MCP and no external AI ever touches either. Both are set up by whoever is currently hosting the room; every other member then just uses them.

Trello

What it does: any member can browse the connected board's lists/cards, and create, comment on, or move cards, straight from KC. Every action shows up on Trello as the room host's own account (Trello has no concept of "acting as" someone else), but KC's own room activity log always records which member actually asked for it.

To connect it (host only), you need your own Trello personal token first. Trello doesn't hand these out without you registering a small app for one, but it's free and takes about a minute:

1. Go to trello.com/power-ups/admin and click New (create an app). Give it any name; it's never shown to anyone but you.
2. Pick "My integration doesn't use Power-Up capabilities" (or the equivalent option). You're only using this for the API key/token, not building a real Power-Up.
3. Open the API key tab. Copy the key shown there.
4. Click the Token link next to it, approve the real Trello authorization screen that appears (this is Trello confirming you are granting access, to your own app). It then shows you a long token string. Copy it.
5. Back in KC, open the Connectors section, click Connect next to Trello, and paste in: the board's ID (open the board on trello.com; the ID is the string of letters/numbers right after trello.com/b/ in the URL, not the readable board name at the end), an optional comma-separated list of list IDs to restrict which lists the room can touch, and the personal token from step 4.
6. Click Connect. KC checks the token against Trello for real before reporting "Connected"; a bad token or an unreachable Trello shows the real reason instead.

Blender

What it does: whichever room member has a real, running Blender with the KERN Bridge add-on installed can become the room's live "host" for it; any member can then read the scene or ask for an operation (create/move/rename an object, set a material/light/camera, render a bounded preview, save a checkpoint copy). Writes need the host's own explicit approval, shown on their screen. Nobody else's Blender is ever touched, and the currently-open .blend file is never overwritten (checkpoints always save to a new file).

To use it:

1. Run KERN Code: Download Blender Bridge Add-on from the command palette to save the real add-on zip (it ships bundled inside KC itself). In Blender: Preferences → Add-ons → Install, pick the saved zip, enable it, save your .blend file once. This is a one-time setup per machine, done by whoever will host. See blender-addon/README.md for the full detail.
2. In KC's shared room, the host clicks Configure under Blender in the Connectors section (scopes it to the current project).
3. Whichever member has Blender open with the add-on running clicks Become host. KC actually probes their local bridge before claiming the slot, so this never falsely claims to be live.
4. Any member can now click Run operation, pick one from the list, and go. Reads and the preview render happen immediately; writes show an approval prompt on the host's own machine first.

A live host has to stay open and reachable. If their Blender closes or their machine goes offline, the room shows "Unavailable" within about 45 seconds, and anyone else with the add-on running can become the new host.

9. Follow-ups and talking to KC

After KC answers a library question you can ask a short follow-up in the same box: "and on Windows?" shows the Windows command, "why?" or "are you sure?" shows how sure KC is and why, "which sources?" lists the sources with links. KC answers from what it just told you, with no new search and no AI. It also answers a remark that is not a question (a greeting, thanks, "I am tired", "nice weather for coding") like a person would, with a little dry humor when the mood allows it and none when you sound stressed. Type "no jokes" for straight answers. This is rules, not a model, and a real question or code is never treated as small talk. KC replies in the language you write.

How it connects

KERN Code talks only to KERN's own backend, authenticated with your kernbot.com sign-in (or a personal API key if you chose the manual fallback).

• This is not an AI bot. KC is rule-based: it plans and acts from real documents and your project's own files, never from a model's guess.
• No external AI client connects to KERN. Claude Code, Cursor's agent, Claude Desktop and the like never talk to KERN directly. Your data does not go to Anthropic, OpenAI, or anyone else.
• Ask streams from KERN's own chat endpoint, so answers appear word by word.
• Everything runs where your code lives. Your linters, your test runner, your workspace. Nothing is uploaded or executed remotely.

What it won't do

Plan, Manual, Auto, and Audit are disciplined and predictable, not creative. They do not decide what to build or change approach on their own. That kind of open-ended judgment call goes to Ask instead, or stays a limitation.

Works in Cursor too

Built and tested in both VS Code and Cursor. It should work in any editor built on the standard VS Code extension API with a desktop-class host, such as Windsurf, VSCodium, or Trae, since Auto/Audit/QA run your actual local git, linters, and test commands, which needs that kind of host. It won't run in a browser-only VS Code (vscode.dev, github.dev) for the same reason.

Where KC lives

In VS Code the main panel opens in the Secondary Sidebar (next to Copilot Chat and any other AI tool's panel, use View: Show KERN Code if it isn't open). In Cursor it lives in the activity bar instead, because Cursor does not support the secondary sidebar for extensions. It also registers as @kern in VS Code's own built-in Chat view, with /plan, /manual, /auto, and /audit as slash commands.

It also runs on your phone:

1. Open kernbot.com/kc-remote in your phone's browser and sign in with your kernbot.com account.
2. Add it to your home screen using your browser's own "Add to Home Screen" (Safari) or "Install app" (Chrome) option, usually under the share or menu button. No app store.
3. Open it from your home screen like any other app - it joins your rooms and lets you follow and send messages from your phone while KC works.

Pricing

KC is not a separate product with its own signup, it runs on your existing kernbot.com account. Every paid KERN plan already includes a KC credit tier at no extra cost, scaled to the plan: Lite gets a small taste (20 credits per 5 hours, 150 per week), Core the Pro budget, Core+ and Team the Max 5x budget, Professional and Enterprise the Max 20x budget. A free-tier KERN account has no KC access. A higher paid tier replaces (never adds to) your plan's baseline.

The table below is what each tier's rolling 5-hour and weekly credit budget looks like (a rolling usage window, not a flat per-request cap). It's shown here so you know what you're getting at each level, not as a separate thing to buy on its own:

You can check or upgrade your current tier anytime from your kernbot.com account, under Settings then Usage. Higher tiers also make Auto try harder before giving up, with more alternate library matches and more fix attempts each. KERN Code Team (shared sessions) is a separate per-seat add-on on top of any tier: 79, 59, or 49 SEK per seat/mo at 3 to 24, 25 to 99, or 100+ seats.

Commands

You don't need any of these to get started. Opening the panel shows a one-click "Sign in with kernbot.com" card the first time. They're here for less common cases.

• KERN Code: Fix Selected Code: sends the selection to Ask as a "why doesn't this work" question
• KERN Code: Audit Current File / Audit Entire Workspace (also the 🔍 toolbar button) and Apply Known Audit Fixes (after an audit has run)
• KERN Code: Status Report (also in the ... menu, and by just asking, for example "do we need more runners?"): reads your GitHub PRs, checks, deploys and job timings and answers with reasons: what is live, deploying (with a time estimate from earlier runs), waiting on CI, needs you, failed. Rule-based, no AI, every line links to its data; a verification command is shown only if your project docs document one
• KERN Code: Run QA Pass (project-wide): failures are saved as tasks in .kern/tasks
• KERN Code: Manage SSH Hosts: register a server for library recipe steps that run over SSH; a step without a rollback command never runs in Auto mode
• KERN Code: Git ... and GitHub ...: status, branches, diff, pull requests and issues, with the same confirmation as any other risky action
• KERN Code: Download Blender Bridge Add-on
• KERN Code: Run Task Batch (also the ▶ Tasks toolbar button)
• KERN Code: Start / Join / Leave Shared Session
• KERN Code: Sign Out
• KERN Code: Set API Key: for manual setup only (scripting, or a restricted network that blocks the browser redirect). Everyday sign-in doesn't need this.

• Questions or issues: support@kernbot.com
• Also on Open VSX and the VS Code Marketplace
• Website: https://kernbot.com
• Discord: https://discord.gg/qmT6mDxwZ
• Facebook: https://www.facebook.com/aikernbot/
• Facebook group: https://www.facebook.com/groups/kerncode/