# The complete guide to LM Studio Bionic

> Learn LM Studio Bionic: choose local or cloud models, fix a JavaScript bug step by step, work with documents, and review what the agent changes.

Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2026-10-24 | Topics: [AI](https://flaviocopes.com/tags/ai/) | Canonical: https://flaviocopes.com/lm-studio-bionic/

LM Studio Bionic lets you give an AI agent a folder of code or a set of documents and ask it to do work with them. You can choose a model running on your computer, on another machine you own, or in LM Studio's cloud.

That makes it an option if you want to try coding agents with open models, without assembling a model runner and an agent interface yourself.

We'll set up a project, ask Bionic to fix a small JavaScript bug, and check the result with tests. Then we'll use the same sample data for a document task.

This walkthrough follows the [official Bionic documentation](https://lmstudio.ai/docs/bionic), checked in October 2026. I haven't run these tasks in Bionic myself. The JavaScript example is runnable independently, and the prompts give you a concrete way to evaluate the agent on your own computer.

## How Bionic differs from LM Studio

Bionic is a separate application. The familiar LM Studio app remains available for experimenting with models and configuring inference. Bionic adds the project interface and tools for working on files. You can keep using both. [LM Studio explains the distinction here](https://lmstudio.ai/docs/bionic).

A model generates responses. An agent also has tools it can call to inspect files, change code, or run a command. Bionic supplies that environment around the model.

Choosing a capable model still matters. A model that chats well might struggle to choose the right tool or finish a multi-step edit.

## Local, remote, or cloud?

You choose the model from the picker in a session. These are the [three execution options](https://lmstudio.ai/docs/bionic/models):

| Option | Where inference happens | What you need |
| --- | --- | --- |
| Local | Your computer | A downloaded model that fits your hardware |
| Remote, through LM Link | Another linked device | That device available and sharing its models |
| Cloud | LM Studio Secure Cloud | Internet, a signed-in account, and available credits |

Start locally if your goal is to keep model processing on your computer. Start with cloud inference if your machine cannot comfortably run the model you need. LM Link is useful when you have another machine with more memory available.

A remote model still receives the input it needs for inference. The docs say the conversation stays on the device where you use Bionic, while the linked device runs the model.

Local and LM Link models [don't consume Bionic cloud credits or require an LM Studio account](https://lmstudio.ai/docs/bionic/accounts-plans-and-billing). Your own hardware still uses memory, storage, and electricity.

Cloud requests leave your computer. LM Studio says Secure Cloud processes them with Zero Data Retention. That describes how the service handles requests; choose local inference when your requirement is that model input stays on your device.

## Install Bionic and choose a model

Download **Bionic** from the [LM Studio download page](https://lmstudio.ai/download). Check the current Bionic downloads for your operating system; the regular LM Studio installer is a separate download.

For a local model, open **Settings → Local Models → Explore**. Search for a model, use the device-fit information to narrow the choices, select its format and variant, and download it. Downloaded models appear under **Local Models → Library**. [The download guide shows this flow](https://lmstudio.ai/docs/bionic/models/download-local-models).

Choose a model that supports tool use for this tutorial. Start with something your computer can run comfortably. A larger download doesn't automatically make a better first experiment.

Memory has to hold more than the model file. The conversation and other running applications also need space. If the model fails to load or your computer becomes sluggish, try a smaller variant and a shorter conversation before changing anything else.

Once you've created a session, select the downloaded model in its picker. **Settings → General → Root model** sets the default for new sessions. You can change a session's model later.

For cloud inference, sign in through **Settings → General → Account**, then use **Manage plan** to open the Hub and add credits under Cloud Inference. Check **Settings → Billing and Usage** afterward. [These are the documented billing steps](https://lmstudio.ai/docs/bionic/accounts-plans-and-billing).

Cloud usage depends on the model and tokens processed. Bionic's usage page shows totals rather than a guaranteed price for a complete task. Check it after a small run before leaving an agent on a long investigation. [More on credits and usage](https://lmstudio.ai/docs/bionic/accounts-plans-and-billing/credits-and-usage).

## Understand projects and sessions

A **project** groups related files and conversations. A **session** is one conversation inside it.

For our tutorial, use one project for the sample repository and one session for the bug fix. Later, a separate session can investigate another task without carrying the whole first conversation along.

Project files are shared across sessions. Separate conversations can still affect the same files, so avoid asking two sessions to edit the same function at once.

Bionic also supports session tabs, side-by-side views, and forking an eligible response. Switching tabs doesn't stop a running task. [The projects and sessions guide covers those controls](https://lmstudio.ai/docs/bionic/projects-and-sessions).

## Tutorial: fix a JavaScript bug

We'll make a tiny study tracker. It records study sessions and calculates how many minutes you've completed.

The bug is easy to verify: the starting implementation also counts a session that is still planned. This gives us a small task where we can judge the result ourselves.

You'll need Git and a recent version of Node.js. There are no packages to install.

### 1. Create the sample repository

In your terminal, create a new folder:

```sh
mkdir bionic-study-tracker
cd bionic-study-tracker
git init
```

Save this as `sessions.mjs`:

```js
export const sessions = [
  { topic: 'JavaScript', minutes: 25, completed: true },
  { topic: 'CSS', minutes: 40, completed: true },
  { topic: 'Git', minutes: 30, completed: false },
]

export function completedMinutes(items) {
  return items.reduce((total, item) => total + item.minutes, 0)
}
```

Save this as `report.mjs`:

```js
import { sessions, completedMinutes } from './sessions.mjs'

console.log(`Completed: ${completedMinutes(sessions)} minutes`)
```

Run it:

```sh
node report.mjs
```

The starting program prints `Completed: 95 minutes`. We want `Completed: 65 minutes`, because the 30-minute Git session hasn't been completed.

Save a baseline so you can compare the agent's edits:

```sh
git add sessions.mjs report.mjs
git commit -m 'Add study tracker with a counting bug'
```

If Git asks for your name and email, configure those before committing.

### 2. Connect the folder to Bionic

Create a new **Project** named **Study tracker**. Enable **Allow coding**, choose the `bionic-study-tracker` folder as its working directory, then click **Create**. Select your model in the new session.

These are the [current coding-project controls](https://lmstudio.ai/docs/bionic/agent/code-project). With coding enabled, Bionic can search and edit the repository, use Git, and run shell commands.

Choose the sample folder itself. There's no need to give this exercise your entire home directory.

### 3. Ask it to inspect first

Paste this prompt:

```text
Read sessions.mjs and report.mjs. Do not edit anything yet.

Explain why the report prints 95 completed minutes when only
65 minutes are marked completed. Identify the smallest fix.
Do not install packages or access the network.
```

The explanation should point to `completedMinutes()`. It currently sums every item without looking at `completed`.

If the response talks about changing the sample data or subtracting 30 from the result, redirect it. We want the function to work with different lists too.

### 4. Request the fix and tests

Continue in the same session:

```text
Fix completedMinutes() so it sums only completed sessions.
Keep the exported names and sample data unchanged.

Add sessions.test.mjs using node:test and node:assert/strict.
Cover the sample list, an empty list, a list containing only
unfinished sessions, and a list containing only completed sessions.

Run node --test sessions.test.mjs and node report.mjs.
Do not add dependencies, commit, or push.
Show me what changed and the command results.
```

There are several valid implementations. A compact final `sessions.mjs` would be:

```js
export const sessions = [
  { topic: 'JavaScript', minutes: 25, completed: true },
  { topic: 'CSS', minutes: 40, completed: true },
  { topic: 'Git', minutes: 30, completed: false },
]

export function completedMinutes(items) {
  return items
    .filter(item => item.completed)
    .reduce((total, item) => total + item.minutes, 0)
}
```

`report.mjs` stays as it was. Here's a complete `sessions.test.mjs` you can compare against the generated tests:

```js
import test from 'node:test'
import assert from 'node:assert/strict'
import { sessions, completedMinutes } from './sessions.mjs'

test('counts only completed minutes in the sample', () => {
  assert.equal(completedMinutes(sessions), 65)
})

test('returns zero for an empty list', () => {
  assert.equal(completedMinutes([]), 0)
})

test('ignores unfinished sessions', () => {
  const items = [{ minutes: 30, completed: false }]
  assert.equal(completedMinutes(items), 0)
})

test('adds all completed sessions', () => {
  const items = [
    { minutes: 10, completed: true },
    { minutes: 15, completed: true },
  ]
  assert.equal(completedMinutes(items), 25)
})
```

These tests assume the application supplies numeric minutes and a boolean `completed` value. Input validation would be a separate change if we started accepting arbitrary user data.

### 5. Check the work yourself

Review the inline diffs in Bionic, then run these commands in your own terminal:

```sh
node --test sessions.test.mjs
node report.mjs
git diff -- sessions.mjs report.mjs
git status --short
```

You should get four passing tests and `Completed: 65 minutes`.

A new, untracked test file won't appear in a normal `git diff`. Open `sessions.test.mjs` directly too. Check that it imports the real function and asserts the expected results.

The tests should fail against the original implementation. If they pass before the fix, they aren't catching our bug.

If Bionic didn't run the commands, its answer is still a proposal. Run them yourself and paste any failure back into the session. Ask for a correction that keeps the original constraints.

Once you're happy, save the result:

```sh
git add sessions.mjs sessions.test.mjs
git commit -m 'Count only completed study sessions'
```

You've now used the agent to inspect a repository, make a focused edit, and supply evidence you can verify.

## Tutorial: turn a file into a study report

Bionic also works with documents, spreadsheets, presentations, PDFs, images, and plain text. The available previews and editing behavior depend on the format. [The document guide explains the workspace](https://lmstudio.ai/docs/bionic/agent/work-project).

Let's use our study data without enabling coding. Create another project and attach a file named `study-sessions.csv` containing:

```csv
topic,minutes,completed
JavaScript,25,true
CSS,40,true
Git,30,false
```

Ask:

```text
Use only the attached study-sessions.csv. Do not search the web.

Create study-report.md with the completed minutes by topic,
the completed total, and a separate list of planned sessions.
Do not count unfinished sessions toward completed time.
Mention the source filename and show the arithmetic.
```

Open the generated file in the project's right sidebar. Check that JavaScript contributes 25 minutes, CSS contributes 40, and the completed total is 65. Git belongs in the planned section.

Then request a revision:

```text
Revise study-report.md. Add a short next-study suggestion based
only on the planned sessions. Keep all the original numbers.
```

This small exercise tests whether the model can extract facts, save a file, and revise it without losing information. If it gets the arithmetic wrong, give it the specific discrepancy and check the revised file again.

**Be careful with external files.** Bionic distinguishes project-managed files from external files that remain in their original locations. Editing an external file changes that original. For a first experiment, use disposable sample files like this one.

The [launch announcement](https://lmstudio.ai/blog/introducing-lm-studio-bionic) describes automatic checkpoints for document work. Keep your own copies of important inputs as well. A checkpoint for files can't undo every action an agent might take through a shell or external service.

For web research, enable **Settings → General → Web Search**. Ask for source links and check them. Leave it disabled when the task should use only the supplied material.

## Reuse a workflow with skills

A skill is a set of reusable instructions stored in a `SKILL.md` file, optionally with supporting files. Bionic supports the [Agent Skills format](https://lmstudio.ai/docs/bionic/agent/skills).

After getting a useful study report, ask:

```text
Create a skill based on this study-report workflow.
Require separate completed and planned totals, source filenames,
and an arithmetic check. Ask before overwriting an existing report.
```

Read the generated instructions before reusing them. Make sure they describe a general workflow rather than hardcoding our sample's 65-minute result.

Type `@` in the composer to select a skill explicitly. You can add an existing `SKILL.md` through **Settings → Skills**, or choose compatible skills from other apps through **Use skills found in other apps**. Review imported instructions too, especially any commands they ask the agent to run.

## Use voice input

Bionic can transcribe speech locally using Mistral's Voxtral model. Open **Settings → Voice** to configure it. **Auto load voice model** keeps the transcription model loaded so later dictation starts faster, at the cost of keeping that model in memory. [See the voice documentation](https://lmstudio.ai/docs/bionic/voice-input).

You could dictate the investigation prompt, then correct file names before sending it. Review the transcript carefully when it contains commands or numbers.

Local transcription and local inference are separate choices. If the session uses a cloud model, the transcribed prompt still goes to that cloud model.

## When something goes wrong

| Problem | What to check |
| --- | --- |
| A downloaded model isn't available | Check Local Models → Library, then the session's model picker. |
| A remote model disappears | Check that its LM Link device is connected and sharing models. |
| The model won't load comfortably | Try a smaller variant, close other memory-heavy apps, and reduce conversation size. |
| Bionic explains code but can't run the checks | Check Allow coding and the selected working directory. |
| Cloud requests can't proceed | Check sign-in and available credits, then refresh Billing and Usage. |
| The agent claims success but the result is wrong | Run the command yourself and give it the actual failure. |
| A document preview is missing | Preview support varies by format. Open the generated file with an appropriate application. |

For a stubborn coding task, start a fresh session with the relevant files and a narrower question. Don't keep repeating a broad request while the model edits unrelated parts of the project.

## How I would evaluate it

I'd start with the bug-fix exercise above and use a local model. It's small enough that I can read every change and know whether the tests prove anything.

Then I'd try a real task of similar size: explain an unfamiliar function, fix one reproducible bug, or summarize a short document with references to the source.

For me, choosing where inference runs is Bionic's main appeal. The trade-off is that local models depend on the hardware you have, and their ability to finish agent tasks varies. Cloud inference can remove that hardware constraint, but adds usage costs and sends model input to a service.

Keep the same task and checks when comparing models. A correct 65-minute report and tests that catch the original bug tell you more than a confident final message.