CodeGenie

KaarTech's AI agent platform, powered by KTern.AI Intelligence

Chat and agents · Spec-driven development · Chat artifacts and mockups · Parallel sessions in git worktrees · A team marketplace of skills, modes, MCP servers, workflows and rules · Claude models on Amazon Bedrock · Spend you can see

---

CodeGenie is an AI agent platform that lives in VS Code. Engineers use it to build, fix, test and review code. It isn't only for developers, though. The same agent reads documents, drafts specifications, works with SAP systems through MCP servers, drives a browser, files tickets, and follows your team's rules. So functional consultants, testers, architects, analysts and project leads use it as well.

Everything runs on Claude models through your company's Amazon Bedrock account. It is scoped to a KTern project and buildspace, and every chat counts toward a spend you can see.

 

Table of contents

• What you can do with it
• Quick start
• The chat
• Models, tiers and effort
• Spend, budget and your account
• Agents and modes
• Spec-driven development
• Chat artifacts
• Web search and web pages
• Creating your own artifacts
• KTern Workflow Studio compatibility
• Agent Behaviour: MCP servers, skills, workflows and rules
• Marketplace
• Agent Manager: parallel sessions and worktrees
• Autocomplete
• Chats, export and history
• Approvals, checkpoints and diffs
• Browser, screenshots, design, terminal and Git
• Settings
• Commands and keyboard shortcuts
• Enterprise and security

---

What you can do with it

Who	For example
Developers	build features, fix bugs, refactor, write tests, review a diff, explain an unfamiliar codebase
SAP and ABAP teams	read and change ABAP objects through the ABAP ADT MCP server, map transports, check naming rules, build Fiori and CAP apps with multi-agent units
Functional consultants and analysts	draft functional specifications from requirements, turn meeting notes into a structured document, compare two versions of a spec
Testers	write and run test cases, drive a web app in a real browser, capture screenshots for a defect
Architects	explore a system, plan a design with the Plan agent, agree requirements and a design with the Spec agent and have it build them task by task, review a proposal with a sceptical second agent
Designers and front-end developers	mock up a screen as SVG or HTML, see it beside the chat, and let the agent screenshot and correct its own layout
Project leads	run the same task in several worktrees and compare the results, file and update tickets through MCP servers, share the team's best prompts as workflows

Skills, modes, MCP servers, workflows and rules are how a team teaches CodeGenie its own way of working. Create them in Settings or by asking in chat, publish the ones worth sharing to the project's marketplace, and everyone in the project can install them.

---

Quick start

1. Install CodeGenie from the Extensions view (Ctrl+Shift+X / Cmd+Shift+X).
2. Open the CodeGenie icon in the Activity Bar and sign in. You can continue with Microsoft, or use the email and password of your KTern account.
3. Choose a project, then a buildspace, or create your first buildspace in place. Buildspace names are unique within a project; a name that's taken is pointed out on the form.
4. Describe what you want. The composer stays at the bottom; type / for commands and @ to add files.
5. Watch the agent work, approve what it asks to do, and review the result.

Press Ctrl+Shift+M / Cmd+Shift+M to open the Agent Manager and run several sessions side by side.

---

The chat

• New chat screen. The KaarTech logo, a greeting with your first name, "What should we build in {buildspace}?", and starter prompts. The composer stays docked at the bottom.
• Composer.
  • On the left are + and the model pill.
  • On the right are Enhance prompt, the mode (Code, Ask, Debug, Plan, Orchestrator, Spec or your own) and Send.
  • The placeholder tells you why sending is paused when the budget stops it.
• "+" menu. Type to filter; use ↑ ↓ and Enter.
  • Attach a file or folder.
  • Add terminal output.
  • Open Context and cost.
  • Compact the conversation.
  • Switch model and effort.
  • Turn Auto-approve on or off.
  • Toggle MCP servers.
  • Insert a skill.
  • Open Rules or the marketplace.
  • Open Artifacts and changed files.
  • See how much of the budget is used (the ring next to the filter, or Budget); see Spend, budget and your account.
• Chat header. The title (F2 renames it), model health, the Artifacts button with a count, a context ring and a "⋯" menu with Rename, Fork chat and Export chat….
• Context and cost. Clicking the ring shows:
  • tokens used against the window;
  • the model of the last request;
  • a breakdown of the system prompt, tools by source, history and tool results;
  • the cache split;
  • session spend including sub-agents;
  • an activity strip, where each bar shows what ran, when, and for how long;
  • Compact now.
• Compacting from the Command Palette. CodeGenie: Compact Session compacts the chat open in the active CodeGenie tab or the sidebar, the same as /compact: it does nothing while the chat is replying, has no messages or has no model selected, and it pauses at the budget. Other extensions can run it with vscode.commands.executeCommand("codegenie.compactSession").
• Long chats. Older tool output is pruned once a chat passes 60K tokens or 35% of the window (after three of your messages; the newest ~40K is kept). Compaction summarises the rest, keeping your request, decisions, the to-do list and the next step.
• Every reply starts with a route note, for example Auto → Smart · Sonnet 5.5 · High. It ends with a turn summary showing the mode, tier, model, effort, cost and time. Click the summary for turn insights: a token bar with cache read, cache write, uncached input and output. Auto's route note expands to show the tier, the reason and the classifier's cost. A turn that ran on a stand-in model is tagged fallback; hover it to see which model was unavailable and when it's tried again.
• To-dos. On longer tasks the agent keeps a to-do list. The chat header shows how many are done, and the list ticks items off as the work goes. When the direction changes, earlier items are set aside with the reason instead of disappearing.
  • On a request with several steps and no list yet, the agent's first change shows as Not run until it writes the list; it then repeats the change. This happens at most once per request, and not while a list from your earlier request is still open or when the list was sent in the same step as the change.
  • When the agent ends its work with items still open, it's reminded once to tick them off, or to say which item stays open and why.
