Learn by doing · Pro

From offline suggestions to AI-assisted coding

Start with fast table-based suggestions that cost nothing per request. Then set up the Assistant, ask for online alternatives, try an on-device model, and finish with focused AI Prompt cells that explain your code.

Pro only
Pro 1.4.0 + upcoming execution controls
Local model: Android

Most screenshots show the Android app; some are browser captures. Layouts may vary with your app version.

Check your version. The execution changes in the appendix are planned for proposed Pro 1.5.0, which is unreleased; the final release number may change.

“Free” here means no API charge. Table suggestions and the on-device model do not bill a provider. That does not make them Free-edition features: this walkthrough is for SciREPL Pro. Online requests use your own provider account and can cost money.

Step 1 · No API key needed

Start with offline table suggestions

Find ☰ Menu in the app's header: it is the button with three horizontal lines. Open Completion. Its Section picker separates General, AI suggestions (online), and Local model (on device). Begin with General.

Set Local code completion → On. The default Auto (desktop on, touch off) would otherwise leave it off on a phone.
Set Suggestion chips → On and keep Suggestions → At cursor. To isolate the tables, set AI suggestions → Off in the online section and Use local model → Off in the local section, if either was previously enabled. Return to General.

The actual General controls in a narrow **browser capture, not an Android screenshot**. Yellow borders locate **Suggestions → At cursor**, **Suggestion chips → On**, and their section titles. The Section dropdown is at the top; lower settings may require scrolling.

Close Completion. In a new practice workbook, choose a Code cell and the JavaScript language. Type cons, with the caret at the end and no selection. These first letters of const are called a prefix. Look for const.
In the screenshot below, cons is followed by a faint t—in-line ghost text. Tap Accept or press Tab to insert the suggestion, giving const. If a const chip appears instead, tapping it is another way to accept that candidate. Finish the line yourself, for example const values = [12, 15, 18];.

Accept is not Run. Accepting a suggestion edits the source; it does not execute the cell. The JavaScript and Python examples in this section demonstrate autocomplete while editing. Running these practice cells is not part of this section. With only the offline table layer enabled, typing a prefix does not send an API request or start a language runtime just to make suggestions.

Future online prefetch: an opt-in mode is planned that could send model requests while you type. It is not available yet, and no release number is assigned to it. The no-request statement above describes the current offline table layer, not this future mode.

Lower composer detail from an actual Android Galaxy S24+ screenshot: JavaScript cons followed by a faint t ghost and an Accept button, with suggestion chips enabled and the extra-key row hidden. — **Detail view of an actual Galaxy S24+ Android screenshot.** JavaScript table completion offers `const` for `cons`: the faint `t` is ghost text, with **Accept** visible and chips enabled. The API and local model are off. The extra-key row is hidden here to contrast with the next picture; it is a separate optional control, not a requirement for completion.

See the two offline displays on a phone. Leave Suggestion chips → On, choose Python, and type pri. The faint nt after the caret offers print; it is not part of your source until you accept it. You do not need to turn chips off to see ghost text. A single candidate can appear as a ghost, while chips offer a choice when several candidates fit. Keep AI suggestions and Use local model off for both examples.

Lower composer detail from an Android Galaxy S24+ screenshot: Python source pri followed by faint ghost text nt and an Accept button. Suggestion chips are enabled. — **Detail view of an actual Galaxy S24+ Android screenshot.** Offline table completion offers one faint suffix at the caret with **Suggestion chips → On**. The API and local model are off.

With chips still On, replace the practice input with these three lines, leaving the caret after the unfinished sample_m. The row offers sample_mean and sample_median from names in your own source. Tap a chip to choose a candidate; unlike ghost text, the row shows alternatives.

sample_mean = 0
sample_median = 0
sample_m

Lower composer detail from an Android Galaxy S24+ screenshot: Python source defines sample_mean and sample_median, then sample_m, with candidate chips sample_mean and sample_median. — **Detail view of an actual Galaxy S24+ Android screenshot.** With chips on, source-derived offline candidates offer the two names above. The API and local model remain off.

