Release notes

What changed in each release of LatticeMind, newest first.

LatticeMind 0.5.1

Released 25 September 2026

  • In the browser, a figure you ask LatticeMind to draw, such as a structure view, appears in the conversation and in the Control room, as the standard plots do.

  • Before a plotting or analysis script runs, the permission question shows the whole script with numbered lines, in the browser and in the terminal, next to any line the safety check flagged.

  • VASP band structures and densities of states can start from a large parent density, such as a spin-polarized slab at a high cutoff, and run evidence reports the magnetic moment of every atom.

  • NanoDCAL transmission and density-of-states runs have their own evidence: the transmission at the Fermi level, its plateaus and, for a device that repeats one cell, a check that the transmission is a whole number of channels. Projected densities of states, one- and two-dimensional leads and precise electrode cells are written correctly, and a refused device or parent says what it expected.

  • A failed run reports the solver’s own error lines.

  • Structures written by an analysis script are saved under results/analysis/, and a structure read from a file reports its bonding: coordination, bond lengths, separate fragments and unusual atoms.

  • Long conversations about large structures (hundreds of atoms) keep their room: project summaries show a large structure’s size and composition instead of every coordinate.

  • On Windows, background work no longer opens console windows.

  • The offline package comes as one archive per platform.

  • The manual has a new tutorial that reproduces a published figure, the band structures of four two-dimensional altermagnets, with VASP, and new screenshots of the browser and the terminal.

LatticeMind 0.5.0

Released 23 September 2026

LatticeMind is now a conversation. You start it in the folder you want to work in, describe the calculation in a sentence, and answer one permission question before anything runs.

How you work

  • The research conversation is the default. You describe what you want, LatticeMind inspects what exists, does the next thing, reads the result, and decides what follows. You can correct it as it goes and pick the conversation up the next day. The old one-shot pipeline is still there as latticemind quick.

  • The folder you start LatticeMind in is the project. It keeps its records in a hidden .latticemind/ folder there and writes the solver inputs, pseudopotentials/, results/ and the figures into that same folder. A home, root, system or software folder is declined with a note asking you to change into a project folder first. LATTICEMIND_ARTIFACTS_DIR still overrides the location for automation. A second project started in the same conversation gets its own subfolder.

  • Running latticemind again in the same folder reopens the conversation with every result in place; /new starts a fresh one there.

  • /model switches the model, in the terminal and the browser. It lists the current models from the OpenAI, Claude, Gemini and Qwen APIs and a local Ollama, each marked configured or unconfigured. Pick an unconfigured one and LatticeMind asks for its API key and saves it to the .env file you use; each provider remembers its own model. Switching after the first message starts a fresh conversation in the same folder and keeps the earlier one.

  • /remote chooses where calculations run: your saved profiles and the hosts in ~/.ssh/config, a short wizard to add one (+ or /remote add), a connection test that checks SSH, file transfer and the solver command and uploads nothing, and /remote local to come back to this machine. Choose a profile and the solver runs on that host while the conversation and the model stay on your machine; each launch still asks. /remote setup and /remote warm set up SSH session reuse for two-factor logins, and latticemind --remote-profile <name> starts with a profile chosen. Conversations launch over direct SSH; Slurm stays with latticemind quick.

  • One status line updates in place while LatticeMind works — elapsed time, what it is doing, and the reminder that ctrl-c stops it or you can type to steer. Each completed step leaves one line behind. A message typed during a turn is read at the next step. ctrl-c offers to stop, to leave the work running, or to keep watching.

  • Below the status line an input line marked > shows what you type while LatticeMind works, so a correction is visible before you send it.

  • Once a launch is approved, the solver’s own output streams into the session as it is written – RESCU’s iteration log, NanoDCAL’s output, VASP’s OSZICAR – so you can watch a calculation converge without opening a log file. The full log stays in the run folder.

  • “Organise this folder into si_test” is one question and one answer: LatticeMind moves the files it published into that directory keeping their layout, removes the folders it empties, overwrites nothing and leaves its hidden record in place.

  • A conversation started under an earlier LatticeMind continues after an upgrade; the newer guidance is adopted on record with one line saying so.

  • latticemind-web is the same conversation in a browser, with a control room beside it: chat bubbles and one line per step, the permission question answered by button or by typing, the solver’s live output, and a second view showing the research agent, the current turn, permissions, tool activity, project files, solver runs and figures.

  • The browser’s top bar stays in place while you scroll and shows the Project, the Model, where runs go (Runs on) and who answers launch requests (Approvals). Click Model, Runs on or Approvals to change them, or type /model or /remote in the message box: the same pickers open, with a key field for an unconfigured provider and Test, Use and + Add a remote profile for remote hosts. Open… and New switch folders or start a fresh conversation. The earlier dashboard is still served at /classic.

  • A new installation is ready after two questions. latticemind setup asks which model to use and where RESCU is, offering the copy it finds, and saves the answers for the terminal and the browser. A first latticemind with nothing configured asks the same two questions; the browser setup screen shows what is ready and takes a missing key or path.

  • Answering a permission request once is enough. While LatticeMind picks the answer up, the browser closes the card and says it is resuming instead of asking again; a second yes in the terminal continues rather than re-asks.

  • The browser conversation keeps the newest message, step or solver line in view, just above the message box. Scroll up to read and it stops following and offers a small Latest button to return.

  • The permission question shows what will run and where, then offers 1. yes   2. yes, always   3. no. You can answer in words — yes, go ahead, run it, approve, no, cancel — as well as with the number or with /approve and /deny.

  • Approve-for-me (/approve-for-me on, or start with latticemind --approvals assessed) lets routine work go ahead and asks only about what can lose work. A prepared solver run of low or medium estimated cost, on this machine or on a saved remote profile, goes ahead, one run or a whole batch, and so does creating folders or empty files inside the project. Moving, copying or deleting files, writing into a file, reorganising the folder, running a program or analysis script, an expensive local run and a run whose size cannot be estimated still ask. After twelve runs or twenty folder creations since your last message the next request asks you, and /approvals-log lists every automatic approval. /approve-for-me off returns to asking.

  • After a turn you get the answer, one line saying where the files are, and one sentence on the next step. Every number in the answer is tied to a recorded result; the terminal folds the evidence into one line, and /report writes the full evidence report (HTML and Markdown) under results/. Figures are drawn inline where the terminal supports images and always saved under results/plots/.

  • On Windows, LatticeMind’s shell tool runs PowerShell and reads its output correctly, so inspection commands behave the same as on Linux and macOS.