• The goal stays in view. After a long chat is compacted, the agent sees your original request and the to-do list again. An agent that changed code without running anything is reminded once to check it before it finishes.
• Links and images. A path in backticks, a plain path, a file link and an image all open on click, at the line and column (:42, :42:5, #L42, #L42C5, #L10-L20; file:// and Windows paths work too).
  • A missing file says "File not found" instead of being created; a folder opens in the Explorer; a path given relative to another file still finds the file.
  • An image opens a preview with Open in Editor; an image outside the workspace shows as a link.
  • A Word, Excel or PowerPoint file (.docx, .xlsx, .pptx and the others) opens in the app your computer uses for it, such as Word or LibreOffice; VS Code has no viewer for them. PDFs open in VS Code.
  • Only web and mail links leave VS Code.
  • Ask for screenshots and the agent shows them in the chat.
• Documents. Ask about a Word, Excel or PowerPoint file (.docx, .xlsx, .pptx and their macro and template variants) and the agent reads it as text in any mode, with nothing installed: headings, lists and tables; cells by coordinate with their formulas; slides with tables and speaker notes. Files you attach are read the same way. PDFs and images are sent to the model as they are. Old .doc, .xls and .ppt files need converting first. To create or change documents, the built-in docx, pptx, xlsx and pdf skills load on demand (see Tools).
• Images. Images you paste or attach, and the ones the agent reads or screenshots, are scaled to fit 2000×2000 and Bedrock's size limit before they go into the chat, so a chat with many screenshots keeps working. One that can't be fitted is replaced by a short note. If a chat still hits the provider's image limit, it compacts once and continues.
• Messages sent mid-turn are queued with your exact words.
• Terminal blocks start collapsed; click one to see the command and its output. Settings › Display › Terminal Command Blocks keeps them expanded.

 

---

Models, tiers and effort

CodeGenie runs Claude models on Amazon Bedrock. Pick a tier and let CodeGenie choose the model, or pick a model by name.

Tier	Runs on	Use it for
Auto (recommended)	Fast, Smart or Expert, chosen per message	everyday work; it stays put when a switch would waste the prompt cache
Fast	Claude Haiku 5.5, with thinking off for focused work and at medium for broad work (Haiku 4.5, then Sonnet 5.5 with thinking off, stand in if it is unreachable)	quick edits and lookups
Smart	Claude Sonnet 5.5 (falls back to Sonnet 5, then Sonnet 4.6)	most engineering and writing work
Expert	Claude Opus 5.5, or Sonnet 5.5 at xHigh	hard problems, design, unresolved debugging

• How Auto chooses. Smart is the default. Expert is kept for research, unresolved debugging, security, architecture, or when you ask for it; "be thorough" alone doesn't escalate, a repeated failure does. Small talk ("thanks") gets an answer without a thinking pass. Some agents set a floor: Plan, Orchestrator, Debug and Spec run at least Smart. Sub-agents, Explore included, run on the tier of the chat that started them. Long chats stay on their model so the prompt cache isn't wasted: past 100K tokens, Auto doesn't step down a tier unless the last turn failed. Messages are classified by Haiku 5.5, or by Haiku 4.5 when Haiku 5.5 doesn't answer; with neither, Auto runs Smart.
• Named models. Under Specific models you can run exactly Haiku 5.5 or Haiku 4.5 (listed under Fast), Sonnet 5.5, Sonnet 5 or Sonnet 4.6 (under Smart), or Opus 5.5 or Sonnet 5.5 at xHigh (under Expert), with no routing. Each starts at its own effort: Haiku 5.5 at Medium, Anthropic's default for it, and Haiku 4.5 at Off.
• Effort. Set it with the dots in the model picker and the "+" menu, from Off to Max where the model offers it. A level is never carried as-is to another model; it moves to the nearest level that model offers. When a turn spends its whole output budget thinking, it's retried once at the next lower effort, and both attempts stay visible.
• Fallback. When a model is unavailable, throttled or Bedrock can't serve it, tiers move to the next model in the same turn. The chat header, the model picker and the fallback tag say what happened and when the usual model is tried again; Try again now retries it early.
  • A model is marked from what Bedrock answers, never from how long it takes:
    • Unavailable (30 minutes) when Bedrock says the account can't use it: no access, an invalid model or profile, IAM not allowing it, a retired model, or no on-demand throughput. Tiers skip it.
    • Busy when Bedrock keeps refusing a call. That's either throttling ("Too many requests", your account's quota) or Bedrock being unable to serve the model ("Bedrock is unable to process your request", "Service temporarily unavailable", overloaded, model not ready).
      • On Fast, Smart and Auto, a call still refused after 2 retries marks the model busy for 5 minutes, and the turn moves to the tier's next model.
      • On Expert, throttling keeps retrying on Opus 5.5 by default, because moving would rewrite the prompt cache; router.throttle.tiers in codegenie.json changes that. When Bedrock can't serve Opus 5.5, Expert waits about two minutes (6 retries), then finishes the turn on Sonnet 5.5 and tries Opus 5.5 again for messages sent 2 minutes later.
    • Slow (10 minutes) whenever a call is retried, including for a timeout or a lost connection. It's shown only; routing doesn't change.
  • A reply that is slow to start but doesn't fail sets no mark, so a model with a long queue stays in use.
  • Unavailable and busy marks survive a restart and are shared between VS Code windows (throttling is per account, so every window hits it); slow marks aren't.
  • A model the chat has outgrown is skipped: past 75% of a model's window it isn't used as a stand-in, so a long Fast chat moves to Sonnet 5.5 (1M) instead of Haiku 4.5 (200K).
  • A turn that already streamed text, thinking or a tool call isn't re-run on another model; the fallback starts with your next message.
  • A model picked by name never falls back.
• Check access. It is under Settings › About and tests every model in one click.

---

Spend, budget and your account

• The account menu. The avatar opens your name and email, a card with Your spend and the budget, Switch project, Switch buildspace, Settings, Feedback & support, and Sign out. The workspace chip next to it switches the buildspace.
• Your spend is your own spend in the selected project, as KTern records it. It includes chat and autocomplete.
• No usage report is lost. Each report waits in VS Code's storage until KTern confirms it, across restarts and sign-outs, and a report KTern hasn't confirmed pauses sending until it is. Stopped and failed turns are billed for the steps they completed. A sub-agent is billed once: its own messages add 30% on top of the cost its parent's task already carries.
• How much of the budget is used. A project has either one budget for everyone or a budget per user. A ring shows the share used of whichever applies: green under 50%, yellow from 50% to 80%, red past 80%.
  • In the account menu, under Your spend: "Project budget · 96% used" (or "Your budget"), what's left, the project's total spend under a project budget, and when the figures were updated.
  • In the "+" menu, the share used sits next to the filter; it and the Budget row open the Budget view with Project used, You used, the budget, the project's total under a per-user budget, and Check again.
  • The figures are refreshed at sign-in, after each turn and on Check again.
• Low-credit warnings. With 20% of the budget or less left, VS Code shows a warning each time CodeGenie starts. With 5% or less left, every message shows a warning (the message still goes); snooze it for 30 minutes, 1 hour, 12 hours or 1 day, from the warning or the Budget view. The snooze applies in every window and workspace.
• Budget reached. When the budget is reached, a card above the composer says so and offers Check again. When KTern can't be reached, it says that instead and offers Retry.
  • Compact now and /compact pause at the budget too, because compaction is a model call.
  • When your spend isn't known yet (for example right after signing in), the card says "Token limit exceeded in ‹project›" without an amount.
  • A restored chat shows the project's name, including chats saved before 2.1.0.
• Switching is safe. Switch project and Switch buildspace only list choices until you pick a buildspace. Back, Cancel, Escape and ✕ leave you where you were.

 

 

---

Agents and modes

