# Pize

> Pize is an AI coding assistant for scientific computing and statistical analysis. It runs in Pize Code and Positron, and also ships as an SDK.

## Start here

- [Home](https://pize.ai/): Product overview and research-coding workflow
- [Docs](https://pize.ai/docs): Plugin documentation for data reading, statistics, the runtime bridge, the SDK, MCP, and how they connect to AI / 人工智能
- [Docs (Markdown)](https://pize.ai/docs.md): English CommonMark of the plugin documentation, for models that prefer text over HTML
- [Download](https://pize.ai/download): Two sections — Pize software (not published yet) and catalog product manuals
- [Download (Markdown)](https://pize.ai/download.md): The same download page as CommonMark, for models that prefer text over HTML
- [Pricing](https://pize.ai/pricing): Credit packs for Pize Code and the SDK

## Product catalog

- [Products](https://pize.ai/product): Automated liquid handling and femtosecond lasers
- [Scientific applications](https://pize.ai/applications): Spectroscopy, microscopy, extreme light, source development, and fabrication

## Machine-readable files

- [llms.txt](https://pize.ai/llms.txt): This site card
- [llms-full.txt](https://pize.ai/llms-full.txt): Docs plus a catalog index
- [ai.txt](https://pize.ai/ai.txt): Same card under the older ai.txt name
- [robots.txt](https://pize.ai/robots.txt): Crawl policy, including named retrieval and training agents
- [sitemap.xml](https://pize.ai/sitemap.xml): Every public HTML URL
- [Atom feed](https://pize.ai/feed.xml): Public URLs as Atom, for feed fetchers

## What Pize is not

- Pize is not a generic Cursor replacement.
- The CLI is not available yet. Use the Pize Code extension or the SDK.
- Pize software is not published for download on this site yet.

## Full documentation

# Pize plugin documentation

> Pize is an AI coding assistant for scientific computing and statistical analysis. It runs in Pize Code and Positron, and also ships as an SDK.

Pize is an AI coding assistant for scientific computing and statistical analysis. It runs in Pize Code and Positron, also ships as an SDK, and puts its effort on the step that fails most often and is cared for least: recognizing and reading statistical data. Once the data is understood correctly, the computation, tests, and inference that follow can be right.

## Say what Pize does, then say what it does not

Most programming agents spend their effort writing more code. Failures in statistics and research usually happen earlier: if the data is read wrong, every later test, model, and inference quietly inherits the error. Pize puts its effort there — first make the model know the shape, types, and missingness, then write, run, read plots, and correct in the R / Python session you already use.

It is also a complete programming agent: cross-file edits, the terminal, plan and act, project rules, a choice of models, and MCP to reach tools that already live in a lab or an internal system. The CLI is not open yet. What you use now is the editor plugin, or the same agent embedded in your own program.

- **What it is.** A programming agent optimized for mathematical computing and statistical analysis. Reading, computing, and testing happen in a live session. Results can be recomputed.
- **What it is not.** Not a reskin of a generic completer, and not a Cursor stand-in that writes a bit of everything. The effort is not completion. It is reading the data right and getting the numbers straight.
- **Where it runs.** Pize Code, Positron, and the SDK. The CLI is not available yet.
- **What the model is given.** Structure, types, missingness, and summaries — not the whole table stuffed into context. Raw observations stay in the session.

### Three doors, one agent

In the editor it is a sidebar plugin. In your own tools it is an SDK. To a database, an instrument program, or an internal knowledge base, it goes through MCP. All three call the same read logic, the same computation, and the same approval boundary.

## An SDK is a kit another program can call, not another website

An SDK (software development kit) packages APIs, types, and examples so another program can call your capability without implementing that capability again.

Without an SDK, each integration writes its own HTTP and guesses at fields. With one, the caller gets stable function names, types, and an example that actually runs. Embedding a model in a lab acquisition program or an internal analysis platform is this layer.

- **What it gives.** Callable interfaces, types, and the smallest example that runs. The caller does not reinvent reading data or the session.
- **What it does not give.** It does not replace your product UI, and it does not choose the statistical method. The method still comes from the model and your confirmation.
- **How it differs from the plugin.** The plugin opens in the editor. The SDK embeds the same agent in a program you already use, without another sidebar.

### What the Pize SDK does

Pize packages data reading, the session bridge, and the programming agent so they can be embedded. A lab tool or an internal program does not need another editor window for the model to compute on real data and change things after you confirm.

## MCP is a plug, not another model

MCP (Model Context Protocol) is an open protocol: it lets a model reach external tools, data, and prompts at runtime, without a private wire for every source.

A model only reasons. It cannot see your database, and it cannot touch parameters inside instrument software. MCP names three things: tools (actions it can call), resources (data it can read), and prompts (instructions it can reuse). Whoever implements that contract can be used the same way.

- **What it solves.** Model and external system no longer each invent a private plug. Databases, knowledge bases, and internal gateways can be reached by one protocol.
- **What it is not.** It is not a model, and it is not an SDK. It does not decide how you embed the agent in your own program. It only says how the running agent attaches outward.
- **Inside Pize.** Pize acts as a client to other MCP servers. The safety boundary is still your approval: read-only by default; actions wait for you.

### Do not mix this with the SDK

The SDK answers “how do I embed Pize in my program”. MCP answers “how does the running agent reach tools and data I already have”. One embeds. The other attaches.

## The model thinks, the SDK embeds, MCP reaches

For an AI system to get the numbers right in research, the missing piece is rarely “a larger model”. It is whether the model can see real data, move real tools, and live inside software you already use.

Pize keeps these three layers apart and also joins them. The model chooses a method and writes code. The SDK puts that agent inside your tools. MCP lets it reach libraries, instrument software, and internal systems at runtime. Reading still comes first: if the data is wrong, the other two layers only carry the error farther.

| Layer | What it does | In Pize |
| --- | --- | --- |
| Model | Reason, choose a method, write code | Any provider you connect, or a local model |
| SDK | Embed the agent in a program you already have | The same reading, computation, and approval as the editor plugin |
| MCP | Reach external tools and data at runtime | Acts as a client; read-only by default; actions wait for you |

The order does not change: read it right, then embed, then attach outward. Reverse any layer and the numbers that follow cannot be trusted.

## Why “reading it right” is the premise of statistical skill

Statistical errors rarely show up as crashes. A wrong delimiter shifts every column; treating the first row as a header deletes the first observation; NA and NULL become 0 and the mean and variance move; a numeric column typed as text is treated as a factor in a regression. None of this stops the program. It quietly gives you a plausible wrong number — and because the error happened at read time, every later test, model, and inference inherits it.

So Pize is not optimized to make the model write more code. It first makes the model know the shape of the data, the type of each column, how much is missing, and roughly how many rows — then write the computation and modeling code, and run it in your real session so you can see it.

## Recognizing and reading statistical data

Format detection looks at the content, not the extension — in research data a .txt often holds a table, and a .csv is often three lines of config. Each decision below directly decides the numbers that come later.

- **Delimiter detection.** Tab, comma, semicolon, or pipe: pick one. Rows must have a stable column count, and fields must look like cells, so prose that uses a comma in every sentence is not treated as a two-column table.
- **Header or data.** If the first row still has digits in numeric-column positions, it is an observation, not a column name — eating the first observation as a header is the classic way to lose one sample.
- **Missing values stay out of type inference.** Empty strings, NA, NaN, and NULL are recognized on their own; otherwise a column of empties is typed numeric and the model is invited to summarize numbers that are not there.
- **Per-column type inference.** Numeric / text / empty, column by column. This step decides whether a column can enter a mean, a variance, or a regression.
- **Comments and metadata are stripped.** Leading blocks that start with #, !, or @XX come off first. VCF hides column names in the last comment line; those names are recovered so the columns have names to use.
- **Compressed tables are read transparently.** .gz is decompressed automatically; size is judged after decompression — a 1 MB archive can hold a 20 MB table.
- **Row-count estimate.** Total rows are estimated from the byte share of the prefix already read, and the figure is labeled as an estimate so it is not reported as fact.
- **Over-budget files get a data card, not an error.** When the context budget is exceeded, Pize returns size, delimiter, estimated rows, column names with inferred types, and the first two rows. The model writes the right read code from that card; a million-row table does not eat the context.

### Binary containers used in statistics and research

Statistical data is often not plain text. Attach Parquet, Feather, Arrow, RDS, RData, h5ad, Loom, HDF5, NumPy, SPSS (.sav), Stata (.dta), SQLite, or DuckDB, and Pize no longer answers “cannot read binary files”. It reports the format name and how to open it (for example readRDS, anndata.read_h5ad) so the model writes the right read code. PDF, DOCX, XLSX, and notebooks go through text extraction and are readable the same way.

## Compute on real data, not on a guess

Reading comes first, then computing. Pize does not invent statistical methods for you. It makes sure the model faces your real data, and that you can see every step.

- **Choose the method from the real distribution.** The model gets row count, column count, types, missing counts, and summaries, and uses them to decide parametric vs nonparametric, whether to transform, and how to handle missingness.
- **Write it, then run it.** Generated R or Python runs in the current session after you confirm. What comes back is real output, not the model imagining a result.
- **Diagnose from plots.** The latest plot can be retrieved — QQ plots, residual plots, distribution plots that you can only judge by looking. The model can take part in that judgment.
- **Closed iteration.** Run, read, correct, all in the same session. Intermediate variables are not lost because a new process started.
- **Aggregates only, never raw rows.** Table summaries return structure and statistics. Raw observations stay in the session.

## Positron runtime bridge

The truth of an analysis is not in the file. It is in memory. The bridge reads the R or Python session you currently have focused, through Positron’s public extension API. It never creates or switches a runtime. It only uses the one you are already using.

### Read, summarize, execute, fetch plots

| Tool | Role | Approval |
| --- | --- | --- |
| `get_session_context` | Read session language, status, and the variable list (metadata only) | Read class |
| `inspect_variables` | Inspect a variable’s structure and a truncated preview by name | Read class |
| `summarize_table` | Row/column counts, types, missing counts, and summaries for a data frame | Read class |
| `execute_code` | After you confirm, run statistical code in the current session | Command class, off by default |
| `get_current_plot` | Fetch the latest plot for the model to see | Command class, off by default |

The safety boundary is part of the design: every call re-checks that the session is still in front — if you switched away, it is refused; output volume, variable count, preview length, and image size have hard caps; raw data rows, console history, and secrets are never returned. In ordinary Pize Code these five tools disappear on their own.

### Attachments come from the editor buffer

The attachment chips under the input read the editor buffer, not the stale file on disk — the script or data you just changed and have not saved is exactly what the model sees. Duplicate attachments of the same content are de-duplicated by hash.

## It is also a complete programming agent

Reading and the bridge are the layer it adds. What follows is the complete programming agent it also is — without these, the statistical loop does not turn.

- **Cross-file edits and diff review** Coordinated edits across files. Every edit is a reviewable, undoable diff, and a whole task can be rolled back.
- **Terminal execution and live output** Run commands in the integrated terminal and read output live. Errors and test failures are caught immediately.
- **Plan / act modes** Survey the data and code first, agree on an analysis plan, then act, so the wrong model is not run on the first try.
- **Context references and browser debugging** Feed context precisely with @file, @folder, @problems, @url. It can also drive the browser, take screenshots, and read logs to locate a problem.
- **Project rules and skills** Put statistical definitions, plotting conventions, and directory rules in a rules file so every teammate’s session follows them.
- **Model choice and MCP** Anthropic, OpenAI, Gemini, DeepSeek, Bedrock, OpenRouter, and local models can all be connected. Databases can be reached through MCP.

## The read logic is verified, not believed

- **Recognition is regressed on generated corpora.** Labeled samples are generated across 31 file shapes, ten thousand at a time, and run through the detector: the first pass failed 458 cases, exposing four defect classes that were fixed one by one. The random seed is fixed, so the same inputs can re-check the fix.
- **Tripwire tests at every join.** Every join to upstream code has a test. If a merge drops one wiring line, the test goes red — the feature does not fail silently under a green suite.
- **The full checklist on every merge.** Thousands of unit tests, two type-checkers, repo-wide lint; after packaging, the artifact is unpacked to confirm the behavior is actually in the bundle.
- **One-click self-check.** The bridge check in the command palette really reads a session. A pass means the tools reached real data.
- **Coexists with the official build.** Shipped under a separate extension id, so it can be installed beside the upstream plugin without overwriting it.

Architecture has one rule that runs through everything: new behavior always goes in new files; upstream files are touched only at the call sites that need them. That is why a merge covering ten upstream commits can conflict on a single line — it can keep following upstream, instead of shipping once and stopping.

## Answer these seven questions first

### What is Pize?

Pize is an AI coding assistant for scientific computing and statistical analysis. It runs in Pize Code and Positron, and also ships as an SDK.

### What is an SDK, and does Pize have one?

An SDK is a set of callable interfaces, types, and examples used to embed a capability in another program. Pize ships an SDK: the same reading and the same agent, not only inside the editor.

### What is MCP, and does Pize support it?

MCP is an open protocol for a model to reach external tools and data. Pize acts as a client to MCP servers. Databases and internal gateways can be reached through it. Read-only by default.

### How do the Pize SDK and MCP work with an AI model?

The model reasons. The SDK embeds the agent in your product. MCP lets the agent reach real tools and data at runtime. Pize does all three, and puts reading the data in front of them.

### Where does Pize run?

Pize Code, Positron, and the SDK. The CLI is not available yet.

### Is Pize a Cursor replacement?

No. It is aimed at mathematical computing and statistical analysis. The effort is reading data and computing in a live session, not becoming a generic “write a bit of everything”.

### What data can Pize read?

It detects delimiters, headers, missing values, and column types from the content. Beyond text tables it reports how to open containers such as Parquet, RDS, h5ad, SPSS, and Stata. Over-budget files get a data card. The whole table is not stuffed into context.

## Four steps: from one dataset to one conclusion

Install the plugin, connect a model, give it the data. What remains is rounds of write-code, run-results, read-plots, and correct.

1. **Install the plugin** Install the extension in Pize Code or Positron. The Pize icon appears in the sidebar.
2. **Connect a model** Enter an API key from any provider, or point at a local model and a self-hosted endpoint.
3. **Give it the data** Attach the current data file, or in Positron focus a session that already has data loaded.
4. **Plan, then act** Align the analysis plan in plan mode. After you confirm, let it write code, run results, and correct from the plots.

Positron tools appear only inside the Positron host, and they are read-only by default. Code execution and plot fetch are command-class approvals and must be turned on explicitly. Row counts are estimates and summaries come from the runtime; both are labeled with their source in the result.

## Catalog index

### Product lines

- [AMTK](https://pize.ai/product/amtk): Automated liquid-handling workstations and sample-preparation systems for nucleic-acid extraction, NGS library construction, and plate-based assays.
- [Light Conversion](https://pize.ai/product/lightcon): Yb femtosecond lasers, wavelength-tunable OPAs, OPCPA systems, spectroscopy instruments, and microscopy sources for scientific research.

### Instruments

- [LH-1209 · AMTK](https://pize.ai/product/amtk/lh-1209): A 96-channel automated liquid handler for magnetic-bead nucleic-acid extraction and purification. The open 25-position deck holds thermal, shaking, and magnetic modules for 96–192 samples per run.
- [LH-1406 · AMTK](https://pize.ai/product/amtk/lh-1406): A compact open-deck liquid handler with interchangeable 1- to 32-channel heads. Twelve positions support plate-to-plate and tube-to-plate work, with optional blood-separation, PCR, thermal, and magnetic modules.
- [LH-1808 · AMTK](https://pize.ai/product/amtk/lh-1808): A 30-position fully automatic liquid handler for tube-to-plate and plate-to-plate work, including primary-tube loading through qPCR setup. Interchangeable 1- to 32-channel heads cover 0.5–1000 μL.
- [iLab-100R · AMTK](https://pize.ai/product/amtk/ilab-100r): A compact automated sample-preparation system with a 12-position deck. Interchangeable heads from 1 to 32 channels cover tube-to-tube, tube-to-plate, and plate-to-plate transfers, with HEPA and UV protection.
- [iLab-200R · AMTK](https://pize.ai/product/amtk/ilab-200r): A 30-position automated sample-preparation system for larger batches. One deck layout can run a full method sequence with interchangeable 1- to 32-channel heads and HEPA plus UV protection.
- [iLab-300R · AMTK](https://pize.ai/product/amtk/ilab-300r): A high-throughput automated sample-preparation system on a 30-position deck. 96- and 384-channel heads run NGS library construction for 96 samples or magnetic-bead cleanup for 384 samples in one pass.
- [CARBIDE · Light Conversion](https://pize.ai/product/lightcon/carbide): A compact Yb femtosecond laser for industrial and scientific work. Water-cooled models reach 120 W and 2 mJ; pulse duration tunes from 190 fs to 20 ps at rates up to 10 MHz.
- [PHAROS · Light Conversion](https://pize.ai/product/lightcon/pharos): A multi-millijoule Yb femtosecond laser with pulse durations down to 100 fs, pulse energy up to 5 mJ, and average power up to 20 W.
- [FLINT · Light Conversion](https://pize.ai/product/lightcon/flint): A high-repetition-rate femtosecond oscillator for microscopy and seeding. Models reach 20 W, 0.5 µJ, and pulse durations down to 50 fs.
- [I-OPA · Light Conversion](https://pize.ai/product/lightcon/i-opa): An industrial-grade OPA built onto CARBIDE and PHAROS heads. The sealed layout keeps wavelength tuning stable in factory and lab environments.
- [ORPHEUS · Light Conversion](https://pize.ai/product/lightcon/orpheus): A Yb-pumped OPA for spectroscopy, microscopy, and materials work. Extensions cover 190 nm to 16 µm with short, high-contrast pulses.
- [ORPHEUS-HE · Light Conversion](https://pize.ai/product/lightcon/orpheus-he): A high-energy ORPHEUS that accepts pump pulses up to 5 mJ and tunes from 210 nm to 16 µm for demanding spectroscopy and nonlinear optics.
- [ORPHEUS-NEO · Light Conversion](https://pize.ai/product/lightcon/orpheus-neo): A next-generation OPA with continuous power monitoring and onboard diagnostics for automated, long-term operation from 210 nm to 16 µm.
- [ORPHEUS-MIR · Light Conversion](https://pize.ai/product/lightcon/orpheus-mir): A broad-bandwidth mid-infrared OPA for vibrational spectroscopy and MIR nonlinear optics.
- [ORPHEUS-VIS · Light Conversion](https://pize.ai/product/lightcon/orpheus-vis): A broad-bandwidth visible OPA that delivers ultrashort VIS pulses for spectroscopy and imaging.
- [ORPHEUS-N · Light Conversion](https://pize.ai/product/lightcon/orpheus-n): A non-collinear OPA for pulses shorter than 50 fs, and below 30 fs in some configurations, when the experiment needs shorter pulses than the pump.
- [ORPHEUS-PS · Light Conversion](https://pize.ai/product/lightcon/orpheus-ps): A narrow-bandwidth OPA with picosecond-class pulses for experiments that need spectral resolution more than the shortest pulse.
- [TOPAS-PRIME · Light Conversion](https://pize.ai/product/lightcon/topas-prime): A Ti:Sapphire OPA with hands-free tuning from 1160–2600 nm, extendable to 189 nm–20 µm, for 0.15–6 mJ pumps.
- [TOPAS-PRIME-HE · Light Conversion](https://pize.ai/product/lightcon/topas-prime-he): A high-energy TOPAS for 2–60 mJ Ti:Sapphire pumps, keeping broad tuning and high conversion efficiency.
- [TOPAS-TWINS · Light Conversion](https://pize.ai/product/lightcon/topas-twins): Two independently tunable OPAs seeded by one white-light source, with optional CEP-stable outputs for two-color experiments.
- [ORPHEUS-OPCPA · Light Conversion](https://pize.ai/product/lightcon/orpheus-opcpa): A compact tabletop OPCPA that delivers few-cycle, CEP-stable pulses above 1 mJ and 100 GW peak power at rates up to 1 MHz.
- [OPCPA-HE · Light Conversion](https://pize.ai/product/lightcon/opcpa-he): A multi-TW OPCPA for extreme-light work: more than 250 mJ, pulse durations below 9 fs, and peak power above 25 TW at 1 kHz.
- [HARPIA-TA · Light Conversion](https://pize.ai/product/lightcon/harpia-ta): A compact transient-absorption spectrometer for UV to MIR pump–probe work, with modules for fluorescence, multi-pulse, and flash-photolysis measurements.
- [HARPIA-LIGHT · Light Conversion](https://pize.ai/product/lightcon/harpia-light): A compact transient-absorption instrument with continuous scan mode for day-to-day ultrafast spectroscopy on a small bench.
- [HARPIA-TG · Light Conversion](https://pize.ai/product/lightcon/harpia-tg): A transient-grating spectrometer for time-resolved third-order nonlinear measurements in a compact HARPIA module.
- [CRONUS-2P · Light Conversion](https://pize.ai/product/lightcon/cronus-2p): A high-repetition-rate tunable source for two-photon microscopy, optogenetics, CARS, and SRS, with one or two tunable beams plus a fixed 1025 nm output.
- [CRONUS-3P · Light Conversion](https://pize.ai/product/lightcon/cronus-3p): A single-box source for three-photon microscopy: microjoule pulses tunable from 1250 to 1800 nm, durations down to 50 fs, and automated GDD control.

### Scientific applications

- [Ultrafast spectroscopy](https://pize.ai/applications/ultrafast-spectroscopy): Transient absorption, time-resolved fluorescence, femtosecond stimulated Raman, transient grating, sum-frequency generation, TR-ARPES, two-dimensional electronic and infrared spectroscopy, flash photolysis, and Z-scan.
- [Advanced microscopy](https://pize.ai/applications/advanced-microscopy): Transient absorption microscopy, nonlinear microscopy in biological tissues and solid-state materials, ultrafast electron microscopy, and Raman microscopy (CARS & SRS).
- [Nonlinear and extreme light generation](https://pize.ai/applications/nonlinear-extreme-light): High harmonic generation, nonlinear optics, X-ray generation, and THz generation.
- [Laser source development](https://pize.ai/applications/laser-source-development): Laser pumping and seeding, carrier-envelope phase stabilization, repetition rate locking, and optical parametric chirped-pulse amplification.
- [Micro- and nanofabrication](https://pize.ai/applications/micro-nanofabrication): Photopolymerization, surface nanostructuring, color center formation, volume modification, and laser-tissue interaction.
- [High-throughput liquid handling](https://pize.ai/applications/high-throughput-liquid-handling): Plate-based pipetting for nucleic-acid extraction and assay setup on automated workstations.
- [NGS library preparation](https://pize.ai/applications/ngs-library-prep): Automated library-construction workflows from purification through quantification.