The extra-key row visible in the Python phone pictures and syntax colours while typing are separate, optional Pro controls. See Appearance walkthrough: extra keys and syntax colours to turn either on or off, and to find the file editor's separate highlighting checkbox.

After trying these completion displays, switch back to JavaScript and leave chips on for the rest of the lesson.

The offline chips shown here, enabled under Completion → General → Suggestion chips, combine curated name tables with local code information. In Python, that includes variables and functions found in workbook code and cached kernel names and object attributes, including methods. Frequency and acceptance history help rank them. Other languages have different coverage: static lists, unrun definitions or stale snapshots may suggest a name that is not currently available in scope. Table-based completion is not a language model and does not reason about your task.

End of cell only is an alternative if mid-cell suggestions distract you. A selection, string, comment, or half-split name may intentionally produce no suggestions. In short landscape, optional rows can disappear to keep room for code; see Appearance settings.

Detail of the actual Galaxy S24+ Android General Completion screen: the Suggestions dropdown is open with At cursor selected and End of cell only beneath it. — **Actual Galaxy S24+ Android screenshot.** In **Completion → General → Ghost text → Suggestions**, choose **At cursor** or **End of cell only**. The latter means the end of the *whole cell*, not each line. Android's expanded menu covers the nearby indentation settings; those are separate controls, not part of this choice.

Step 2 · Online setup

Save an API key

An API key lets SciREPL use a provider account you control. Obtain the key from that provider, check its current prices and account limits, and use only a small practice workbook with non-private data for this lesson.

Open Menu → 🤖 AI Assistant (Pro). Tap the panel's ⚙ gear to open AI Settings.
Can't see the gear? The keyboard can shift or scroll the Assistant panel. Drag the panel's contents downwards to scroll back towards its top and reveal the gear; dismissing the keyboard can also give you more room.
Set Configure model for → AI Assistant. Choose a Backend (e.g. OpenRouter) and Model, and check the endpoint if your backend uses a configurable one.
Enter the matching API Key. Use Saved keys to manage keys for other provider/endpoint pairs. A key for one destination is not automatically a key for another.
Tap Save. Saving settings alone does not make a model request. Keep the panel open for the next step.

Keep the key out of the workbook. Do not paste it into a cell, prompt, screenshot or exported file. Saved keys stay in local app/browser storage, without application-level encryption; protect the device and do not run untrusted code. The Pro privacy policy explains what is stored and sent.

A fresh, **keyless browser capture** of AI Settings, not an Android screenshot. Yellow borders mark the fields to set: **Configure model for**, **Backend**, **Model** and **API Key**. The faint `sk-…` is a placeholder, not a saved key. Scroll farther down to reach **Save**; no key was entered or request sent for this picture.

A low-cost, tool-capable model is a sensible starting point for the Assistant. Examples to compare include GLM 5.3 Flash, GPT-6 Luna, Claude Haiku 5.5, and DeepSeek V4 Flash. Exact model IDs, available versions, tool support and prices depend on your app version and provider; check the current picker and provider documentation. A newly announced model may need an app update before it appears. Later, you can choose a different inexpensive model just for completions.

Model missing from the list? In AI Settings → Configure model for → AI Assistant, choose the correct Backend first, then enter the provider's exact API model ID in Or enter custom model ID, below the Model picker, and tap Save. This field is already available in Pro 1.4.0.

Verify the ID with your selected provider, not just the model's marketing name. For OpenRouter, include the organization prefix—for example, anthropic/claude-haiku-5.5 on its model page. Enter the ID, not that page's URL. The custom ID takes precedence over the dropdown; choosing a listed model again clears the custom field.

An ID does not add API support. The model must support tool calls through the API SciREPL uses. Check provider access, compatibility and current prices; saving does not validate them or make a model request.

A real, **keyless browser capture**, not an Android screenshot. The yellow border below Model locates the custom-ID field. The dropdown still shows GLM 5.3 Flash, but the typed Haiku ID would take precedence on Save. API Key and Save are below this crop; no key was entered, Save was not pressed, and no model request was sent. This is a configuration example, not a test that the model works.