Agent	What it does
Code	the default; reads, edits and runs commands with your approval
Ask	answers and explains without changing files
Debug	diagnoses and fixes problems step by step
Plan	researches and writes a step-by-step plan (goal, findings, steps, risks, verification); it may only edit plan files and can send research to Explore
Orchestrator	splits a large task across sub-agents running in parallel, picked by what they can do, and ends with a verification step
Spec	agrees requirements, a design and a task list with you, then builds them task by task (Spec-driven development)
Explore, General	sub-agents for searching a codebase (read-only) and for multi-step work
spec-task, spec-verify	Spec's sub-agents: one implements a single task with its tests, the other checks it against the acceptance criteria and never edits

• Debug reproduces the problem, proves the cause, makes the smallest fix, removes the logging it added and proves the fix. It asks first only when a fix is risky.
• Ask never changes files. When you want something built, it says which agent to switch to.
• Explore runs only read-only commands, so a mode or unit that delegates pipes or find to it gets them refused; it still searches, globs and reads.
• Agents know their limits. An agent without the shell, edits or delegation is told so up front, and a call to a tool it lacks gets a clear answer saying where to delegate. The sub-agent list tags each one [shell, edit], [edit] or [read-only], and a multi-agent master sees only its own sub-agents.
• New problems after an edit. After the agent edits a file, any new errors or warnings VS Code shows for it in the Problems panel (ESLint, Pylance, the TypeScript server, the ABAP extensions and others) are added to the result, so the agent fixes them before it finishes. Problems that were already there are left out. It adds up to about 2 seconds per edit; turn it off under Settings › Agent Behaviour › Problems after edits.
• Background processes. The agent can start a dev server or watcher in the background, wait until it prints that it's ready, test against it, read its new output and stop it, all without blocking the chat. Starting one asks the same approval as running the command. At most five per chat; one nobody has read for 30 minutes is stopped.
• Remembering past chats. Ask about earlier work ("what did we decide about the budget card?") and the agent can search what was said in this project's past chats, its worktrees and sub-agents included, by keywords, and read just the part that matched. It asks your permission first. The search runs on your machine; nothing leaves it.
• Knowing its own session and sub-agents. Every message tells the agent its session ID and the sub-agent sessions it has started, each with where it stands: answered, running, no answer, or stopped with the error. A sub-agent that was throttled or stopped without an answer is continued from where it stopped, by its task_id, instead of being started again. Ask "which sub-agents did you start?" and it lists them with recall's session view.
• Several edits at once. When one file needs several changes, the agent sends them in one step: one approval, one diff, and nothing written if any change doesn't match.
• Safer edits. An edit is matched exactly first, then by forgiving whitespace, indentation and escapes. A loose match that would also overwrite a line the agent never wrote is refused, with the stray lines named, and your file is left as it was. When an edit doesn't match at all, the result shows the closest lines in the file to copy from, and a failed multi-edit says which edit failed and that nothing was written — so the agent corrects itself in one retry instead of guessing.
• Fewer wasted turns. A tool call whose arguments are right but shaped differently (a list sent as text, old_string for oldString) is repaired and runs. A path that doesn't exist gets up to five real paths with the same name.
• One shared base. Every agent, including the ones you create, works from CodeGenie's base instructions (read before editing, run the checks, report what was verified). Your mode's prompt is added on top as its role, so it narrows the standard workflow instead of replacing it.
• Custom modes set their own prompt, permissions, tier (auto, fast, smart, expert), model (haiku45, haiku55, sonnet46, sonnet5, sonnet55, opus55) and effort (off to max). Selecting the mode moves the model picker to them. A sub-agent without its own setting runs on what the delegating turn ran on; the forms also offer "Same as parent" and "Auto (classify this task)".
• Multi-agent units bundle a master agent with its sub-agents and are edited as one.
• Ways to create one: see Creating your own artifacts.

---

Spec-driven development

Use Spec when a feature spans several components or many files, or when the requirements need agreeing before anyone writes code. For a change to one or two files, Spec suggests Code instead.

How a spec is made

1. Pick Spec in the mode picker and describe the feature. Spec reads the code, sends broad searches to Explore, and asks you anything only you can decide.
2. Requirements. It writes requirements.md: user stories, each with numbered acceptance criteria such as 1.1 WHEN the user presses Export THE SYSTEM SHALL save a Markdown file, plus what's out of scope and any open questions. It asks you to approve it or say what to change.
3. Design. After you approve, it writes design.md: the current code as path:line, the architecture (with a diagram when it helps), the files and interfaces to change, data, error handling, which tests prove which criteria, and the risks. You approve it the same way.
4. Tasks. Then tasks.md: small coding tasks with sub-tasks, the criteria each covers, and what each depends on. Spec checks that every criterion is covered before asking you.
5. Build. Choose to run all tasks, one task, or stop. You can edit any of the files yourself between steps; Spec re-reads them.

Spec only skips the approvals if you tell it to.

How tasks run

• Tasks run in dependency order. Tasks that touch different files run in parallel.
• Each task goes to spec-task, which changes the code, writes the tests and runs them for that one task.
• Each batch is checked by spec-verify, which runs the tests and reports, per acceptance criterion, met, not met or can't verify, then PASS or FAIL.
• A task is ticked only after it passes. After two failed fixes on the same task, Spec stops and tells you what fails.
• If the design turns out wrong, Spec stops, updates the design and the tasks, and asks you again.
• tasks.md shows progress as [ ] pending, [-] in progress and [x] done.

Where specs live

.codegenie/specs/<name>/
  requirements.md
  design.md
  tasks.md

Specs are plain Markdown in your repository, so they can be reviewed and committed like code. Ask Spec to continue a spec in a new chat and it picks up at the first unapproved file or unfinished task.

Spec edits only its spec files, even if your configuration allows edits everywhere, runs only read-only commands itself, and delegates only to Explore, spec-task and spec-verify. A spec run costs more turns than a plan: each task is a sub-agent run and a check, and Spec runs at least the Smart tier.

The spec panel

Run CodeGenie: Open Spec from the Command Palette, or press the checklist button in the title bar of an open spec file. The panel shows the spec's files as tabs and the tasks with their status (○ pending, ◐ in progress, ● done), and refreshes as Spec writes. Approve, Run and Run all send the matching message to Spec in the sidebar chat, so you can still read and answer everything there. Start the spec's chat first, or the message opens a new Spec chat that picks the spec up from its files.

• Approve <file> says you approve the file in the tab, and Spec goes on to the next one.
• Run on a task asks Spec to run just that task; Run all runs every pending task, in dependency order, in parallel where the tasks allow.
• A running task shows Stop, which stops the chat running it (and any other task that chat is running), like the chat's own stop button.
• A task whose chat stops (from the panel or the chat), fails or finishes without completing it goes back to not started, with Run. Running another chat doesn't change it.
• Done tasks have no Run button. Apart from that reset, the panel never edits the files itself; Spec and spec_status do.