What it can calculate

  • Attach a paper as a PDF and ask for one of its figures. LatticeMind reads the structure and settings out of the paper, prepares the calculations and reproduces the figure from its own results.

  • RESCU reports the magnetism of a collinear run — total and per-atom moments — and the band edges from the calculation’s own eigenvalues and Fermi level, with the valence and conduction edges per spin and the gap. A metal, or a state inside the smearing window, is reported as such instead of a gap.

  • Rectangular and square monolayers are recognised as two-dimensional and get the standard Γ–X–S–Y–Γ band path, so a 2D sheet no longer needs a hand-written path.

  • VASP reports band edges from the occupations of its own eigenvalue file: highest filled and lowest empty sampled state, direct or indirect, the smallest direct gap, and the energy at each labelled point of a line path. The band plot is labelled with those points (Γ, M, K, …) and, when the occupations verify, referenced to the valence-band maximum with the gap printed.

  • Spin-polarized VASP runs (ISPIN=2) report their band edges per spin channel with the two-channel gap, the spin splitting of the highest valence and lowest conduction band at each sampled point, and the net moment from the occupations. A band-structure request can set the number of points per path segment (KPOINTS_LINE_DIVISIONS), and the curated vocabulary includes the density-mixing tags for hard magnetic SCFs.

  • VASP relaxations that move the cell as well as the ions (ISIF=3) are verified and reported: the relaxed and starting cell lengths and the final pressure, with the Pulay-stress caveat stated. The relaxed geometry can then be handed straight to the next calculation.

  • NanoDCAL gains collinear spin polarization declared per atom, so an antiferromagnetic setup needs no hand-edited input; DFT+U with a Hubbard parameter block; and complex band structures, reported as the energy windows free of propagating modes and the slowest decay rate in each.

  • Starting parameters for RESCU SCF, DOS and band calculations come from the verified structure and the potentials actually present, with the reciprocal mesh derived from the cell. DOS and band calculations inherit their SCF parent’s density, geometry, method and units. Standard bulk band paths need a primitive cell, because a conventional cell folds the bands onto different labels; explicit custom paths remain available. Wide spectra keep a full-range figure and add a labelled near-Fermi view.

  • Elemental iron, cobalt and nickel start in their magnetic state whatever the conversation said about them: collinear spin, the cited moment per atom, a real-space grid of at most 0.3 Bohr and a 12×12×12 mesh with tetrahedron occupations. A seeded moment that converges to zero is reported as a failed magnetic state to fix before any band structure or DOS, not as a result.

  • A standard DOS figure is drawn from any RESCU release with the same output layout; the native check no longer requires one version string.