Step 3 · Deliberate tool use

Build a small example with the Open agent preset

Open is the second-most-permissive security preset, after Full control. It allows notebook edits by default, with fewer prompts than Cautious. Whether execution asks depends on your version and permission settings; see the upcoming execution-approval appendix. Use it deliberately in a practice workbook—not as a requirement for autocomplete.

In AI Settings, select Security Level → Open and Agent writes → Active worksheet. Leave source browsing off and turn off Auto-run cells created by AI. Under Kernels…, set JavaScript → Ask, then save. This kernel rule still asks even if an execution-tool Allow was saved earlier.
Auto-run off is not an execution lock. It stops newly created cells from running automatically; it does not disable separate execute_cell or run_cells requests. Released Pro 1.4.0's Open default can allow them without asking. The upcoming Open default asks, but an explicit tool or kernel Allow can change that default. AI Settings → Kernels… → JavaScript → Ask keeps this exercise's JavaScript execution behind confirmation. Your own manual cell Run remains a separate action. Next-release execution controls are detailed in the appendix.

If you prefer more confirmation, use Cautious instead. Open still respects the separate source-browsing and write-scope controls; Full control bypasses those two coarse controls. Individual permissions and other safety gates still matter. Review is an additional read-mostly restriction, which would obstruct this cell-creation demonstration.

What the browser sandbox does—and does not—protect

Normal workbook execution runs in the browser/WebView and its language runtimes, with a virtual filesystem rather than unrestricted access to your phone's files. That is a useful boundary, not a guarantee that code cannot do harm. Permitted JavaScript and bridges to it can reach app data and saved credentials; network restrictions are best-effort once allowed code starts, not an isolation boundary you should trust with secrets. The upcoming execution prompt adds an approval step, not isolation from the app's data. Use a practice workbook and keep its contents non-private.

Remote/MCP Terminal is different: it can expose a real shell on the broker host, outside the browser-local sandbox. Keep Remote and Terminal off here. See Remote and security before enabling them. A polite “do not…” in the prompt is not a security control.
In the Assistant panel, choose This workbook. Leave Review, Remote, and Terminal off for this direct-provider example.

Panel header

Bottom controls

Two details of the same actual Galaxy S24+ Android screenshot. Yellow borders locate This workbook and Review, Remote and Terminal (all unchecked). The empty middle of the panel is omitted. No prompt was sent.
View the unmodified full Assistant-panel screenshot

Send the practice prompt in the callout below. The panel's Send already starts the agentic tool loop: there is no extra “Agent mode” toggle here. The full-screen editor's Agent button is a separate workflow.

Copy this prompt. Paste it into the Assistant's message box, not a code cell, then tap Send.

In this practice workbook, add a Markdown explanation followed
by one JavaScript cell named summary_demo. Generate an input
array of 10 pseudorandom integers from 1 to 20 inclusive.
Use the Park-Miller generator with initial state 42. For each
value, first update state = (16807 * state) % 2147483647;
then append 1 + Math.floor(20 * state / 2147483647).
Generate the array with this rule; do not hard-code its values
or use Math.random. Reset state to 42 on each cell Run.
Print the generated input array, then compute its count (array
length), arithmetic mean, minimum and maximum. Print each
result on its own labelled line with console.log.
Use ordinary JavaScript arrays, arithmetic and Math.floor,
with no packages.
Do not run cells or change existing cells. Do not use files,
storage, DOM APIs or network requests. Explain the expected
results so I can review the code.

Read the proposed explanation and the new summary_demo cell. Check that it generates the input using the stated rule and computes the summaries from that array. Run that cell yourself, then compare with the check below. The expected results are count 10, mean 9.3, minimum 1, maximum 20.

Check the input as well as the summaries

The seed fixes the sequence, so this random-looking input is reproducible. With the update-before-draw rule above, expect:

Input: [1, 11, 15, 6, 8, 4, 20, 11, 11, 6]
Count: 10
Mean: 9.3
Minimum: 1
Maximum: 20