---

Chat artifacts

When the agent produces something meant to be reviewed on its own (a document, a diagram, a UI mockup, a screenshot), it saves it as a chat artifact instead of pasting it into the reply.

Kind	Shown as
Markdown	a preview card; opens rendered
Mermaid	a diagram card; opens full size
SVG	an image card; opens beside the chat
HTML	a mockup card; opens beside the chat with scripts off, with Open in Editor in the title bar
Code, images, PDF	a card that opens the file

• Where. Each chat has its own folder, .codegenie/artifacts/<session id>/ in the project, or ~/.codegenie/artifacts/<session id>/ when the folder isn't a git project. The folder ignores itself, so artifacts never show up as changes. Saving again with the same title replaces the artifact.
• The Artifacts list. The button next to the context circle (or Artifacts and changed files in the "+" menu) lists the chat's artifacts, its plans and every file it changed, with All, Artifacts, Files and Plans filters. Folders collapse, files outside the workspace are marked, and work done by sub-agents is grouped under each one.
• Read-only agents can save them too. Ask, Plan, Orchestrator and Spec can save artifacts, because the tool can only write inside the chat's own artifacts folder.
• What commands and MCP tools produce. After each request, a short Haiku pass outside the conversation names what commands and MCP tools created or changed: an ABAP class, a transport, a database table, a file a script wrote. They're listed under the Tools tab, each labelled with the tool that produced it. Reads, failed calls and tools the server marks read-only give nothing, and a chat that only used file tools makes no Haiku call. Each Haiku call counts toward your spend.
• Counted once. Each file, plan, artifact or object counts once per chat, and once per agent that worked on it, however often it's rewritten. Each row, and the list's header, shows a cloud: a tick once the count reached KTern's telemetry, an x while it hasn't, a spinner while it's being sent.
• Export and import. Exported chats list what they produced, and an imported chat shows that list marked "imported".

 

---

Web search and web pages

• Search. Agents search the web instead of guessing a URL, and say which pages they used. Pages are fetched directly from each site.
  • Web search is set up by KTern when you sign in, restore a session or switch project, so it can change without a new extension version. When search isn't available, the agent says so instead of guessing.
• Pages. Fetched pages come back as the main content, without menus and footers, and PDFs are read as text.
  • An old URL that 404s as Markdown is retried as HTML. A real 404 lists the site's closest pages and an archived copy, and the agent is told not to guess another URL.
  • Three modes: full (the default), selective (only the sections with a phrase) and truncated (the first 8,000 characters). A page fetched again within 15 minutes comes from a cache.
  • JavaScript-only pages come back nearly empty with a note; the agent can use the browser or a screenshot instead.
  • When several pages were asked for, the agent says which it got and which it couldn't, and never calls the result complete while one is missing.

---

Creating your own artifacts

Modes, multi-agent units, skills, workflows, rules and MCP servers are all artifacts: plain files in your project that teach CodeGenie how your team works.

Artifact	What it is	Lives in
Mode	an agent with its own prompt, permissions and model	.codegenie/agents/<id>.md
Multi-agent unit	a master agent and its sub-agents, edited and shared as one	.codegenie/agents/<unit>.md and <unit>-<sub>.md
Skill	instructions the agent loads when a task matches, with optional references and scripts	.codegenie/skills/<id>/SKILL.md, references/, scripts/
Workflow	a saved prompt you run as /id, with $ARGUMENTS for input	.codegenie/commands/<id>.md
Rule	instructions every chat follows	.codegenie/rules/<id>.md
MCP server	tools from a local command or a remote URL	codegenie.json › mcp

There are three ways to make one:

1. In Settings. Settings › Agent Behaviour has a Create button on each sub-tab. Skills can also be uploaded as a single file or a whole folder.
2. In chat. Ask for it, for example "create a skill for our ABAP naming rules" or "make a review team with a fixer and a read-only auditor". The built-in create-artifacts skill asks for the fields it needs and writes the files.
3. By hand. Write the file in .codegenie/. The lists in Settings refresh on their own.

The create and edit forms for modes, multi-agent units and MCP servers share one layout: a framed panel with a header, fields separated by rules, a multi-agent unit's sub-agents each in their own box, and Cancel and Create at the bottom.

Each artifact is saved for this project or for all projects (~/.config/codegenie/). Either way it stays on your machine until you publish it (Sharing with your team).

---

KTern Workflow Studio compatibility

KTern Workflow Studio is a companion extension (KTernAI.ktern-workflow-studio, installed alongside CodeGenie) that gives you a visual canvas for designing workflows. CodeGenie provides the foundation that lets a studio flow live beside your other workflows and run as a slash command:

• Each workflow command gets its own folder. A command is stored at .codegenie/commands/<name>/<name>.md, so it can carry a sibling <name>.json definition describing a studio flow. Existing flat .codegenie/commands/<name>.md commands keep working and move into the folder layout the first time you run them.
• Two workflow types. When you create a workflow you choose Standard (a plain prompt command) or Agentic (a studio flow). The type is stored as a workflow: line in the command's frontmatter; anything other than agentic is treated as Standard. Both types appear in the command palette and run the same way.
• Edit opens the right editor. In Settings › Agent Behaviour › Workflows, the Edit button opens a Standard workflow's Markdown in an editor, and an Agentic workflow in the Studio when a valid <name>.json definition is present — otherwise it falls back to editing the Markdown.
• Marketplace carries both. Published workflows are distributed as a folder with the <name>.md body and an optional <name>.json definition, so a teammate installing an Agentic workflow gets its studio flow too.

The visual canvas, the Prompt/Skill/MCP Tool and control-flow nodes, Edit with AI, and the Open Editor command all live in the Studio extension. A flow you build there is exported into the folder above and executed by CodeGenie like any other workflow.

---

Agent Behaviour: MCP servers, skills, workflows and rules

Settings › Agent Behaviour is where you shape what the agent can do. Each sub-tab shows how many items it holds.

Sub-tab	What you manage
Agents	the default agent, built-in and custom modes, multi-agent units; import, create, publish; Problems after edits; Claude Code compatibility
MCP Servers	add, edit, test, switch on or off, sign in, publish, remove
VS Code Tools	tools other extensions offer through VS Code's language model API, off until you turn them on
Rules	Markdown instructions every chat follows (.codegenie/rules/, or for all projects ~/.config/codegenie/rules/; ~/.codegenie/rules/ is read too, and on a name clash the first wins). ✎ edits the Markdown inline; project and global rules with the same name are edited separately; Remove deletes every global copy
Workflows	saved prompts you run as /name (.codegenie/commands/); ✎ edits the description and template inline
Skills	instructions and scripts the agent loads when a task needs them; built-in ones (codegenie-config, create-artifacts, design, docx, pptx, xlsx, pdf) are marked built-in, and one you install with the same name replaces it

