TIATool

Verify-first AI toolkit for Siemens TIA Portal

Describe the change.
Watch it compile.

TIATool connects Claude, Cursor or VS Code to TIA Portal through MCP. It reads the whole project offline, backs it up before every write and checks each change against your baseline. When no tool fits, it scripts Openness itself.

€99.99 / month or €999.99 / year. One PC per seat.

Facts you can check

Install

Three steps, real commands.

One line in PowerShell on the engineering PC, a check of the PC, then plain-language requests in the AI client you already use.

  1. 01

    Install on the engineering PC

    PowerShell, no admin shell needed. The script checks the installer against the published SHA-256 and stops if it does not match, then setup finds TIA Portal, adds you to Siemens TIA Openness and registers TIATool in Claude Desktop, Cursor and VS Code. Preview build for TIA Portal V19 only. V21 support comes with the full release.

    irm https://tiatool.dev/install.ps1 | iex
  2. 02

    Check the PC, activate your key

    Doctor reports Openness, the user group and the licence. TIATool needs an active licence. Buy a plan, then activate that key on this PC.

    tiax-agent doctortiax-agent license activate <KEY>
  3. 03

    Ask for real work

    Close TIA Portal first, then ask your AI client in plain words. It picks the tools; your client asks before each call runs.

    Export C:\TIA\Line3\Line3.ap19, scan it, and tell me who writes Conveyor_01_Running.

Windows PowerShell · ENG-PC-07
irm https://tiatool.dev/install.ps1 | iexTIATool: downloading installer from https://tiatool.dev/downloadTIATool: SHA-256 verified.WARNING: Installer signature: NotSigned. Continue only if you trust the source.TIATool: starting setup (Windows will ask for administrator rights once).TIATool installed. Restart Claude Desktop / Cursor / VS Code, then ask:  "export my TIA project and list its blocks"tiax-agent doctor[ OK ] Operating system: Windows x64[ OK ] .NET Framework: 4.8 or later (release 533325)[ OK ] TIA Portal Openness: V19 (API 19.0.0.0)[ OK ] tiax for V19: C:\Program Files\TIATool\tiax.exe[ OK ] Openness user group: current user is in 'Siemens TIA Openness'[ OK ] TIA Portal processes: none running[WARN] License: No license activated. Activate a key with: tiax-agent license activate <key> — or buy a license (EUR 99.99/month or EUR 999.99/year) at https://tiatool.dev/#pricing.

The preview installer is not code-signed yet, so the script says so. The SHA-256 check is how you know the file is ours: the script stops if the hash is missing or does not match. Prefer to install by hand? Download TIATool-Setup.exe (0.7.0-preview.7) and compare it with /download.sha256 first. Preview build for TIA Portal V19 only. V21 support comes with the full release.

What it does

The whole project, offline, in seconds.

Export once, scan once. From then on, who writes a tag, what calls what, where a name is used and what changed since last week come from a local cache, with TIA Portal closed.

who_writes_tag · who_reads_tag

Know who writes a tag before you touch it.

Writers, readers and HMI use of any tag, down to the network and the line of logic. The assistant checks this before it changes anything.

what_block_calls · unreachable_blocks

Read an inherited project from its call graph.

Which OB calls which FB, what a block depends on, and which blocks nothing calls any more.

hmi_import_screens · where_is_tag_used_on_hmi

Screens and tags wired to your PLC.

Comfort panels get screens and HMI tags linked to the PLC. Basic panels get screens and internal tags, linked in the tag grid. Then trace every PLC tag to the screens that show it.

project_stats · search_project · refresh_scan

Analyse with TIA Portal closed.

Search, diff, audit and docs run against the local cache. Every answer says when the cache is older than the exports.

Also in the box

Equipment model
Describe the plant once. 20 built-in templates generate FBs, instance DBs, tag tables, HMI, alarms and docs that agree with each other.
Verify gate
After a change: only the intended blocks changed, interfaces and retain flags intact, scan shape unchanged.
Audit
Multiple writers, unwired inputs, literal offsets, retain in volatile DBs. Every finding points at a block and network.
Restore
Every write keeps its own restore point. Restore into a new folder, or in place with a confirmed roll-back.
Knowledge base
55 field entries with verbatim error texts. When a call fails, explain_error returns the cause and the fix.
Diff and docs
Compare two scans block by block. Publish the project as Markdown or HTML with call graphs and tag tables.