Running and recovering

  • Several runs approved together now launch one after another. A local run keeps its approval while it waits for the run before it, instead of expiring in the queue, and a run that never started can be approved again.

  • When a calculation is redone, the older run is marked as superseded by the newer one in the run listings and in its evidence, so an old number is not mistaken for the current one.

  • Reopening a conversation keeps its running jobs, prepared inputs and remaining allowances. A job whose outcome is unknown is checked against the records rather than launched again.

  • A launched calculation is part of the request. An SCF, band structure and DOS asked for together are carried through in one turn: LatticeMind waits for the SCF and finishes the rest before it answers, unless you asked to leave the job running in the background.

  • A figure that cannot be drawn from a run — an unfamiliar output layout, a changed source file — is reported and worked around instead of pausing the conversation.

  • Fewer steps stall on small slips: a mistyped reference to an earlier result still finds it, a repeated failing step is not run again, a k-point mesh you ask for is kept when LatticeMind proposes the other settings, and a calculation type written in another common spelling is accepted.

Starting defaults and a successful process exit do not certify numerical convergence or physical adequacy; those remain separate findings. See Two runtimes for the current execution and verification boundaries. The 0.4.0 notes below describe the one-shot pipeline, and its benchmarks do not certify every workflow in the research conversation.

LatticeMind 0.4.0

Released 2 September 2026

This release improves long, multi-step projects. A follow-up request builds on what the project already knows and has already computed, remote work can run detached and be collected later, and NanoDCAL now covers the calculation types its manual documents.

Continuing a project

  • A follow-up request inherits the device, material and settings the project was founded on, so “add a Seebeck coefficient calculation to this project” needs no restatement. A request that names a new material still takes precedence.

  • Finished calculations are reused rather than recomputed, and work that is still pending is carried across turns until it completes.

  • Standing decisions are remembered: an energy window or a vacuum policy set in an earlier turn shapes the inputs rendered later.

  • Clarifying questions can offer answers to choose from.

  • Starting LatticeMind inside a project continues that project; starting it in a folder of projects continues nothing until you say so. The banner names the most recent project and /resume last continues it. A follow-up request typed with no active project is recognized and confirmed with you first.

Running on a cluster

  • --detach launches a remote run that continues after the command returns; a later turn collects the finished results.

  • A remote submission is confirmed against the host before it is reported as failed.

  • Execution approval can be granted once for a project, and a turn reports what it has left to spend.

NanoDCAL

  • The calculation types documented in the NanoDCAL manual are available as workflows, and run the same way on your own machine or on an HPC profile.

  • Two-probe devices are built from a named element, isolated molecules are built in vacuum boxes, and spin-orbit and projected-band requests configure themselves.

  • Thermoelectric and phonon properties run after the calculations they depend on, with the intermediate results carried along.

Command line

  • The plain CLI is now the default interface. The terminal dashboard opens with /dashboard on (/dashboard off closes it), or at launch with LATTICEMIND_UI_MODE=dashboard.

  • /solver lists every available solver with a description, and a new project announces the solver it will use.

LatticeMind 0.3.1

Released 23 August 2026

This release improves multi-step projects, where a new calculation is added to a project that has already run, and extends the command line.

Continuing a project

  • A follow-up request that builds on a completed project keeps the calculations that project already contains.

  • A request for a calculation the project does not yet have is recognized as new work.

  • A continuation carries forward the material, workflow and solver of the project it belongs to.

  • The replanning loop concludes promptly when a requirement cannot be satisfied.

Calculation inputs

  • Density-of-states calculations inherit the Brillouin-zone sampling of the calculation whose density they reuse.

  • Clearer description of the generated project layout.

Reporting

  • Band gaps are reported exactly as the solver computes them, with a note that semilocal functionals typically underestimate band gaps and a recommendation to compare against published values.

Command line

  • Added /solver, which shows and changes the solver used for new projects.

  • The command palette lists every available command with a short description, and command completion is improved.

  • The file-movement notice is shown once per session.

Packaging

  • LatticeMind 0.3.1.post1 adds wheels for CPython 3.13 and 3.14 on Linux, Windows and macOS. The source is identical to 0.3.1.

LatticeMind 0.3.0

Released 19 August 2026

The largest release so far. It widens solver coverage across RESCU, VASP and NanoDCAL, introduces a deterministic structure builder, improves the continuation of existing projects, and adds local command-line model providers.