Custom MCP servers

Add server connects a local command (stdio) or a remote URL (streamable HTTP or SSE). The form has:

• a name, an ID and a description;
• the command and its arguments, or the URL;
• environment variables or headers;
• parameters: write {{NAME}} in any field and CodeGenie asks for the value;
• prerequisites;
• Save to: this project or all projects.

Test connection starts the server once and reports "Connected · n tools", the error, or "Reachable; it needs you to sign in after saving", without saving anything. Its tools are never offered to a running chat. Remote servers are tried over streamable HTTP, then SSE.

MCP tools load either up front or on demand (deferred servers are listed by name and loaded when the agent needs them), which keeps requests small when many servers are connected.

In a narrow panel the tabs wrap onto a second line and each section's buttons sit below its description.

Publish to the marketplace, from the form or from the ☁ button on any server, shares it with everyone in the project:

• Values stay private by default. Environment and header values become parameters that each teammate fills in, unless you tick Share this value. Tokens are never uploaded.
• Same install flow. The server installs through the same dialog as the standard ones.

---

Marketplace

The marketplace has the standard KTern.AI catalogue plus whatever your project's team published. Open it from Settings › Agent Behaviour › Browse marketplace, or from the "+" menu.

Tab	What it holds	Installs to
MCP	80+ servers: ABAP ADT, Playwright, GitHub, Atlassian, Azure DevOps, ClickUp, Apify, Context7 and more, plus your team's	codegenie.json › mcp
Modes	ready-made agents and multi-agent units	.codegenie/agents/
Skills	50+ skills for documents, SAP, testing, front-end, data and more	.codegenie/skills/
Workflows	reusable prompts	.codegenie/commands/
Rules	your team's rules	.codegenie/rules/
Plugins	bundles of modes and skills	each item's folder
Tools	programs the agent runs on your computer: Document tools and LibreOffice	CodeGenie's storage, for this computer (Tools)

Installing an item

1. Open the marketplace and pick a tab.
2. Search, filter by source and status, or pick a category (a side list on wide panes, chips in the sidebar). Items your team published are marked Custom and listed first. To see only them, set the source filter to Your team, pick Custom (your team), or search for "team", "ours" or "my team".
   • The Source filter (All sources, KTern.AI (n), Your team (n)) is on the MCP, Modes, Skills and Workflows tabs, and each tab remembers its choice.
   • An empty "Your team" says whether nobody has published yet or the items couldn't be loaded, with Retry.
3. Press Install and choose this project or all projects.
4. For an MCP server, the dialog shows its prerequisites and asks for any parameters, such as a token or a system URL.
5. The item is ready in your next message. Installed items say so on their row and offer Remove. Removing an item from your machine never unpublishes it, so you can install it again later.

Sharing your own with the team

Publishing is opt-in. Nothing you create or edit leaves your machine until you choose to share it.

1. Create the artifact (see Creating your own artifacts) and try it in a chat.
2. In Settings › Agent Behaviour, find it on its sub-tab and press ☁ Publish on its row.
3. Confirm. It appears for everyone in the project under the matching marketplace tab, marked Custom.

What to know:

• What's shared. A skill is shared with its references and scripts, and a multi-agent unit as one bundle. An MCP server's environment and header values become parameters each teammate fills in, unless you tick Share this value.
• Updating. Edits stay on your machine until you publish again, which replaces the shared copy.
• Renaming. Rename on a Custom item in the marketplace gives it a new ID for everyone in the project. Copies already installed, and your own file, keep the old name.
• Workflows kept in codegenie.json. A workflow defined only in the config shows Move to file instead of ☁. That turns it into .codegenie/commands/<id>.md, which can then be published on its own.
• Publish all. The Skills, Workflows and Rules sub-tabs can publish every item in the list at once, from this project and from your global folders (a name in both is published once, from the project). On Skills it asks first. Items installed from the KTern.AI catalogue, or for skills from a plugin, are left out, and the result says how many.

Tools

Some skills need programs your computer may not have. The Tools tab offers them as one-time downloads, for Windows, macOS (13 or later) and Linux (glibc 2.28 or later):

Tool	What's in it	Size
Document tools	Python 3.12 with openpyxl, xlsxwriter, pandas, python-docx, python-pptx, pypdf, pdfplumber, pypdfium2, reportlab, Pillow, lxml and matplotlib; pandoc; PDF page rendering (pdftoppm, pdfinfo); the docx and pptxgenjs Node libraries	about 125–195 MB
LibreOffice	converting documents (to PDF, between formats), recalculating Excel formulas, rendering pages to check how they look	about 350 MB or more

How it works:

• Nothing downloads on its own. Installing CodeGenie doesn't download any tool. You install one from the Tools tab, or say yes when CodeGenie offers Document tools the first time a Word, PowerPoint, Excel or PDF skill needs them (Install, Not now or Don't ask again).
• Once per computer. There's no project-or-global choice. A notification shows the progress and can cancel it; every file is checked against its checksum before anything is replaced.
• No admin rights. Everything is unpacked into CodeGenie's own folder; nothing is installed system-wide.
• Ready at once. The agent can use a tool in the next command it runs, without a restart. The tools are added at the end of PATH, so your own Python or virtual environment still comes first; the agent uses the bundled Python by its full path.
• Where. In VS Code's storage for the extension, under tools/:
  • Windows: %APPDATA%\<editor>\User\globalStorage\kternai.codegenie-agent\tools\
  • macOS: ~/Library/Application Support/<editor>/User/globalStorage/kternai.codegenie-agent/tools/
  • Linux: ~/.config/<editor>/User/globalStorage/kternai.codegenie-agent/tools/
  • <editor> is the editor's own folder: Code for VS Code, Code - Insiders, Cursor, Kiro and so on for other VS Code-based editors, each with its own copy.
• Remove on the card deletes the tool's folder.

What each part is for:

Part	What it's for
Python 3.12 (portable)	runs the skills' scripts; separate from any Python you have
openpyxl	reads and writes .xlsx: cells, formulas, styles, charts, sheets
xlsxwriter	writes new .xlsx files quickly, with rich formatting and charts
pandas	cleans, reshapes and analyses tabular data (Excel, CSV)
python-docx	creates and edits Word documents: paragraphs, tables, styles, images
python-pptx	creates and edits PowerPoint decks: slides, shapes, tables, notes
pypdf	merges, splits, rotates and encrypts PDFs, fills form fields
pdfplumber	extracts text and tables from PDFs, with their positions
pypdfium2	renders PDF pages to images
reportlab	creates new PDFs from scratch
Pillow	handles images: resize, convert, thumbnails for visual checks
lxml	reads and writes the XML inside Office files
defusedxml	parses that XML safely, blocking malicious files
matplotlib	draws charts as images to put in Word reports and slides
pandoc	converts between formats (Word ↔ Markdown, HTML and more)
pdftoppm, pdfinfo	turn PDF pages into PNG or JPEG and report page info, so the agent can look at a page (poppler on Windows, a small stand-in on macOS and Linux)
docx (Node)	builds Word documents from JavaScript; the docx skill's way to create new ones
pptxgenjs (Node)	builds PowerPoint decks from JavaScript; the pptx skill's way to create new ones
codegenie-node	runs those Node scripts with VS Code's own Node, so Node needn't be installed
LibreOffice	converts documents to PDF and between formats (.doc → .docx, .ppt → .pptx), recalculates Excel formulas so saved values are right, and renders slides and pages so the agent can check how they look