Self-extension 0.8

When no tool fits, the AI writes one.

It reads the Openness object model, writes a short C# script, runs it in a transaction that is never committed, and keeps what worked as an extension. A write script goes through the same licence, approval, backup and verify gate as every built-in tool.

  1. 01

    Explore

    Browse the Openness object model of the open project: attributes, compositions, actions and their types. Reading changes nothing.

    • openness_browse
    • openness_get
  2. 02

    Script

    Write a short C# script. Read mode runs in a transaction that is never committed and never saved. Compiler errors come back with line numbers.

    • script_check
    • script_run
  3. 03

    Verify

    A write script takes the write path: licence, your confirmation, a new backup, commit only on success, then re-export and the verify gate.

    • script_run
    • verify_change
  4. 04

    Promote

    A script that ran becomes an extension: a named tool with a parameter schema and the hash of the code that ran, kept in your workspace.

    • extension_save
    • extension_run
  5. 05

    Learn

    What failed and what fixed it goes into the knowledge base, in the same symptom, cause, fix form as the field entries.

    • knowledge_add
    • explain_error
script.cs
using System.Linq;using TiaTool.Scripting; public static class Script{    public static object Run(ScriptContext ctx)    {        var plc = Tia.Plc(ctx, ctx.Arg<string>("plc"));        var tables = plc.WatchAndForceTableGroup.WatchTables;        ctx.Log($"{plc.Name}: {tables.Count} watch tables");        return tables            .Select(t => new { name = t.Name, entries = t.Entries.Count })            .ToList();    }}

tiatool›script_runproject: "C:\TIA\Line3\Line3.ap19", mode: "read", args: { plc: "PLC_1" }

SCRIPT OK — read · rolled back (never committed, never saved) · 6.4 s · run_id r20261013141502-4f2a9c
value:
[
  { "name": "Commissioning", "entries": 14 },
  { "name": "Conveyor_IO", "entries": 9 }
]
log (1 line(s)):
  PLC_1: 2 watch tables
Promote it with extension_save from_run=r20261013141502-4f2a9c once it does what you want.

tiatool›extension_saveid: "watch_tables_list", from_run: "r20261013141502-4f2a9c"