Output labels may differ, but the numbers should match. Running the cell again should produce the same input and summaries. A different seed changes the exercise; this small generator is for a reproducible demonstration, not security-sensitive randomness.

Actual Android Galaxy S24+ screenshot showing part of the reviewed JavaScript summary_demo source and its seeded output: input 1, 11, 15, 6, 8, 4, 20, 11, 11, 6; count 10, mean 9.3, min 1, max 20. — **Actual Galaxy S24+ Android screenshot of the seeded-vector exercise above.** GLM 5.3 Flash created the practice cells, paused at a four-step limit, and finished after one **Continue** press. The code was inspected and run manually—not automatically by the agent—and produced the expected input, count 10, mean 9.3, minimum 1 and maximum 20. A second manual Run reproduced the same results. The screenshot shows the output and part of the source; scroll up in the cell to inspect its seed and first lines.

Before Send: the Assistant includes the selected conversation and a bounded preview of the current workbook's cells (up to the first 500 characters of each cell, plus metadata). Allowed tools can send more. Turning source browsing off does not stop workbook previews from being sent. That is different from the smaller current-cell payload used by completion below. Planned workbook-context changes are described in the appendix.

Paused with a Continue button? Agent limits (per run) → Max steps, highlighted below, controls the step allowance for one bounded run. The agent may reach that limit before finishing. Read what it has already done, then press Continue if the task is unfinished and you want another bounded run. Continuing can incur more API charges; it is not needed after Done.

AI Settings scrolled to execution and permissions. Yellow borders identify **Auto-run cells created by AI** and **Allow source browsing** (both unchecked), **Agent writes → Active worksheet**, **Max steps** under **Agent limits (per run)**, and **Security Level → Open**. This **browser capture predates the execution-consent update**; it is not a provider request or a security test. Its Open label describes the older defaults and is longer than the narrow dropdown can display. The upcoming approval and override dialogs are not pictured.

Step 4 · Request alternatives when you want them

Ask for API-based completions

Open Menu → Completion, then choose Section → AI suggestions (online). Set AI suggestions → On tap.
Keep Completion model → Follow AI Assistant to inherit its provider, endpoint and model. Or choose Choose provider and model, select a saved provider/endpoint and a low-cost model suited to short suggestions. No key is entered on this screen; Open AI Settings lets you add one first.
Open this section's Advanced to inspect the reply timeout and spending guards. Defaults are 6 seconds, $0.25/day and $5/month. Check prices before increasing them.
Return to a JavaScript editor and enter this practice snippet:
```
const values = [12, 15, 18];
const average = 
```
Leave the caret after the unfinished const average = line. Tap … at the end of the suggestion row, use the …AI extra key, or press Ctrl + Shift + Space.
Review the first request's actual payload and destination before sending it. AI chips carry a ✦ marker. Tap one to accept it; a truncated or multi-line chip opens a preview first. Review the resulting source before Run.

Pro browser online completion screen with On tap and Choose provider and model, explaining that no provider keys are saved and offering Open AI Settings. — A deliberately **keyless browser capture** of the independent-model controls. Its warning is real: without a saved key and valid destination, nothing can be sent. Your configured provider and model appear here after Step 2.