The agent uses only what a task needs. Reading a .docx, .xlsx or .pptx needs none of these.

The bundles are built with bun run build:tools from the repository, which downloads pinned versions from each project's official releases and checks them, and are published to the marketplace bucket with the rest of the standard catalogue.

---

Agent Manager: parallel sessions and worktrees

The Agent Manager (Ctrl+Shift+M) turns one VS Code window into a control room for several sessions.

How parallel sessions work:

1. Local is your workspace as it is. Sessions there edit your checkout directly.
2. New worktree (Ctrl+N) creates a git worktree: a separate folder on its own branch (Ctrl+Shift+N lets you pick the branch and its base). The setup script runs there, and a session opens in it. Its edits never touch your checkout or the other worktrees.
3. Start more worktrees and give each a task. They run at the same time; the sidebar shows which ones are working, their changes (+/−, commits ahead) and any pull request.
4. To compare approaches, send one prompt to up to four versions at once. They're grouped in the sidebar ("3 versions" above), each in its own worktree. The dialog lets you pick the agent and, in Compare Models, which models to spread the versions across; the model list opens inline so it never hides the agent picker, and your chosen agent is used for every version, with or without a prompt.
5. Open a worktree to see its chats as tabs, its terminal, and Review with every changed file. Keep the version you like, commit and push it from its worktree's terminal or Source Control, and close the rest (Ctrl+Shift+W).

• Isolation. Each session can run in its own git worktree with its own branch, terminal, setup script and diff view.
• Compare approaches. Run the same prompt in up to four worktrees and compare the results before you merge.
• Live status. Git stats and pull-request status update for each worktree.
• Tabs. The open tab joins the page below it. Use Ctrl+1–Ctrl+9 to jump to a session, and Ctrl+Alt+↑/↓ and Ctrl+Alt+←/→ to cycle.
• Removed worktrees. Chats of a removed worktree are kept. They open read-only, with Fork into this workspace and Export…; the worktree's row shows a warning until you remove it from the list.
• Empty panel. With no sessions yet, the panel offers New session (on your checkout) and New Worktree.

Action	Shortcut
New worktree	Ctrl+N
Open existing worktree	Ctrl+Shift+O
Close current worktree	Ctrl+Shift+W
Advanced new worktree (branch, base)	Ctrl+Shift+N
New tab / terminal tab / close tab	Ctrl+T / Ctrl+Shift+T / Ctrl+W
Terminal / run script / diff panel	Ctrl+/ / Ctrl+E / Ctrl+D
Show all Agent Manager shortcuts	Ctrl+Shift+/

---

Autocomplete

Not yet stable. Autocomplete runs on Claude Haiku 4.5, a chat model rather than a completion model, so suggestions can be slow, empty or off the mark. It will move to a dedicated completion model in a later release.

• Inline suggestions from Claude Haiku 4.5 appear as you type. Press Tab to accept and Esc to dismiss.
• Ctrl+L / ⌘L inserts a suggestion at the cursor, if Enable smart inline task keybinding is on.
• Chat box suggestions finish your message from the code you have open, if Enable chat textarea autocomplete is on.
• The status bar shows the KaarTech K, the number of completions and their cost. Autocomplete counts toward your spend, like chat.
• Copilot. If GitHub Copilot's inline suggestions are on, CodeGenie offers to turn one of them off.
• Limits. Suggestions are at most one short line. Some come back empty, because Haiku is a chat model rather than a completion model.

---

Chats, export and history

• Chats.
  • Search, date groups, and a "⋯" on each chat with Rename, Fork chat and Export….
  • Chats are never deleted. Revert to here asks first and continues in a new chat up to that message: Rewind keeps your files as they are, Rewind & undo changes also puts back the files written from there on. The chat you rewound from keeps its whole history.
• Export chat… writes Markdown to read, JSON for audit and log tools, or a chat to import. For Markdown and JSON you choose whether to include tool calls, model, route and cost, and reasoning.
  • Exports carry the project and buildspace but no name or email, and paths are made relative.
  • /export and /export-json do the same from the composer.
• Fork. Fork from a message or the whole chat. Forked turns are never billed twice.
• A chat whose worktree was removed opens read-only wherever you open it, sidebar included, with Fork into this workspace and Export… in place of the composer.
• Finding something from an earlier chat. Ask the agent, for example "what did we decide about the budget card last week?" or "how did we fix the export dialog before? Use your recall tool".
  • It searches what was said in this project's chats, its worktrees' chats and sub-agent chats: your messages, the replies, and the tools that ran (their titles and the start of their output). Chat titles count too.
  • The search is by keywords, not meaning, so distinctive words work best: a file name, an error message, a feature's name. All the words must appear; if nothing matches, any of them will do. Put an exact phrase in quotes.
  • Results are grouped per chat, best match first, with short snippets. The agent then reads just the messages around a match instead of the whole chat.
  • It asks your permission before searching, and it only sees chats from the open project.
  • The chat you're in is marked "(this chat)" in the results. Recall's session view lists the current chat and every sub-agent session it started, with each one's ID, status and the start of its last answer; it doesn't ask first, because it only reads this chat.

Handing a chat to a teammate