Saved extension 'watch_tables_list' (read, status unverified) to …\extensions\watch_tables_list (journal #23).
Provenance: run r20261013141502-4f2a9c (read, Openness V19), script sha256 9c41e0b7d2a35f18…
Run it with extension_run id=watch_tables_list.
extensions/watch_tables_list/extension.json
{  "format": "tiatool.extension/1",  "id": "watch_tables_list",  "title": "List watch tables",  "description": "Watch tables of a PLC with their entry counts.",  "category": "watch_tables",  "kind": "script",  "mode": "read",  "parameters": {    "type": "object",    "properties": {      "plc": {        "type": "string",        "description": "PLC name; optional with one PLC"      }    }  },  "min_tia": "V19",  "status": "unverified",  "provenance": {    "created": "2026-10-13T14:15:09Z",    "script_sha256": "9c41e0b7d2a35f18…",    "run_id": "r20261013141502-4f2a9c",    "verified_run": true,    "tia_version": "V19",    "journal_seq": 23  }}

Siemens does not open all of TIA Portal, so some calls depend on the project, the panel and the TIA version. The assistant says when one cannot be done. Try a new script on a copy of a project. The scan for risky APIs is a guard rail, not a sandbox: review a script like code you run yourself.

The script names are the tools in the catalog this page was built from.

Self-extension: teaching TIATool what it cannot do yet

Safety and trust

It’s your plant’s code. Every change is verified.

One write, start to finish. Your approval and a backup come with every write tool; the verify gate runs on its own in a project workspace; the build tools add a free preview first.

  1. 01

    Preview

    build_from_source (preview) → + FB_Pump + DB_Pump_01 ~ Main [OB1] NW 7

    The build tools show what would change first. Nothing is written.

  2. 02

    Approve

    your AI client → Allow build_from_source on MyProject? ✓

    You approve the write. Downloading to a PLC also needs a confirmation code bound to that exact download.

  3. 03

    Backup

    backup_project → MyProject · backup 2026-10-12 16:04

    A new timestamped restore point before any write. Never overwritten.

  4. 04

    Write

    build_from_source · compile_project → FB_Pump ✓ DB_Pump_01 ✓ errors: 0

    Only while TIA Portal isn't open in front of you. A failed step never saves.

  5. 05

    Verify

    verify_change → blast radius ✓ interfaces ✓ retain ✓ · journaled

    In a project workspace: re-exported, checked against your baseline, and written to the journal.

Where data goes

Your project goes to this PC
Exports, the cache, backups, workspace and journal stay next to your project.
Tool answers goes to your AI provider
Sent by your AI client under that provider’s terms. With a local model, nowhere.
Licence check goes to licence server
Key, a hashed machine id and the computer name. Never project data.
Telemetry goes to none
No usage data, crash reports or tool logs.
  • Approval

    Your AI client asks before each tool call. A PLC download or a write script needs a second confirmation bound to its exact arguments.

  • Portal guard

    Tools that open a project refuse to run while TIA Portal is open, so they never work against your unsaved edits.

  • Restore

    Every write keeps its own restore point. Restore into a new folder, or in place after a roll-back point is taken.

  • Journal

    With a project workspace, each write lands in its journal: the arguments, the backup it took and the verify result.

  • Policy filenew in 0.8

    An administrator can make TIATool read-only, switch scripts off or allow read scripts only, and require a human confirmation for named tools.

  • Air-gapped licence

    Yearly plans: the offline PC writes a request file, your account turns it into a licence file, the PC imports it.

Compared · as of October 2026

How it compares.

The alternatives an automation engineer weighs today, from their own public pages, with a source on every cell. Where they are ahead, the table says so.

TIATool

this product

What it is
An MCP server and command line for TIA Portal with an offline project cache. No chat of its own.
AI model
The MCP client you already use: Claude Desktop, Claude Code, Cursor or VS Code.
TIA Portal versions
V19 and V21.
Breadth
75 MCP tools, plus C# scripts against the Openness API.
How writes are guarded
A new backup before every write and your approval; with a workspace, the verify gate against your baseline and a journal entry.
Offline and air-gapped
No connection needed day to day. Yearly plans include an air-gapped licence file.
Price
€99.99 a month or €999.99 a year per seat, one PC, all 75 tools. No free tier and no trial.

Siemens Eigen Engineering Agent

Siemens’ own AI agent

What it is
Siemens’ agent for TIA Portal, generally available since April 2026.[1][2]
AI model
A Siemens-managed cloud service with Siemens-hosted models.[4]
TIA Portal versions
V19, V20 and V21.[1]
Breadth
SCL and LAD generation, WinCC Unified scripts, drives, hardware and PROFINET, translation, ECAD import.[1][3]
How writes are guarded
Not described on the public pages we checked.[1]
Offline and air-gapped
A cloud service: it needs a connection to Siemens.[4]
Price
Subscription on Siemens Digital Exchange; price not public; one-month free trial.[1]

T-IA Connect

REST and MCP wrapper product

What it is
An application with an MCP server, a local REST API and a built-in assistant.[5][10]
AI model
Built-in assistant with your own API key (OpenAI, Anthropic, Google, Groq or a local endpoint), or an MCP client.[10][5]
TIA Portal versions
V17 to V21.[6]
Breadth
393 MCP tools listed and 316 REST endpoints documented.[5][9]
How writes are guarded
A download to a real PLC needs an explicit confirmation flag; actions are logged.[11]
Offline and air-gapped
Installation, authorisation and activation need the internet; offline authorisation only when sold separately.[6]
Price
€147 per seat per month; €97 for an eligible first month. No free tier and no automatic free trial.[7][8]

Open-source TIA MCP servers

Community projects

What it is
MIT-licensed MCP servers, for example heilingbrunner/tiaportal-mcp and Czarnak/tia-portal-mcp.[12][13]
AI model
Any MCP client, over stdio.[12][13]
TIA Portal versions
V21 by default; heilingbrunner reaches older versions with a start-up flag.[12][13]
Breadth
heilingbrunner: 114 tools (69 read, 45 write). Czarnak: 16 tools.[12][13]
How writes are guarded
heilingbrunner: read-only unless started with --allow-write. Czarnak: dry-run previews, an audit log, never starts or stops a PLC.[12][13]
Offline and air-gapped
Run locally, no activation.[12][13]
Price
Free.[12][13]

Where they are ahead today

  • Siemens Eigen Engineering Agent

    Made by the maker of TIA Portal and runs inside it. Generates LAD as well as SCL, configures drives and PROFINET, and reads ECAD data. TIATool does not configure drives.[1][3]

  • T-IA Connect

    A much broader tool set, a REST API for your own software, V17 to V21, CODESYS, and a built-in assistant for teams without an AI client.[5][9][6]

  • Open-source TIA MCP servers

    Free and open source, with more single-operation tools (tags, watch tables, V20+ documents) than TIATool ships as built-in tools.[12]

Pricing

Two prices. Every tool.

One licence per engineer: all 75 tools, all updates. Pay monthly or save with a year.

Monthly

€99.99/ month

Per engineer. Cancel anytime.

  • Every tool, including writes
  • One PC per seat
  • All updates included

Yearly

save €199.89

€999.99/ year

€83.33 a month: two months free.

  • Everything in Monthly
  • Air-gapped licence file included
  • 30-day offline grace on the engineering PC

Online checkout is not open yet, so nothing was charged. Write to hello@truesmarttech.com and we send you an invoice.

Prices in euro. Up to 50 seats are self-serve at list price; for more, a PO or your own terms, write to hello@truesmarttech.com. 14-day money-back on your first payment. Requires Windows and your own licensed Siemens TIA Portal V19 or V21 with Openness. Preview build for TIA Portal V19 only. V21 support comes with the full release. Checkout by Stripe.

What each tool does to a project53 only read · 7 depend on the action · 15 change a project. All need a licence. Generated from the catalog the server enforces.

Reads 53 tools

Never changes a TIA Portal project.

Reads tools
Tool
project_statsInventory of the TIA project: PLCs, block counts by type and language, and the fidelity roll-up saying how much of the project is actually readable.
list_blocksList blocks in the project.
get_blockThe full record for one block: interface tree, per-network logic as SCL, calls, and read/write edges.
who_writes_tagEvery place a tag or variable is WRITTEN, with the block, network, and the logic that writes it.
who_reads_tagEvery place a tag or variable is READ, with block, network and the reading logic.
who_callsWhich blocks call the given block, with the instance name used.
what_block_callsWhich blocks the given block calls (callees, from CallInfo), including the instance DB used — the downward half of the call graph; who_calls is the upward half.
unreachable_blocksCode blocks never reached from any OB — dead code candidates.
search_projectRanked free-text search across block names, titles, comments and logic — and HMI content (screen texts, tag bindings, events).
list_screensHMI screens, templates and popups in the scanned project — name, device, object count and fidelity.
get_screenThe full record for one HMI screen: every object with its texts, tag bindings, animations and events, plus the tags_used and navigation rollups.
hmi_tag_mapEvery HMI tag with its table, connection and the screens using it (joined by name over each screen's tags_used).
where_is_tag_used_on_hmiWhere a PLC-side symbol shows up on the HMI: screens whose tags_used match and HMI tag tables whose tag names match.
tia_statusLive environment check: installed TIA Portal Openness versions, whether a TIA Portal process is running (with PIDs), the cache being served and whether it is stale, and the scanner version.
refresh_scanRe-scan the exports folder into the cache this server is serving, then reload the index in place, so the cache tools answer from fresh data.
backup_projectZip the whole project folder to a restore point beside it — the same backup every write tool takes automatically, on demand.
list_devicesThe REAL project's hardware tree: devices, plugged modules, article numbers, firmware and I/O address ranges.
generate_equipmentGenerate PLC code for pumps, valves and motors from proven templates, named per the SCL naming convention: FB FB_Pump/FB_Valve/FB_Motor (feedback supervision, thermal trip, latched faults with reset), one instance DB per equipment (IDB_Pump_P101), command struct in DB_Equipment, PLC tags I_P101_Running/Q_P101_Run in a tag table, and an FC 'Equipment' calling every instance.
io_list_importTurn an electrical I/O list (CSV or XLSX; columns Name/Tag, Address, optional Type, Comment, Table, Station, Module, OrderNumber, Firmware, Slot — English/German/Dutch headers recognised) into PLC tag tables (TagTables/*.xml for build_from_source), a hardware.json module plan, and an AutomationML file for hardware_import.
generate_alarmsGenerate a bit-coded alarm system: DB_Alarms (alarm Words), FC 'Alarms' packing each trigger into its bit, a WinCC Comfort/Advanced discrete-alarm CSV, the HMI tag list, and a Unified alarm spec for unified_build.
project_diffCompare two scans (.tiax caches) — e.g.
export_docsWrite project documentation from the cache: block catalogue, per-block interface tables, calls / called-by, tag tables with addresses, HMI screen inventory.
library_listList the types (blocks, PLC data types, faceplates…) of the project library or a global library, with versions, states and the default version.
plc_onlineOnline state of a PLC (Offline/Connecting/Online/Incompatible…) and the PC interfaces TIA can reach it through — run before plc_download to pick pc_interface.
explain_errorLook up an error message (TIA Portal, Openness, compiler, import, tiax) in the field-proven knowledge base and return the matching entries with their rule and fix.
verify_changeThe verify gate between a baseline cache and the cache taken after a change: 1 blast radius vs the declared targets (instance DBs of a target allowed), 2 block attributes (author, family, version, language, safety, memory layout), 3 interface (start value changes = warning), 4 scan shape (counts, failure ledger, readable %, fidelity regressions), 5 remanence and External* per member.
audit_projectAudit the scanned project: multiple writers, declared-never-written and written-never-read members, unwired FB inputs at call sites, POKE/PEEK/BLKMOV with literal offsets, retain in volatile DBs and mixed lifetimes, external HMI tags with no PLC match (by name), lossy renderings, and the Modbus register-map self-check on Standard-layout DBs.
finding_verdictRecord a verdict on an audit finding (by fingerprint from audit_project): accepted (real, will fix or live with), false_positive, wont_fix, or open again.
workspace_initCreate the project workspace (the per-project work folder: tiatool.workspace.json, journal.jsonl, plan.json, assumptions.md, decisions.md, findings.json — plain text, git-friendly).
workspace_statusOne-call situation report: workspace, cache freshness and format, active baseline, licence, plan task counts, last writes with their verify results, open assumptions and findings, and the suggested next step.
taskThe change plan (plan.json).
assumptionThe numbered assumptions register (assumptions.md; knowledge/standards/assumptions-register.md).
decision_addAppend a decision to decisions.md (what was decided, why, by whom).
baseline_setFreeze the current cache as a named baseline (copied to snapshots/<name>) and make it the active baseline that verify_change and project_diff compare against.
template_listList the equipment templates (built-in, %APPDATA%\TIATool\templates overrides, <workspace>/templates overrides) with version, FB name, signal/alarm counts and where each comes from.
template_showShow one template: signals (role, direction, type, required), parameters with defaults and units, HMI commands and statuses, interlock input, ISA-18.2 alarms, compliance notes (to confirm), SimHarness tests, and the SclSelfCheck result.
model_validateCheck the equipment model (<workspace>/model/equipment.json, schema tiatool.equipment/1) without TIA Portal: templates exist, io roles and addresses (direction, size, clashes across the whole model), params, interlocks and cross-references (TAG.status), alarm overrides, cultures and CPU family.
model_generateGenerate a build_from_source folder from the equipment model into <workspace>/build/<batch>/: UDTs, the used template FBs, instance DBs, the DB_HMI command/status interface DB, Equipment/Comms/CyclicControl FCs with interlocks, tag tables per area, alarms in every culture, SimHarness specs, Markdown docs (equipment list, as-built I/O, ISA-18.2 alarm list, HMI interface manual) and generation.json.
model_from_io_listDraft model/equipment.json from an I/O list (CSV/XLSX/tab text with name, address, type, comment, table): tags like I_BP1_Running / Q_BP1_Run are grouped by equipment and matched to the template whose signals fit best.
template_extractTurn an FB from the scanned project (cache) into a template skeleton in <workspace>/templates/<id>/ (template.json + fb.scl): interface → parameters and statuses; the body is copied only when the block's fidelity is native SCL.
openness_browseExplore the LIVE Openness object model of the project — anything Openness exposes, including what no dedicated tool covers.
openness_getRead ONE attribute of a live Openness object, with its access mode and types.
find_toolSearch the FULL tool catalog by name and description — including tools this session does not list (tiax-agent --toolset).
script_checkCompile a C# Openness script and check it against the guard rail — nothing runs and no project is opened.
extension_savePromote a script that compiled AND ran successfully in this session (script_run) to a reusable extension: writes <workspace>/extensions/<id>/extension.json + script.cs (or %APPDATA%\TIATool\extensions without a workspace) with provenance (script sha256, run_id) and status unverified.
extension_listSearch the extension library: built-in pack (~40 live Openness scripts + offline cache queries: watch/force tables, text lists, technology objects, libraries, network, HMI, UMAC, tags, UDTs, blocks...), then %APPDATA%\TIATool\extensions and <workspace>/extensions overrides.
extension_showOne extension in full: manifest (description, parameters as JSON Schema, mode, min_tia, status, provenance), where it comes from (builtin / user / workspace override) and its code (script.cs or query.js).
cache_queryRun JavaScript over the scanned cache — offline, read-only, no TIA Portal — for any question the fixed cache tools do not answer.
knowledge_addRecord what this session learned so the next one does not hit it again: writes a knowledge-base entry (<workspace>/knowledge/learned/<slug>.md, or %APPDATA%\TIATool\knowledge\learned without a workspace) in the built-in format.
project_archiveArchive the REAL project to a compressed .zapNN file (Project.Archive).
project_retrieveRetrieve a .zapNN archive into a NEW folder (missing or empty) and report the project file found there.
scl_lintCheck SCL source text before it goes anywhere near TIA: every FUNCTION_BLOCK, FUNCTION, DATA_BLOCK, TYPE and ORGANIZATION_BLOCK, with line numbers.
plc_compare_onlinecompare the REAL project's PLC software with what runs on the PLC (offline vs online, the CompareToOnline tree) and list what differs.

Reads or writes 7 tools

Depends on the action: reads (for example an export without compile) leave the project alone; other actions change it.

Reads or writes tools
Tool
export_projectExport all PLC blocks, tag tables, types, watch tables and external sources from the REAL project to SIMATIC ML XML in output_folder.
alarm_textsPLC alarm text lists as Excel: action=export writes the XLSX (two sheets, lists + entries); edit it (or let the model fill translations); action=import overrides the lists from it (entries of a list in the file replace that list's entries).
plcsimControl S7-PLCSIM Advanced: action list | start (register, power on, RUN) | stop | read (tags) | write (set).
restore_backupRestore a project from one of its timestamped restore points.
openness_invokeRun one Openness ACTION on a live object (the actions openness_browse lists, with their parameter types).
script_runRun a C# script against the REAL project inside the TIATool engine.
extension_runRun a saved extension (built-in, %APPDATA%\TIATool\extensions or <workspace>/extensions) against the REAL project.

Writes 15 tools

Changes a TIA Portal project: a backup is taken first. Its dry run or preview only reads.

Writes tools
Tool
compile_projectCompile every PLC and HMI target in the REAL project (or the plc / hmi named, or only the given blocks of one PLC) and save it.
clean_sourcesDelete leftover external source files from the REAL project (they break TIA's Search and Cross-references) and remove the stale XRef cache.
build_from_sourceGenerate the REAL project from a source folder: hardware.json modules, TagTables/*.xml, *.scl block sources, optional HmiTags, then compile.
import_blockSurgically import ONE edited SIMATIC ML block XML into the REAL project, overriding the block of the same name inside a transaction.
hmi_import_screensImport every *.xml in screens_folder as an HMI screen, overwriting by name.
hmi_import_tagsImport HMI tags ONE PER FILE: tag_files_dir holds one subfolder per (existing) tag table, each containing <TagName>.xml files.
add_project_languagesAdd cultures to the project's active languages, e.g.
hardware_importImport hardware from an AutomationML (.aml) file into the REAL project via the CAx interface — devices, modules by order number + firmware, tag tables.
library_useUse a library type in the REAL project: instantiate a released block/PLC-data-type version into a PLC (keeps the link to the type), or with update=true update all instances in the PLC to the latest released version.
plc_downloadDownload the compiled program (and optionally hardware config) to a real PLC or a PLCSIM Advanced instance.
unified_buildGenerate WinCC Unified screens from a JSON spec into the REAL project: screens, items (HmiButton, HmiIOField, HmiText, HmiCircle, HmiRectangle…) with position/size/text, tag bindings (validated against the HMI tag tables), Release-event navigation buttons, and discrete alarms (from generate_alarms).
plcsim_testRun an input→output test spec against a PLCSIM Advanced instance: per case set inputs, wait, assert outputs (Bool/Int exact, Real with tolerance or {min,max}).
openness_setWRITE one attribute of a live Openness object (any writable attribute openness_browse lists).
project_createCreate a new, empty TIA project.
scl_applyApply SCL source text to ONE PLC of the REAL project: scl_lint first (errors refuse; warnings refuse unless confirm=true), backup, generate the blocks through a temporary external source that is deleted again, compile only that PLC, save.

FAQ

Straight answers.

Something else? Write to hello@truesmarttech.com.

What do I need?

Windows 10 or 11 (64-bit), your own licensed Siemens TIA Portal V19 or V21 with Openness, and an AI client that speaks MCP: Claude Desktop, Claude Code, Cursor or VS Code. The offline cache tools need no TIA Portal at all. Siemens does not open all of TIA Portal, so some calls depend on the project, the panel and the TIA version, and the assistant says when one cannot be done. Preview build for TIA Portal V19 only. V21 support comes with the full release.

What can the assistant change?

It can build blocks from SCL source, import SIMATIC ML blocks, import HMI screens and tags, add project languages, compile and export. You approve each call in your AI client and every write takes a backup first; in a project workspace the verify gate checks the result. The build tools have a preview that changes nothing. A download to a PLC needs a second confirmation bound to that exact download.

What does it cost?

€99.99 a month or €999.99 a year per seat, with all 75 tools and all updates. Without an active licence the tools refuse and tell you how to activate or buy one.

Does my project leave my PC?

Not through TIATool. It runs locally and sends no telemetry. What your AI assistant reads through the tools goes to that assistant’s provider under its terms; with a local model nothing leaves the PC. The licence server sees your key, a hashed machine id and the computer name, never project data.

Can it read LAD and FBD?

Yes. LAD and FBD networks are rendered as SCL so the assistant can follow the logic. A network that could not be rendered completely is flagged as lossy; never judge an interlock from a flagged network.

Can I use it on an air-gapped PC?

Yes, on yearly plans. The offline PC writes a licence request file, you exchange it for a licence file in your account on a connected PC, and import it. Day to day TIATool needs no connection.

What counts as a seat?

One engineer, on one PC. A virtual machine counts as that PC. To move the seat, remove the PC in your account and activate the key on the other one.

Is an AI model included?

No. You use the AI client you already pay for, under that provider’s terms. TIATool does not resell AI usage.

What happens when a licence ends?

The tools refuse until a licence is active again; doctor, init, license and setup keep working. Projects, backups, exports and workspace files stay where they are.

Invoices, refunds and cancelling

Stripe handles payment and invoices. Cancel anytime: monthly plans end with the current month, yearly plans at the end of the paid year. Not for you? Write within 14 days of your first payment for a full refund.

Your next project,
pair-programmed.

All 75 tools for €99.99 a month or €999.99 a year. On the engineering PC:

irm https://tiatool.dev/install.ps1 | iex