Solver support

  • Added NanoDCAL two-probe transport, planned as a chain of electrode and device calculations followed by the requested property.

  • Added six advanced NanoDCAL device properties: transmission spectrum, current-voltage, projected local density of states, transmission eigenchannels, thermoelectric coefficients, and the local device density of states. Each has a dedicated plot.

  • Transport chains can resume from calculations already completed on disk.

  • Improved the NanoDCAL property definitions, and broadened the terminology accepted for phonon workflows.

  • Added Berry curvature calculations in RESCU, including a curvature map over the Brillouin zone.

  • Added VASP electrostatic potential, dielectric response, optics and phonon calculations.

  • Added a coverage table showing which calculation types are supported for each of the three solvers.

Structure building

  • Added a crystal structure library that builds the common prototypes from curated geometries at measured lattice constants.

  • Added a surface slab builder covering the common fcc and bcc facets.

  • Added an independent check that a generated cell matches the crystal it is meant to represent, run before any calculation starts.

  • Better handling of requests that name a particular cell or polymorph.

  • Added reference states for the elements across the periodic table, so defect formation energies work for metals, oxides and nitrides alike.

Surfaces and work functions

  • Added work-function extraction from the vacuum region of a slab.

  • Added slab-thickness convergence studies from a single request, including potential-profile figures.

  • Added comparison against a reference calculated with the same functional, with measured values reported as context.

Understanding requests

  • Added a review step that checks how a request has been read against what it asked for, covering calculation stages, band paths, functionals, alloy compositions, spin treatment and remote execution profiles.

  • LatticeMind asks which material is meant when a request does not name one.

  • LatticeMind states what it can and cannot do. A request outside materials simulation is declined with an explanation, and a materials calculation that is not yet supported is redirected to the nearest supported route.

Continuing a project

  • Continuations reuse the project’s existing plan, and completed calculations keep their inputs and results.

  • A new step can be attached to a specific earlier calculation, named either exactly or descriptively.

  • Better selection of which project a follow-up request belongs to.

  • Clearer distinction between rerunning a calculation as it stands and modifying it. Reruns are limited to the calculations the request identifies.

Execution and recovery

  • Added bounds on every automatic retry, repair and replanning cycle within a request.

  • Failure recovery examines the project before choosing a fix, and prefers fixes supported by evidence.

  • Better continuation of local runs, with the new /lease command for inspecting and clearing the lock held by a running or released calculation.

  • Remote runs use the processor allocation of the selected profile.

Reporting

  • Reports and console output present one consistent verdict per calculation.

  • Added a convergence figure for sampling studies, presented as the study’s headline result.

  • Improved the built-in band structure plot, which follows RESCU’s own plotting conventions.

  • The confidence score and its accompanying notes now agree.

  • Better handling of run completion and reconnection in the Web UI.

Projects and working directories

  • New projects keep their bookkeeping in a single hidden directory, leaving a clean project folder. Existing projects are unchanged.

  • Simplified the information printed at startup.

  • Added /trust, which records whether LatticeMind may search a directory for structure files.

  • Better recognition of which structure file a request refers to.

  • Home, root and system directories can no longer be used as project directories.

Security and safety

  • Generated post-processing scripts are reviewed before they run.

  • The Web UI binds to the local machine by default. Exposure beyond the machine must be requested explicitly.

  • Added /rescu-plotting, which enables or disables RESCU’s built-in plotting and remembers the choice.

Documentation and packaging

  • Startup checks for a newer release and prints the command to install it. The check can be disabled.

  • Added a client release package assembled alongside the wheels, containing the README, installation guide, changelog, cloud quickstart and manual.

  • Rebuilt the manual for this release, with new tutorials on k-point convergence, electronic structure chains, spin-polarized calculations, alloys, work functions, NanoDCAL transport and remote HPC execution.

LatticeMind 0.2.0

Released 27 July 2026

This release completes the multi-solver interface, adds defect, strain and phonon workflows, allows long calculations to run independently of the client, and ships the LatticeMind manual with the package for the first time.

Solver support

  • Completed the multi-solver interface. RESCU, VASP and NanoDCAL each provide input generation, validation, execution, post-processing and capability declarations through one common interface.

  • Added a shared set of physics checks applied to all three solvers, with each message expressed in the active solver’s own vocabulary.

  • The solver for a request is determined before planning, with a clear order of precedence.

  • Extended NanoDCAL post-processing with figures for every result type, a machine-readable figure manifest, and validation of electrode and device calculations before launch.

  • Extended VASP support across input generation, execution and pseudopotential handling. VASP remained early and experimental at this release.