1. Open the chat's "⋯" › Export…, pick Chat to import and save the .chat.json file. It keeps every tool call and its output, so the next person sees what you saw.
2. Send the file to your teammate. Tool output can contain file contents, command output and secrets such as tokens, so share it only with people who may see them.
3. They open Chats › Import chat… (or type /import), pick the file and choose Import or Hand over.
4. Import opens the whole chat as a new chat in their workspace, titled "… · imported". They continue it with their own model and mode.
5. Hand over copies none of its messages. It asks for an agent (the chat's own agent is listed first) and an optional focus, then opens a new chat, titled "… · continued", that starts from a summary of the file's chat (see Continuing in a new session). The summary is marked as a teammate's chat, used as background and not as instructions.

What carries over and what doesn't:

• Spend. The imported turns aren't counted again. Only new turns count, toward the person who sends them.
• Checkpoints. They stay behind, so earlier turns can't be rewound. New turns get checkpoints as usual.
• Files. The chat refers to files by relative path, so it makes most sense with the same repository open.
• Older exports. A JSON export works too. If it was made without tool calls, the import warns that CodeGenie won't see what those steps found.

Continuing in a new session

When a chat gets long, hand it over: CodeGenie writes a handover summary of it and continues in a new chat that starts working right away, with the agent you choose. The old chat stays as it is.

• Three ways to start it.
  • Type /session_handover [agent] [focus], for example /session_handover debug focus on the retry bug. A first word that names an agent picks it (in any letter case); the rest is what the new chat should focus on. With no agent named, it asks which one, the chat's current agent first.
  • Ask the agent, for example "continue this in a fresh session with Plan". It asks your approval first, and its turn ends once the new chat is running. You can also give it an exported chat, "hand over from teammate.chat.json to Debug".
  • Run CodeGenie: Hand Over Session from the Command Palette and pick the agent.
  • From another extension, call vscode.commands.executeCommand("codegenie.handoverSession", { agent: "debug", focus: "the retry bug" }). Both fields are optional: a named agent (any letter case) skips the picker, and without one the picker opens as usual. It hands over the chat open in the active CodeGenie tab or the sidebar, and resolves to the new chat's session ID, or undefined when nothing was handed over.
• The summary has the same sections every time: Objective, Work done (with how each item was checked, or "unverified"), Important notes, References, Todo and What's next. It becomes the new chat's first message.
• What carries over. The to-do list, including the reasons for set-aside items. The new chat, titled "… · continued", runs on the same model choice: Auto stays Auto, a tier stays that tier, and a model picked by name stays that model.
• Where it opens. The sidebar, tab or Agent Manager session that showed the old chat switches to the new one. If you've moved to another chat in the meantime, you get Handover ready with Open instead.
• When it won't run. Nothing is created, and it says why, when the chat has no answered turn yet, is still replying, is already being handed over, or is too long to summarise in one go (run /compact first). If the summary fails or you cancel the progress notification, the old chat stays open and nothing changes.
• Spend. The summary is one model call and counts toward your spend once. When you start the handover yourself, it's held back while the project budget is reached, like /compact; when the agent starts it, it's part of a turn that was already checked. After that, the new chat's turns count as usual.
• Approval. The agent's handover asks each time. Set permission.session_handover to allow or deny in codegenie.json to skip the approval or turn it off. Sub-agents never get it.

CodeGenie: Open Chat with Agent opens a chat with any agent, built-in or your own, without a handover. Pick the agent, then the current or a new chat (the second question is skipped when no chat is open), then an optional first message. Leave the message empty to just open the chat with the agent selected.

From another extension, call vscode.commands.executeCommand("codegenie.openChatWithAgent", { agent: "plan", text: "plan the export feature", fresh: true }). All three fields are optional. A named agent (any letter case) skips every question: it opens a new chat unless fresh is false, and sends text only when it's given. Without an agent the usual questions are asked, minus the ones whose answer you passed.

To continue an existing chat, pick Existing session in the palette (offered when the history has chats) and choose a chat from the list, which shows each title with its session ID, or type a session ID and press Enter. From another extension, pass sessionID (or session_id): executeCommand("codegenie.openChatWithAgent", { sessionID: "ses_…", text: "now add tests" }). A message is required for an existing chat; if you leave out text, you're asked for it. The chat keeps its own agent unless you name one. An unknown ID, or a sub-agent's session, opens nothing.

Both commands resolve to a session ID: codegenie.handoverSession to the new chat's, and codegenie.openChatWithAgent to the chat it opened (an existing one, the current one, or a new one, which is created straight away, so it has an ID even without text). Both resolve to undefined when nothing was opened.

Another extension can then check where a chat stands. Call vscode.commands.executeCommand("codegenie.sessionStatus", "ses_…") with a session ID string, and it resolves to { kind, reason? }: running while a turn is in flight, idle when the session finished without an error, stopped-with-error with the reason the last turn failed, and not-found when no session exists for the id. The command only reports; it never starts, stops or changes the session.

Approvals, checkpoints and diffs

• Approvals. Each request shows numbered choices:
  • 1 Allow once (Enter);
  • 2 Always allow what it names — the file (Always allow src/foo.ts in this project) or the command family (Always allow git log * in this project) — and only for that file or command family;
  • 3 Deny (Esc);
  • 4 Deny and tell CodeGenie why: type what it should do instead ("use bun, not npm") and press Enter. The agent gets your reason and carries on with it instead of stopping.
• What asks. Changing a file (edit, write, patch), running a shell command that isn't read-only and calling an MCP tool ask first, for every agent that can do them. Reading, searching, web fetch and search, skills and the to-do list don't. Auto-approve lets them through, and so does a rule in your config: "permission": { "edit": "allow" } for all edits, { "edit": { "src/**": "allow" } } for a folder, { "context7_*": "allow" } for a whole MCP server. MCP servers the extension adds itself, such as the built-in browser, aren't covered by the MCP prompt. You can also ask the agent, for example "stop asking before edits in this project": the built-in codegenie-config skill finds the exact project or global config file for the open folder, writes the rule there, and tells you if another file overrides it.
• Auto-approve. Use the switch in the mode picker and the "+" menu, or Ctrl+Alt+A. Turning it off also clears the allow-everything rule on the backend, so permission prompts come back right away.
• Diffs. Review every change before it lands, in a split or unified diff viewer. Markdown diffs can be rendered.
• Checkpoints. Hover a message and choose Revert to here. Both choices continue in a new chat up to that message, with the message back in the composer: Rewind leaves your files as they are, Rewind & undo changes restores the files written from that message on from the checkpoint. Nothing in the chat you rewound from is hidden, edited or deleted.

---

Browser, screenshots, design, terminal and Git

• Browser. Playwright ships inside the extension and is on by default, headless. It drives a page: navigate, fill forms, capture screenshots and downloads.
  • Use System Chrome (the default) uses your installed Google Chrome.
  • Without Chrome, a one-time prompt offers Download Chromium, Not now or Turn off. Chromium goes into the extension's storage, about 100 MB for headless (a visible window needs the full browser), with progress you can cancel. Not now is remembered until you change the browser settings.
  • Settings › Browser turns automation off, shows the window, or switches browsers.
• Screenshots (in VS Code, not the terminal CLI). The agent can screenshot an HTML or SVG mockup, or a running page such as your dev server, at a size you choose or full page, and look at the result. Each screenshot is saved as a chat artifact.
• Design skill. For UI work a built-in design skill loads on demand: brief, plan (palette, type, layout), mockups as artifacts, a build that meets an accessibility and responsive floor, then screenshot and critique. Ask for a screen "like" a product and it studies that product's pages first.
• Terminal. Generate a command from plain language (Ctrl+Shift+G), fix or explain a command, and add terminal output to the chat.
• Git. Generate commit messages from the Source Control panel, and use auto-branching per worktree.

---

Settings

Settings opens in an editor tab. The search box finds individual settings as well as pages: type "font" or "compaction" and the matching settings are listed under their page; click one to open the page scrolled to it, highlighted. A match on an Agent Behaviour sub-tab ("mcp", "skills") opens that sub-tab.

Group	Pages
General	Display (Signature · KaarTech or Match VS Code, username, layout, font size, terminal command blocks collapsed or expanded), Notifications, Language
Agents	Agent Behaviour, Autocomplete, Commit Message
Tools and permissions	Auto-Approve, Browser
Knowledge	Context, Indexing
Advanced	Checkpoints, Experimental, About (version, model access, settings export and import)

Settings Transfer, under About, exports your settings to codegenie-settings.json and imports them on another machine.

---

Commands and keyboard shortcuts

Ctrl on Windows and Linux, Cmd on macOS.

Command	Shortcut
Open Agent Manager	Ctrl+Shift+M
Focus chat input	Ctrl+Shift+A
Toggle Auto-Approve	Ctrl+Alt+A
Next / previous agent mode	Ctrl+. / Ctrl+Shift+.
Add selection to context	Ctrl+K Ctrl+A
Generate terminal command	Ctrl+Shift+G
Autocomplete: suggestion at the cursor	Ctrl+L
Autocomplete: dismiss	Escape
Explain / Fix / Improve code	editor right-click menu
Open Spec	Command Palette › CodeGenie: Open Spec, or the checklist button on an open spec file
Continue in a new session	/session_handover [agent] [focus], or Command Palette › CodeGenie: Hand Over Session
Open a chat with an agent	Command Palette › CodeGenie: Open Chat with Agent
Compact the open chat	/compact, or Command Palette › CodeGenie: Compact Session
Session status (for other extensions)	executeCommand("codegenie.sessionStatus", "ses_…")

---

Enterprise and security

• Your AWS account. Models run on Amazon Bedrock under your company's account and inference profiles.
• Project and buildspace scoping. Sessions, spend, and the team marketplace are scoped to a KTern project.
• Budgets. Budgets, for the whole project or per user, are enforced by KTern, and CodeGenie shows how much is used and warns before it runs out. When KTern can't confirm the budget, sending pauses and says why.
• Approvals first. File changes, shell commands that change things and MCP tool calls ask unless you choose to auto-approve them.
• Web search. Search queries go to a web search service; pages are fetched from the sites directly.
• Secrets stay local. Publishing an MCP server never uploads environment or header values unless you choose to share them. The server list masks them.
• Local state. Agent Manager state, worktrees, chats, plans, specs and chat artifacts live on your machine and in your repository. The recall search index is kept in CodeGenie's local database, and background processes run on your machine and stop when CodeGenie closes.
• Mockups run without scripts. HTML artifacts open in a panel that blocks scripts; local pages are served to the screenshot tool from 127.0.0.1 only for the call.

---

Resources

• What's new. The release notes for each version live in the repository's release-notes/ folder. 2.2.17 lets another extension ask CodeGenie for a session's lifecycle status with codegenie.sessionStatus, which reports whether a session is running, idle, stopped with an error, or not found. 2.2.16 lets Open Chat with Agent continue an existing chat, picked from the history or named by its session ID, makes both chat commands return the session ID of the chat they opened, and has KTern set up web search so it can change without a new extension version. 2.2.14 moves Fast, Smart and Auto to the tier's next model when Bedrock keeps answering "unable to process your request" or reports the model overloaded, instead of retrying the same model without end, and lets Expert wait about two minutes for Opus 5.5 before it finishes the turn on Sonnet 5.5 and tries Opus again shortly after. 2.2.13 makes sure no usage report is lost when KTern doesn't answer, bills stopped and failed turns and sub-agents correctly, gives Auto a second classifier, counts every unique thing a chat produces with a new Tools tab in the Artifacts list, carries that list in exports, and sends the last usage spans when VS Code closes. 2.2.12 fits images to the model's limits so long chats with screenshots keep working, reads Word, Excel and PowerPoint files as text, ships Word, PowerPoint, Excel and PDF as built-in skills, adds a marketplace Tools tab with Document tools and LibreOffice, makes the codegenie-config skill write to the right project or global file and change permissions, makes Publish all include global workflows and rules, and lets every chat know its session and its sub-agent sessions so a throttled sub-agent is resumed instead of started again. 2.2.11 saves the MCP on/off switch in the "+" menu to your config so it survives a reload, adds a Changelog tab to the extension page, and adds ABAP Object Documentation and Create PR workflows to the marketplace. 2.2.10 lays the groundwork for the KTern Workflow Studio companion extension: each workflow command gets its own folder so it can carry a sibling studio definition, workflows are tagged Standard or Agentic, the Edit button opens Agentic workflows in the Studio when a definition exists, and the marketplace distributes workflows as folders with their optional definitions. 2.2.9 makes edits safer — a loose match that would overwrite a line the agent never wrote is refused and your file is left alone, a no-match shows the closest lines to copy from, and a failed multi-edit says which edit failed and that nothing was written — and fixes the New Worktree dialog so the Compare Models list no longer covers the agent picker and the agent you pick is used for every version. 2.2.8 makes edits and MCP tool calls ask for your approval by default, for every agent, unless Auto-approve is on or your config allows them. 2.2.7 scopes Always allow to the file or command family it names instead of silently allowing every future edit and read, makes turning Auto-approve off clear the backend's allow-everything rule so prompts come back, and lets Revert to here continue in a new chat — Rewind keeps your files, Rewind & undo changes also restores them from the checkpoint — so the chat you rewound from keeps its whole history. 2.2.6 makes the agent tick off its to-do list when the work is done, and stops holding a change as "Not run … no todo list yet" when a list is already open or was sent in the same step. 2.2.5 moves Fast to Claude Haiku 5.5 (1M window), with Haiku 4.5 and then Sonnet 5.5 as fallbacks that a long chat skips when it no longer fits, lists both Haikus under Specific models, stops replaying one model's thinking as text to another after a switch, and bills Sonnet 5.5 cache reads at the lower rate. 2.2.4 adds a Compact Session palette command for the open chat, and lets other extensions run Hand Over Session and Open Chat with Agent with their answers passed in. 2.2.3 shows how much of the budget is used (project or per-user) in the account menu and the "+" menu, warns when it runs low with a snooze, restyles the budget card, and says when a buildspace name is taken. 2.2.0 adds the Spec agent, chat artifacts, the bundled browser with screenshots, one shared base for every agent, several edits in one step, recall that searches what was said in past chats, new problems from the Problems panel after each edit, background processes for dev servers, the spec panel, "Deny and tell CodeGenie why", and settings search that finds individual settings.
• Language. CodeGenie's own strings are in English only for now.
• Changelog. See CHANGELOG.md.
• License. See LICENSE.

_{CodeGenie · KaarTech · KTern.AI Intelligence}