Lower composer detail from an Android Galaxy S24+ screenshot: the unfinished JavaScript average expression has two truncated AI chips, values.reduce and eval(values, each marked with a star. — **Detail view of an actual Galaxy S24+ Android screenshot after a real completion request.** Completion used **Gemini 3.5 Flash-Lite via OpenRouter** while the Assistant stayed on **GLM 5.3 Flash**. The two ✦ chips are truncated; outputs vary, so inspect the preview before accepting.

Choose the code, not just an AI chip. In this request, the first chip proposed values.reduce((a, b) => a + b, 0) / values.length;. Tap it to inspect the full preview: it sums the array and divides by its length, giving 15 for this example. The second proposed eval(values.join(' + ')) / values.length;. Reject that unnecessary eval alternative: calculating a mean does not need to turn a string into executable code. Check your own returned code before accepting it, and Run only after review.

**The full code preview on a Galaxy S24+.** A new Gemini Flash-Lite request returned the same `reduce` expression. **Accept only through a line:** for a multi-line suggestion, tap or click the last line you want. This immediately inserts everything from the first line through that line, leaving later lines out. **Insert all** accepts the whole suggestion; **Cancel** inserts nothing. This example is one code line, even though it wraps on screen, so tapping it accepts the whole expression. Accepting edits the source; it does not Run the cell.

The request asks for up to five alternatives, but your screen may fit fewer. Another tap first pages through already-received alternatives; once those are exhausted it can request more. Tap while the request spins to cancel it. Later replies are dropped when the timeout expires, and typing or moving the caret makes old suggestions stale.

Independent means independent: a separate completion choice stays separate when you change the Assistant's model. This is useful when you want a capable agent but inexpensive autocomplete. Following the Assistant inherits its identity, not its conversation or agent permissions.

Know what you are paying for and sending

Online completion is on demand: ordinary typing sends nothing. Prefetch while I type is not yet available in this workflow. Completion sends bounded current-cell context: at most 1,500 characters before the caret, 200 after it, and up to 12 local names—not the Assistant chat or entire workbook. Secret masking is best-effort, so review the payload yourself.

Always allow grants standing consent for that destination; a provider, endpoint or model change asks again. Send without asking initially arms that choice but still shows the first real payload once. Keep Ask each time while learning.

The day/month amounts are completion-only soft spending guards, not guaranteed provider billing caps and not the budget for Assistant or AI Prompt requests. Failures and cancellations can retain their reserved charge. Clear spending history does not reset cap totals. A model with no listed price needs explicit input/output price ceilings, or the app refuses to send.

Step 5 · Optional Android download

Try the on-device model

The optional Qwen2.5-Coder 0.5B model suggests code locally when the tables are unsure. It is a small code-completion model, not a replacement for the conversational agent. Once installed, inference sends no typed code to a provider and has no API charge.

On a qualifying Android phone with Pro installed from Google Play, open Menu → Completion → Section → Local model (on device).
Tap Install and allow time and storage for the approximately 400 MB download. Current sideloaded installations cannot download the model through this flow.
When ready, keep Use local model → When unsure. Tables answer easy cases; the model contributes when they are uncertain. Always runs it more often; Off stops it without deleting the download.

**Local model settings on a Galaxy S24+.** Yellow borders locate the section picker, the model's **Ready** status, and **Use local model → When unsure**. This phone already has the model, so **Delete** appears instead of **Install**; you do not need to delete it. This debug-build picture shows the settings, not a test of Google Play delivery.

Return to a code cell and pause at an unfinished name or line. Results vary with context; not every pause produces a suggestion. Accept an appropriate ghost or chip, inspect the source, then Run separately.

Which phone is comfortable?

Minimum eligibility is 64-bit ARM Android with at least 4 GB of RAM, not a promise of smooth performance. A Galaxy S24+-class phone is a practical comfort target: Samsung lists 12 GB of RAM for the S24+, leaving more headroom for the app, kernels and model. This is a recommended performance level, not a requirement to buy that model. Samsung's S24-series specifications.

A Galaxy S10+ has qualifying 8 GB or 12 GB variants. The maintainer's informal experience is that local completion can work there but feel slower than API completion; the comparison depends on the model and network. The recorded local-engine benchmark did not measure the S10+, so this is not a measured speed comparison or a guarantee for every handset. Watch for lag or an unresponsive app when combining the model with large workbooks and memory-heavy kernels. Samsung's S10-series specifications.

The earlier S24+-class native-engine test measured a warm first-word median around 0.10 seconds and a cold first-word median around 0.24 seconds, after loading. These are sample benchmark results, not guarantees: an uncached initial load took several seconds. The loaded model added roughly 460–490 MB of app-process memory, in addition to the WebView, Python/R runtimes and the operating system.

If an older phone becomes sluggish: set Use local model → Off and use tables or on-tap API alternatives instead. Under local Advanced, setting Keep loaded after leaving the app → 0 releases it when you leave; the idle-unload and low-battery controls also help. Save/export your workbook before troubleshooting. A no-API-cost model still uses storage, memory and battery.

Step 6 · Understand the code as you build it

Finish with a focused AI Prompt cell

The Assistant is useful for multi-step work. An AI Prompt cell is better for a small, repeatable question about a particular piece of code: it makes one isolated request, without Assistant history or tools. Use it to ask why a calculation works before extending it.

Here we return to Step 3's seeded-random summary_demo cell. We ask for an explanation of that existing calculation—not another random array, and not Step 4's average-only completion example.

Add an AI Prompt cell immediately after Step 3's summary_demo JavaScript cell—not the average-only snippet from Step 4—so the question below matches the selected source. Keep the cell type as Code, then choose AI Prompt from the language/mode dropdown. If it is absent, enable it under Menu → Languages & modes.
Paste the prompt below into the AI Prompt cell, not the Assistant's message box. Open its Configure control.
```
Explain the selected JavaScript cell line by line.
How do the generator rule and seed 42 determine its input array?
Why should it report count 10, mean 9.3, minimum 1 and maximum 20?
Why does resetting the seed make the result repeatable?
Explain what needs changing for an empty array.
Return a short explanation only; do not rewrite the code.
```
New-cell composer

Before the cell is saved: choose AI Prompt (shown as AI) and tap the composer's highlighted Configure. It configures the new prompt you are writing.
View the full composer screenshot

Existing cell while editing

For an existing cell: tap that cell's header Configure. It stays available while you edit the prompt. Both buttons open the same configuration dialog; changing settings alone sends nothing.
View the full cell-edit screenshot
Set Put final response in → This cell's output, the default. Under Context to send → Include source from, choose Previous 1 cell. Uncheck Include saved output text for this source-only exercise. Check that Context preview names summary_demo, then scroll down and tap Save configuration.

The dialog opened by Configure. Yellow borders locate the response destination, Previous 1 cell and the unchecked saved-output option. Send only the preceding summary_demo source. Previous 1 cell means the immediately preceding cell in workbook order; it does not search by name.
View the full configuration screenshot
Scroll down in the dialog to reach Save configuration.

View the full scrolled dialog screenshot
Tap the AI Prompt cell's Run. Check the selected context in the review, then choose Send to AI provider. Read the explanation alongside the source and compare it with the known results.

**A real GLM 5.3 Flash explanation on the Galaxy S24+.** One source-only request produced this reply in the AI Prompt cell's output; it did not change or re-run the JavaScript cell. The picture shows the beginning of the explanation. Scroll the output to continue, and check the answer against the source and Step 3's expected results—an AI explanation is not a correctness guarantee.

A way to control API costs and improve understanding. A focused AI Prompt can send less context than a growing agent conversation and avoid a multi-step tool loop, reducing input tokens and potentially the bill. Ask for concise reasoning, assumptions and expected output as you code. Savings are not guaranteed: model rates, response length, reasoning tokens and your chosen context still matter. These requests use the Assistant's provider/model, not the independent completion model, and are outside the completion spending guards.

Another example · Review a plot before replacing a cell

Now ask an AI Prompt to write code into a different cell, with a review before anything is replaced. We will plot how estimated variance changes across many small samples. These are fresh normal samples—not the earlier summary_demo integer array. The goal is to learn Configure → preview → Apply → Run, not to master the statistics.

Variance is not Student's t. For independent normal samples of size 10, 9s² / σ² follows a chi-square distribution with 9 degrees of freedom. Here the true variance σ² = 1. Student's t instead describes the standardized sample mean (mean − μ) / (s / √10), using the estimated standard deviation s; it also has 9 degrees of freedom here. NIST: variance · NIST: mean.

In the practice workbook, create a JavaScript cell containing // Reviewed plot code will go here. Run that harmless comment to save the cell. Long-press its In[…] label and name it variance_plot. Keep that name unique in the workbook; see naming cells.

Add a separate AI Prompt cell and paste this request into it:

Return only complete JavaScript source, without Markdown fences.
Create a reproducible histogram of estimated sample variances.
Simulate 2,000 fresh samples, each containing 10 standard-normal N(0,1) values.
Do not reuse the earlier integer array from summary_demo.
Initialize state = 42 once for the whole run, not per sample. Before each uniform draw set state = (16807 * state) % 2147483647, then u = state / 2147483647.
For each normal draw use two successive uniforms: sqrt(-2 * log(u1)) * cos(2 * PI * u2). Do not reuse the spare sine result or use Math.random.
For each sample compute its mean, then unbiased variance sum((x - mean)^2) / 9.
Draw a labelled canvas histogram with 40 equal-width bins from 0 to 4. The horizontal axis is estimated variance; the vertical axis is sample count.
Mark the true population variance 1 with a labelled vertical line. Use a light background, dark text and readable labels.
Print sample size, repetitions, seed, mean estimated variance, histogram total and any overflow count. Count overflow separately rather than hiding it.
Display the canvas with window.renderImage(canvas.toDataURL("image/png")).
Use no packages, network, storage or workbook edits.

Open the AI Prompt's Configure. Set Put final response in → Replacement preview for a cell, Result cell language → Preserve target language, Cell to replace → Named cell, and Cell name → variance_plot. Under context, keep Include source from → No other cells (default), then Save configuration.

Replace only after review. These actual S24+ settings select the uniquely named JavaScript cell variance_plot, preserve its language, and omit other cells. Scroll down to Save configuration. Saving alone sends nothing; the next Run still presents the request for review.
View the full replacement-settings screenshot
Run the AI Prompt cell. Review what will be sent, then choose Send to AI provider. No other cells excludes extra workbook context; replacement still sends the complete source of the target cell. That is only our harmless comment here.
Read the returned Before / After preview. Check the complete JavaScript: seed 42, 2,000 samples of 10, variance divided by 9, and no unexpected networking or storage. Choose Apply replacement only if you accept that source; Cancel leaves variance_plot unchanged. Applying edits the destination cell but does not run it.

The generated code is in the approval preview. This is the start of the actual GLM 5.3 Flash response; the target still contains only our comment. Read the whole After section, not just the lines shown here.
View the full start-of-preview screenshot

Scroll to the end to approve or cancel. Apply replacement changes the named cell's source; it does not execute it. The middle of this long preview is omitted from these detail views. Read the complete generated source.
View the full approval-controls screenshot
Review caught a small omission. This model response ended with a report string rather than printing it. After Apply, we edited only that final report into console.log(…) before Run. Check your response too: an image alone does not show whether the totals are right. Read the corrected source that was run.

Find variance_plot and tap its own Run. Each histogram bar counts sample-variance estimates—not individual observations. With the exact generator above, expect a mean estimated variance near 0.9852, a histogram total of 2,000 and overflow 0. The true variance is 1; a finite simulation need not average to exactly 1. Re-running from seed 42 should reproduce the plot.

Output after Apply, review, and a separate manual Run on the S24+. The actual plot and printed checks match the seeded calculation: mean estimated variance 0.98521, total 2,000, overflow 0. The red line is the population variance, not a fitted curve. Your model may format the code or chart differently.
View the full plot screenshot

Two separate approvals: Send to AI provider approves sharing the reviewed request. Apply replacement approves editing the target's source. Neither runs the proposed JavaScript. Do not choose A linked new cell for this demonstration: that option inserts an unrun result cell without this replacement-approval step.

If something does not work

No offline suggestions on a phone: Choose General → Local code completion → On rather than Auto. Check chips, caret position, language, and whether the optional row has room.
No online request: Check On tap, the saved key for the exact provider/endpoint, the selected model's price entry or ceilings, consent and spending totals. Open is not required for completion. A secure browser context and Web Locks are needed; unsupported contexts refuse requests.
The Assistant asks before running a cell—or does not ask: Check your app version, Security… execution permissions and Kernels… rules. The upcoming Open default is Ask; Pro 1.4.0's default can allow execution. Auto-run off is not an execution-tool Deny. Online completion's Always allow does not grant cell-execution permission; see execution approval.
The completion does not understand another cell: Online alternatives use bounded current-cell context, not your full notebook. Use an AI Prompt with explicitly selected source, or the Assistant, when you need broader explanation.
Install is unavailable: The native local-model flow is for eligible Android Google Play installs, not desktop/browser or current sideload delivery. Meeting the RAM minimum does not guarantee speed.
The generated answer looks plausible but wrong: Compare it against small known examples. Check imports, units, empty-input behavior and side effects before running. A model response is not a correctness proof.

AI setup and workflows reference · Remote and security · All tutorials

Appendix · Upcoming execution approval · proposed Pro 1.5.0

Unreleased: these controls describe the next-release implementation, not a promise that your 1.4.0 install has it. The release number is provisional.

AI Settings → Security… → execute_cell / run_cells already offers Default / Allow / Ask / Deny. This update changes Open's inherited Default to Ask; Full control keeps Allow. Explicit tool or kernel rules can replace inherited defaults; when both are explicit, the safer rule wins. Leave Default or Ask while learning. Allow is an override, not a stronger sandbox; kernel Ask/Deny, Review and the global JavaScript disable still apply.
Read the execution request before choosing Run; leave Allow future Assistant cell execution without asking unchecked to approve only that request. Checking it changes the shared execution-tool rule across all workbooks until reset—not just this cell, conversation or provider. An explicit kernel Ask hides that option.
Namespace-inspection and newly created-cell prompts cannot create that standing grant. A created-cell execution prompt includes a bounded code preview; a long preview ends with an ellipsis. If it is truncated, choose Cancel, inspect the newly created cell's full source, and Run it yourself only if you trust it. A previously saved execution Allow can still permit created-cell autorun when Auto-run is on, so keep Auto-run off here.
If you select a preset other than Full control while a saved execution-tool Allow remains effective, a warning offers Reset to Default, Keep Allow, or Cancel. Reset restores the selected preset's tool rule without clearing kernel overrides. Keep retains the override. Cancel restores the previous preset selection. Reset and Keep stay draft changes until you save Settings.

Execution approval is not blanket permission to share data. Execution-tool outputs can return to the Assistant's model, and permitted code can use networking. Online completion's Always allow, AI Prompt's context review, and Remote/MCP's privacy disclosure remain separate. MCP notebook execution uses the same execution checks; those checks do not sandbox a broker's Terminal shell.

Appendix · Planned workbook context and history

Design proposal only: these features are not implemented or assigned to a release. They are separate from the upcoming execution-approval changes above and do not block the current release.

Fetch a workbook summary when needed. The plan replaces repeated automatic source previews with a metadata-only directory tool: cell names, optional descriptions, languages and types, plus a workbook revision. The proposed tool is list_cells with view: "metadata"; the Assistant would read selected source separately. This is a bounded overview, not an automatically generated AI explanation.
Attach once rather than on every Send. A proposed Attach workbook summary this time checkbox could start checked for a fresh conversation and uncheck after that attachment is actually sent. You could uncheck it before sending or check it again for a fresh overview. Its initial default still needs privacy and usability review. Continuations would not add another summary, and switching tabs would not silently re-enable it. The preview and existing read/privacy permissions would still apply; a large workbook could require further pages.
Unchecked does not erase history. It would stop a new automatic attachment, not remove summaries already in the conversation or prevent allowed tool reads. Existing full-screen Agent, AI Prompt and completion context controls would remain separate.
Changes between sends are a later option. Compact updates would need a known sent-context baseline and reliable revisions. Human edits could be highlighted, but agent edits, imports and unknown changes also matter. A source edit would not automatically rewrite a cell's description; missing or stale history would need a fresh overview rather than a guessed update.
Optional local history and GitHub sync are longer-term Pro ideas. Local Send checkpoints could support Git-backed diffs without sharing anything. Independent sync could publish a workbook to a Gist or a chosen file in a repository, with its own payload preview and authorization. Enabling history would not push to GitHub or send a diff to the AI. Git shows content changes, not proof that a human made them.

A secret Gist is not private. Anyone with its URL can read it; use a private repository when access must be restricted. Keep secrets out of workbook source and descriptions before publishing. GitHub's Gist visibility documentation.