Physics workflows

  • Added phonon dispersion through density functional perturbation theory.

  • Added neutral and charged point-defect formation energies, including chemical potential accounting, charge transition levels and finite-size corrections.

  • Added strain comparisons, in which each calculation receives its own geometry.

  • Improved the selection of high-symmetry band paths, which follow one deterministic reference for each lattice type.

  • Structural relaxations report the relaxed cell, the converged energy, force convergence and a validity verdict.

  • Spin-polarized runs report the converged magnetic moment.

  • A material known to be a semiconductor or an insulator is reported as such, with the computed gap given as a lower bound and a hybrid functional recommended.

  • A request naming a Materials Project identifier builds from that published structure.

  • Pseudopotential coverage is checked before a calculation is launched.

Verified results

  • A calculation is reported as successful only when the solver’s own output shows that it converged, and every calculation records a convergence label.

  • Added a check that every requested step appears in the plan.

  • A step producing no extractable results is reported as partial.

Run, release and reattach

  • Added detached execution. Long calculations can be released to Slurm, to a remote shell session, or to a local background process, after which LatticeMind can be closed. A later request reattaches, adopts the results and completes the report.

  • The Web UI shows released runs with live status, a status check and a reattach control.

Durability and recovery

  • Added checkpointing at every approval point and at the end of each request, so a project resumes where it left off.

  • Added a recovery sequence for convergence failures, applied in physical order and confirmed present in the regenerated inputs before a calculation is relaunched.

  • Improved remote transfers and job polling, with checksum verification, finite timeouts and deterministic termination.

  • Project files are written atomically, and an unreadable file is set aside with the reason recorded.

Approve for me

  • The Approve for me setting approves validated, low-cost local runs automatically.

Web UI

  • The launch panel leads with solver, model provider, reasoning effort and model, with a model picker offering known-good options.

  • The attached-project card reports live project information.

  • Approval prompts appear directly below the progress bar, and are cleared when a run starts or a project changes.

  • Report figures are deduplicated, and electrostatic potential figures are produced only when the request asks for them.

Documentation

  • The LatticeMind manual ships with the package, in HTML and PDF.

LatticeMind 0.1

Versions 0.1.2 to 0.1.10, May to July 2026

The first LatticeMind release line, establishing the product: an assistant that turns a plain-language request into a complete, validated, executed and reported materials calculation.

The assistant

  • An interactive command-line assistant and a browser dashboard, both driving the same pipeline.

  • Follow-up requests continue an existing project, and questions about a project or about solver documentation are answered directly.

  • An interactive review mode that pauses after each stage for notes or edits.

  • Prompt understanding and reports in English, French and Chinese.

  • Token usage tracking, forecasting and limits, and a support package workflow that collects a project for a support request.

Workflow generation and validation

  • A request is expanded into concrete calculations with explicit dependencies between them.

  • A deterministic validator checks a workflow before it runs, and routes targeted repairs back to the stage that produced the issue.

  • Solver documentation rules are applied throughout planning and input generation, with keyword definitions taken from the solver manuals.

  • A deterministic confidence score with a transparent breakdown.

Structures

  • Structure generation with approval, validation and a pre-execution check.

  • An alloy builder, and support for structure files you supply.

  • Materials Project support.

Execution

  • Approval-gated local execution, with an optional automatic approval mode that includes guardrails and a kill switch.

  • A repair loop that diagnoses a failed calculation and retries it within a bounded budget.

  • Parallel execution settings for local and remote runs.

  • Remote and HPC execution over SSH and Slurm, with job locks and verified retrieval of results.

  • Filesystem safety checks covering project directories and deletions.

Solvers

  • RESCU support: self-consistent field, band structure, density of states, relaxation, phonons, potentials, band unfolding and DFT+U.

  • NanoDCAL support, from periodic and molecular calculations through device structures and transmission, with publication-quality figures exported as PNG, SVG and PDF.

  • Early experimental VASP support.

  • Defect formation energy workflows for point defects.

Models and providers

  • Support for OpenAI, Anthropic Claude, Google Gemini, Qwen and local Ollama models.

  • Local retrieval over the bundled solver documentation.

Command line and automation

  • A command interface that runs without a license or a model provider key and returns structured JSON, for use from scripts and other tools.

  • One-shot planning and validation from a single command. Running calculations requires explicit approval.

  • Documentation search across the LatticeMind manual and the solver documentation.

  • Grouped, searchable commands and a set of example prompts.

Packaging and deployment

  • Cross-platform wheels for Linux, Windows and macOS, with a runtime pseudopotential library included.

  • Cloud and headless deployment, including a qBraid quickstart.

  • The LatticeMind manual in HTML and PDF.