Skip to content

Releases

v0.55.0

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 17 Nov 16:38

[0.55.0] – 2026-11-17

The built-in knowledge in this version is TcAgent_Knowledge 1.1.0 (unchanged).

Added

  • Clean up TcAgent's files - Knowledge window, tab Storage: what TcAgent keeps under %LOCALAPPDATA%\TcAgent per area
    (chats, attachments, TcUnit runs, logs, caches, server versions, downloaded updates, *.bak-*, files of ended processes)
    with size, oldest, rule and what the rule removes; Clean up … shows every item first and uses the recycle bin; per
    project Delete everything of this project …. Once a day the safe areas are cleaned in the background. Rules in
    settings.json "retention"; never touched: backups, knowledge, settings. CLI: TcAgent.exe storage [clean|auto|project-delete].
  • Install updates from the chat, also in the XAE Shell - Install … closes the IDE (it asks to save), installs the
    package (VSIX installer, or the XAE Shell ZIP with install-xaeshell.ps1) and starts the IDE again with the same solution;
    the XAE Shell now downloads its ZIP from the release itself (update download --kind xaeshell, checked against
    SHA256SUMS.txt). Test builds: TCAGENT_UPDATE_FOLDER names a folder with built packages; one there is offered when it
    is newer or the same version built again (another TcAgentBridge.dll), with Skip this build (update local).
  • Chat history, stage 2 - ⋯ > Earlier conversations … lists the saved conversations of the solution (read, continue,
    delete); a continued conversation goes on in the agent's own session when the backend is the same and the session is still
    there (Claude Code --resume, ACP session/load), otherwise with the summary as before. The history now also keeps your
    answers to question cards and the id of the agent's session.
  • Newer built-in knowledge without a new TcAgent - the TcAgent Chat looks once a day for newer tags of the knowledge
    repository and shows what changed; Use x.y.z makes that version the built-in level (cache under
    %LOCALAPPDATA%\TcAgent\builtin), Skip this version, and ⋯ > About TcAgent goes Back. Only versions this TcAgent can
    use are offered ("Needs TcAgent" in their changelog); the package stays the fallback and pipelines always keep it
    (TCAGENT_BUILTIN=package). updates.json: "builtinUpdates": false or "builtinVersion": "1.1.0". CLI:
    TcAgent.exe update builtin [check|apply|skip|back]. Your copies of built-in, company or team files show
    ↑ original changed in the Knowledge window when their original changed, with Compare.
  • TcUnit report and window: tables in the test texts - /// lines that start and end with | are shown as a table
    (first line the head, a |---| separator line is left out, number columns right-aligned) in the HTML report, light and
    dark, and in the details of the TcUnit Tests window, e.g. the step table of a path test.
  • Chat history per solution - for every backend of the TcAgent Chat (Claude Code, GitHub Copilot, Gemini, Codex):
    the chat keeps every conversation on this PC (%LOCALAPPDATA%\TcAgent\chats\<solution>-<hash>\, never in Git):
    questions, answers, one line per tool call, a stop, and the agent's task list where the backend reports one (Claude
    Code, ACP backends such as Copilot). Opening the solution again shows the last conversation;
    within 8 hours the next question continues it. The first question to the agent gets a short summary - questions, last
    answer, open tasks - and the new tool tc_chat_history (read, list, search) reads more, with every AI client. Kept 90
    days / 50 per solution; ⋯ > Delete chat history of this solution; "saveHistory": false in chat-backends.json
    switches it off. The chat now also follows a solution change of the IDE (new session in the new folder).
    docs/USER_GUIDE.md
  • Knowledge window: several items at once in every list - select with Shift or Ctrl, the actions of the bar and the
    context menu work on all selected lines with one question. Sources (installed): My changes, Update and merge (every
    preview first, conflicts in the merge window), What's new upstream, Revert, Keep as own version, Uninstall, Copy path,
    "Select all like this"; Files: Open, Move to level, Switch off/on, Delete, Copy path and the Source actions; Backups and
    Reference docs: Delete and Copy path; Platforms: Copy path; Modules: Switch on / Switch off. Actions for one item (rename,
    edit, propose, open folder) are grey while several are selected.
  • TcUnit shipped with TcAgent - TcUnit 1.3.2 (MIT license, thirdparty\TcUnit with its license next to
    TcAgent.exe, listed in THIRD-PARTY-NOTICES.md). tc_library action=ensure_tcunit installs it into the TwinCAT library
    repository only if TcUnit is missing or older there (a newer one stays) and adds the reference to the PLC project if it
    has none; TcAgent.exe tcunit ensure --solution <sln> does the install for pipelines and reports the reference.
    doctor now also finds TcUnit in the library folder of TwinCAT 4026 (PlcEngineering\Managed Libraries).
  • Condition window: rewrite it, truth table - ⤢ in the Inline-Logic-View or Tools > Rewrite condition (TcAgent) ...
    Tab Rewrite: NOT inward (De Morgan), NOT inward with the comparisons turned (NOT (a < b) → a >= b), NOT outward,
    simplify, write out in full, = TRUE uniform or removed - before and after in the look of the editor, laid out with the
    formatter rules of the project, each proven over every combination and the code read again and checked; Apply
    replaces the condition in the editor in one step (Ctrl+Z takes it back). Tab Truth table: when it is TRUE or every
    combination (up to 10 sub-conditions), the combination of now marked, copy as a table. Tab Sub-conditions: value now
    and where the variables come from. docs/USER_GUIDE.md
  • Tools menu: Condition at the cursor (TcAgent) opens the Inline-Logic-View, Rewrite condition (TcAgent) ... the window.
  • TcAgent.exe condition --layout: each rewrite as the code that replaces the condition (code, checked again in
    codeChecked), the whole truth table in results; tc_condition offers turned comparisons.

Fixed

  • Search, documentation, risk and refactoring analysis save everything open in the IDE first (like tc_save), so code
    written with tc_plc_write is in the files they read; the search result says "saved first". Not in ask/propose mode -
    there objects with unsaved changes are read through the IDE. Changes to the code still go only through the IDE.
  • Documentation, risk analysis (tc_doc, tc_risk_rules, TcAgent.exe doc) and tc_refactor read the code from the saved
    project files as well, the IDE only for objects open with unsaved changes - the risk analysis over a project with 430
    objects crashed Visual Studio the same way as the search. The result is the same (checked on the example project).
  • tc_plc_search no longer crashes Visual Studio in big projects: it searches the saved project files (in seconds instead of
    minutes) and asks the IDE only for objects open with unsaved changes; reading every object through the IDE crashed
    devenv.exe (C++ exception in KERNELBASE, reproduced twice on a project with 430 objects, feedback FB-4E5119CA).
    source=ide keeps the old way.
  • tc_test_run: code in folders starting with _ (e.g. _this) now counts for "changed since the last
    download" - a changed test suite there was run with the old code (feedback FB-6BF3EC9E).
  • TcAgent.exe tcunit list|report|watch --attach [pid]: the solution of the running IDE, no --solution needed (FB-D902BE21).
  • A missing assembly after an update while TcAgent was running (e.g. TwinCAT.Ads on the first ADS call) now says so and
    asks to restart the AI client, instead of a bare FileNotFoundException (FB-A0080B14).
  • TcAgent.exe library / tc_library_save: a PLC project without a title says what to fill in (Title, Company, Version in
    the project information) instead of only "not a managed library".
  • tc_motion_add kind=nc_task returned an empty path and the next kind=axis found no Axes folder - the new NC task is
    looked up again by its name; tc_motion lists the tasks with their paths.
  • tc_coe action=add: the new entry no longer takes over "CompleteAccess" from the PDO entry it copies its format from
    (a single subindex was written as a complete access).
  • tc_refactor works in a solution with several PLC projects - it finds the project of the object (plcProjectPath optional);
    before it stopped with "Several PLC projects".
  • Editor context: two objects with the same name (e.g. a method Exchange in two FBs) no longer both appear as the
    open object.
  • tc_task set cores: a warning when a core is not a real-time core - the activation would fail.
  • TcUnit report showed old test texts after a run without download when only /// comments had changed: a run now
    saves what is open in the IDE before it reads the tests (texts and line numbers are current), and the report button
    of the window saves before it makes the report.
  • TcUnit tests of a PLC project kept in its own .xti file are found again (TcUnit Tests window, tc_test_run,
    tcunit list): the PrjFilePath of the .xti is relative to the .xti, not to the .tsproj (the .tsproj folder is still
    tried for older projects). A PLC project whose .plcproj is not found is now named with the path tried instead of being
    left out silently.
  • Knowledge > Sources: a commit in a source shows as an update of the installed items it touches. The content of the
    item in Git decides (git diff between the installed and the source commit), not a version number in its header; a
    source in a folder on this computer is read again whenever...
Read more

v0.54.0

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 09 Nov 22:06

[0.54.0] – 2026-11-09

The built-in knowledge in this version is TcAgent_Knowledge 1.1.0 (unchanged).

Added

  • Inline-Logic-View (Ctrl+Alt+B) - the condition under the cursor (IF, ELSIF, WHILE, UNTIL, a boolean
    assignment, also in a CASE branch) as a logic diagram: lamps with names and declaration comments, gates with
    right-angled lines, NOT as a dot; online everything fulfilled turns green and the top line says what is missing; scroll
    bars, branches fold by a click (⊟ folds all fulfilled ones). Members of a library base and enum values as array index
    are resolved.
  • Inline-Scope (Alt+click, Ctrl+Alt+T) - the history of variables in a popup: BOOL as steps, numbers as lines, enums with names;
    time axis 5 s to 10 min with mouse-wheel zoom, frozen it moves through the last 10 minutes; cursor with values,
    min/max, CSV; TcAgent.exe watch reads every 20 ms (only reads).
  • Conditions as logic (tc_condition, TcAgent.exe condition) - the sub-conditions of an IF, when it is true (prime
    implicants), rewrites that mean exactly the same (De Morgan inward/outward, simplify, write out in full, = TRUE
    uniform or removed), each proven over every combination; never a rewrite that changes the meaning, no simplifying with
    calls, no rewriting with AND_THEN/OR_ELSE. Online: each variable resolved through the declarations to its ADS path
    (inherited also from a library base, THIS^/SUPER^, reference, pointer checked for 0, array index read first, GVL; not
    read and said why: interface members, properties without monitoring, method locals, VAR_TEMP, calls), the value of every
    sub-condition, the result and what is missing for TRUE; the instances of a POU are found. The IDE window follows.
  • Formatter: brackets, lines and columns for conditions - 14 cond.* rules (one sub-condition per line, brackets
    around sub-conditions and groups, tight or spaced group brackets, NOT inside or in front, room for NOT, AND/OR at the end
    or the start, next lines under the bracket or indented, inner groups indented or flat, closing brackets, comparisons and
    comments in columns, IF( or IF (, also boolean assignments) and the profile conditions-aligned. Brackets are only
    added, never removed; the safety net checks the expression trees. Tested on 66,618 sections with several combinations.
    docs/FORMATTER.md
  • TcAgent settings window: Tools > TcAgent settings ... (also ⋯ in the TcAgent Chat and the Knowledge window) - every
    setting of TcAgent in plain words on pages (general and mode, target systems, gates and confirmations, knowledge and
    levels, advanced), with its value, where it comes from (default, saved, set from outside) and the details; Save writes
    settings.json and the running servers read it again at once; export and import. Built from one schema
    (TcAgent.exe settings [--set KEY=VALUE] [--export|--import]); a test checks that every variable the code reads is in
    it and in the User Guide (9 were missing there).
  • Release target systems, also for a time: Target systems in the settings window or TcAgent.exe targets add <netId> [--access read] [--until 1h|today|<date>] - write (and read) or read only, for good or until a time; a release that ran
    out stops at once. The user mode runtimes of this PC (their own AMS Net ID) are found and offered; "From routes ..." takes over targets from the ADS routes of the TwinCAT router (read only by default). Only a person
    releases (no agent tool), every change goes to the audit log, a refused call says why. Reading stays free for every
    target. targets.json applies to all projects on the PC, in addition to TCAGENT_ALLOW_TARGETS.
  • Formatter fixes found by the condition rules: a bit access (dwStatus.4) is read as one operand by the expression
    check of the safety net.
  • Reload settings without a restart: ⟳ Reload (F5) in the TcAgent settings window (or TcAgent.exe reload) - every running TcAgent
    reads settings.json, targets and mode, modules.json and the plugins again, the agent gets the new tool list, the chat says what changed.
  • ST formatter: Ctrl+Alt+F (or Tools > Format ST code (TcAgent)) formats the PLC object in the editor - indentation,
    case of keywords, spacing, aligned declarations, blank lines, long calls with one parameter per line, and brackets around
    AND groups inside OR so the order is visible. Declaration and implementation, also unsaved; Ctrl+Z takes it back.
    A safety net keeps the meaning (the same tokens, the same expression trees, a second run gives the same text); a part
    it cannot read stays unchanged. Every rule is configurable in formatting.json on the knowledge levels, with locks;
    // tcagent-format: off ... on and the pragma form keep sections as they are. TcAgent.exe format --stdin|--file|--show-rules.
    docs/FORMATTER.md
  • Formatter settings with a preview: Tools > Formatter settings (TcAgent) ... - every rule in plain words with its value and
    level, search, start from a profile, details of the selected rule; a change shows at once what it does (before | after,
    example or the open object, changed lines marked, in the font and syntax colors of the TwinCAT editor, light or dark); Save writes the changed rules into formatting.json
    of a level (TcAgent.exe format --save), locked rules stay locked. Wish a rule or feature ... opens a GitHub issue with
    the example of the preview. formatting.json is part of the knowledge backups.
  • Formatter layout rules: layout.blocks (one statement per line, block bodies on their own lines), layout.then (THEN/DO/OF
    at the end of the condition or on their own line), wrap.conditions + wrap.operator (long conditions and boolean
    assignments: one term per line at the weakest AND/OR), align.assignments, align.named-args, blank.around-blocks;
    profile structured. Checked on 66,618 parts of real code with several rule sets: no change of meaning, every result stable.
  • Formatter settings in German or English (by the answer language of the chat, English for every other language), values in
    plain words ("keep as written" instead of preserve); Format ST code speaks the same language.
  • Export and import of the formatter rules in the settings window (a formatting.json with every rule) and TcAgent.exe format --export.
  • Formatter rule comment.decl-position: the comment of a declaration above it or at the end of its line; the safety net checks that every comment is still there.
  • Formatter rules for CASE: comment.case-labels: enum writes a comment above each label that has none - the comment
    of the enum value from the DUTs of the project, otherwise its name; blank.case-branches puts a blank line between the
    branches, after the label line, or both.
  • Formatter rule layout.short-if: IF … THEN with one statement and END_IF on one line when it stays within the set
    number of characters; layout.long-if: expand gives a one-line IF that is longer than that its own lines.
  • Formatter rule space.tabs: a tab inside a line becomes spaces up to the next tab stop of indent.tab-width, so the
    text keeps its column (default); tabs in comments and strings stay.
  • Formatter rule indent.underscore: a name that starts with _ one column further left (in declarations or everywhere),
    so its letters line up with the other names.
  • An example for every formatter rule: the code as written and the result for each value, made by the formatter itself
    (TcAgent.exe format --examples) - in docs/FORMATTER_EXAMPLES.md (a test keeps it current)
    and in the details of a rule in the settings window.

Fixed

  • Selected rows in the dark theme (TcUnit Tests, Knowledge window, settings windows) were hard to read; they now take the
    colors of the VS theme.
  • The prompt list (/ in the chat) opened too low the first time; it has its full height at once.

v0.53.0

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 08 Nov 17:10

[0.53.0] – 2026-11-08

The built-in knowledge in this version is TcAgent_Knowledge 1.1.0.

Fixed

  • Own windows and dialogs (update, About, the knowledge dialogs, Ask from code, confirmations) show the TcAgent icon instead of the one of the IDE.
  • New code without a specification: outside a workflow the agent could create new functions without asking. Now TcAgent
    asks once per chat at the first new FB, program, function or method: go on without a specification, or clarify first.
  • The question about the specification follows the answer language of the chat (German or English), and the chat asks the agent
    to write what a person reads in a question, a specification or an advice in that language too, also as tool arguments.
  • Knowledge window: an item that waits for a plugin, a module or another TcAgent showed ✓ applies. It now shows ✗ needs …,
    the column Why says what is missing.
  • tc_check and TcAgent.exe check said OK despite compiler errors in solutions with several PLC projects, for example a
    program and a TcUnit project. The next PLC project clears the messages of the one before, and the error list was read only at
    the end, so only the last project counted. The list is now read after each PLC project; the same for analyze, tc_static_analysis and for
    tc_build checkAll=true, which also lost the messages of the build.
  • tc_test_results showed 0 failed in every suite and named no failed test. TcUnit writes the details of a test in
    several messages, the parser expected one line. A failure of a run that a reset cut off is no longer listed twice.
  • tc_lib_signatures ignored version: it returned the version the project resolves, labelled and cached it as the requested one.
    Another version now comes from the library export, with a note. Wrong cache entries are ignored.
  • tc_activate and tc_runtime_mode returned before the PLC could be read. They now wait for TwinCAT and the PLCs and report the
    states. tc_activate says when the target of the project changed. tc_runtime_mode warns if a PLC is in another state than before
    config mode.
  • tc_errors: runtime messages with their time, really sorted, and max means the newest ones.
  • tc_plc_online: a login says whether something was loaded (nothing, online change, full download). The state comes from the port of
    this PLC on the target of the project, not from port 851 of the local system.
  • tc_open waits until the TwinCAT project is loaded, instead of reporting that there is none.
  • tc_hmi no longer takes an HMI project from a folder next to the solution: it only names it. Projects in solution folders are found.
  • tc_io_scan says that no scan was made outside config mode, instead of "No I/O devices found".
  • tc_library action=resolve: the name alone is enough, and the answer is the effective version instead of *.

Added

  • Update notice with what is new: the notice of a new version shows the CHANGELOG.md sections of every version between the
    installed and the newest one (also versions that were never released on their own), not only the short text of the release.
  • Knowledge window: every list sorts by a click on a column header (again: the other way), and keeps the order when it is read again.
    Switching a module on or off reads the files again at once, so items that wait for it show it without a refresh.
  • Knowledge window: a … button picks a folder in the dialogs New source / Edit source and Levels (company, team, platform repositories; with several, it adds one). An empty name of a new source takes the name of the folder or repository.
  • Knowledge window, deleting a source: asks whether the items installed from it go as well - unchanged ones are uninstalled (a copy goes to the backups), ones you changed are kept as your own version.
  • Advisor (Shadow): an agent that reads and advises, never changes. tc_advisor keeps advice with evidence and a ready
    order in the project (.tcagent\advisor), a run is read only (TcAgent refuses every change). TcAgent.exe advise runs it
    without a window at night or after a failed pipeline, /advise in the chat. The Knowledge window has a tab Advisor: rate
    with one click, Act on it … puts the order into the chat and marks the advice sent; the agent marks it done when the work
    is proven, or you do. Advice can be deleted from the list. Several advice can be selected and rated, marked done, deleted or
    sent to the chat as one order at once. docs/ADVISOR.md
  • Review of a whole project: workflow project-review and prompt /review-prj - deterministic checks over everything first,
    then the structure, deep reviews of at most 10 hotspots, a report with a traffic light per area; findings become advice.
    TcAgent.exe advise --trigger project runs it without a window, e.g. once a month.
  • Advisor (Live): at the running plant, read only. /advise-live in the chat, TcAgent.exe advise watch notices a PLC or
    the runtime leaving Run, an exceeded cycle time and the fault signals of .tcagent\advisor-watch.json (by hand or in the
    chat), and starts a run with --run. A plugin brings its diagnosis skill and signals in an advisor.json. Before it reads
    code it checks that the project matches what runs (project name and build time on the PLC, newer sources, unsaved changes).
  • Knowledge follows the modules: skills, workflows, prompts, rules and lessons can name the modules they need
    (tcagent-requires-module: scope). While one is switched off they show needs module and do not take effect. Items that only
    name tools of a switched-off module stay active, with a note in the lists.
  • Specification before code: the new checkpoint spec-ok in the workflow new-feature. The agent interviews you, TcAgent then asks
    you itself to confirm the specification or to skip it, and until then the run writes no PLC code.
  • Agent guide: a result counts only with a tool output from after the last change, and a check-and-fix loop stops after 3 rounds
    or when the same error comes back.
  • Built-in knowledge TcAgent_Knowledge 1.1.0: workflows bug-fix, safe-activation, online-change, refactoring,
    library-update, io-commissioning; skills plc-spec-review, plc-fix-compile, plc-alarm-diagnosis, plc-traceability,
    plc-multi-review, plc-st-patterns, plc-skill-authoring, plc-retro; 14 prompts for them.
  • Skills, workflows, prompts, rules and lessons can name the plugin they need: tcagent-requires-plugin in their metadata, with versions
    (line-check >=1.2 <2.0). Without a fitting plugin that is ready and switched on, the item cannot be installed from a
    source, pull does not update to it, and an item already there shows needs plugin and does not take effect.
    The lists of skills and workflows say what is missing. tcagent-requires-tcagent: >=0.53 does the same for the version of
    TcAgent, for items that use something older versions do not have.

v0.52.0

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 04 Nov 22:36

[0.52.0] – 2026-11-04

The built-in knowledge in this version is TcAgent_Knowledge 1.0.0.

Fixed

  • Visual Studio start: TcAgent blocked the IDE for up to 9 s, which could bring up the bar saying that it does not respond. The chat window
    started the agent while it was created, on the UI thread of the IDE (a cold start of the agent took 8.8 s). The agent, the search for its
    program and the setup check at the start now run in the background; the window opens at once and shows "starting", the agent follows when the IDE has loaded (a question
    sent before that starts it right away). The stall monitor of the extension ticks every 250 ms instead of 50 ms and no longer
    names a tool of a server that has ended; the log says how long the chat window and the agent start took.
  • tc_find_references in big projects: no answer within 60 s, the IDE hung (one report ended with a crash of the IDE, its cause
    is not known). The text search read every object through the Automation Interface, on the UI thread of the IDE. It now reads
    the project files (unsaved changes are not included, the result says so), the tree paths come from the same files, and the
    whole call answers within about 45 s: the cross references get 25 s and 8 s for reading them, a second query does not queue
    behind one still running, and the text search is returned in any case.
  • Knowledge window, tab Platforms: Delete on a platform connected through TCAGENT_PLATFORMS ended with "not a file of a knowledge level". It
    now detaches the platform, after asking; its files stay where they are.
  • tc_delete without name or parentPath says what is missing instead of "Value cannot be null (source)".

Changed

  • The built-in knowledge (skills, prompts, workflows, risk rules) now lives in its own repository
    TcAgent_Knowledge, included as the Git submodule knowledge/: every TcAgent version
    ships a known state of it. Nothing changes in the package; clone with --recurse-submodules.
  • Knowledge window: the tab Documentation is now Reference ("Manuals, datasheets and library docs the agent searches",
    tc_docs) - it is not documentation of TcAgent and not the templates. The texts of the window say "reference source".

Added

  • General TwinCAT risk rules shipped with TcAgent (knowledge/risk-rules/twincat-general.md): 11 rules and 21 agent checks for
    every project (several based on the Top 20 Secure PLC Coding Practices), in addition to the rules in the code. Pipelines: two of them are high (password in the code, __NEW
    without __DELETE), so doc --risks --fail-on high can fail where it passed before.
  • New versions in the TcAgent Chat (src/Updates.cs, vsbridge/ChatUpdates.cs, TcAgent.exe update): once a day, after the
    IDE has loaded, the extension asks GitHub for the releases (an anonymous request; pipelines and the agent never do). A newer
    version shows a line above the conversation and a dot on ⋯, What's new the release notes down to the installed version,
    with Download, Install, Open on GitHub, Skip this version and Later. The download only starts on a click and must match
    SHA256SUMS.txt of the release; Install opens the VSIX installer, nothing installs silently. The XAE Shell keeps the browser
    download and the documented steps of the ZIP. Switches in About; updates.json on the company or team level locks them.
  • Reset TcAgent (Knowledge window ⋯ > Reset TcAgent, TcAgent.exe reset): back to a fresh installation, to choose levels, platforms, sources and
    plugins again. Confirmed by typing delete all. Nothing is deleted: your knowledge, plugins and modules move to
    %LOCALAPPDATA%\TcAgent\reset-<date>\, the connections leave settings.json. Projects with their .tcagent stay as they are.
  • The knowledge repository as a predefined source: tcagent-knowledge (TcAgent_Knowledge) stands in the tab Sources from the start, so
    newer skills, prompts and rules can be installed between two versions of TcAgent. Nothing is read from it until somebody browses
    it or installs an item; it needs Git. Switch in ⋯ > About TcAgent, "knowledgeSource": false in updates.json locks it off.
  • Newer versions in the repo sources: once a day the sources in use are fetched (no pull, no sign-in window) and a line in the
    chat leads to the tab Sources.
  • About TcAgent (⋯ > About TcAgent, TcAgent.exe about --json): author, license, the versions of the extension, server, IDE and
    TwinCAT, the components with their licenses (the license texts in a window), the update switches. ⋯ also has Check for updates, which
    always answers in a dialog.
  • Shared folders in the TcAgent Chat (src/SharedFolders.cs, vsbridge/ChatShared.cs, TcAgent.exe shared): Attach … > Share a
    folder, a folder dropped on the input, or ⋯ > Shared folders. The agent reads these folders without asking; changing a file there
    still asks. A question decides for folders and files: only this chat, or kept in the knowledge for this solution or all
    solutions (a file as a copy). The list stays on this PC, goes with Backup and Restore, and kept folders are also Reference
    sources for tc_docs. Drives, the user profile, its key folders and system folders are refused, with the reason.
  • Answer language in the TcAgent Chat (⋯ > Answer language): the language of Windows (new default), the language of the
    question, or one of the languages of the Windows user (answerLanguage in chat-backends.json). Before, the answer
    followed the question, so prepared prompts in English gave English answers.
  • Prepared prompt /check-coding-rules: compares the open object with the coding rules, apart from the risk analysis.
  • Prompt list: right click Edit opens your own prompt, Edit my copy a copy of a built-in, company or team prompt on your level.
  • Prompt list: it keeps one height while it is open, also with another category or a longer preview, so the categories stay under
    the mouse. Many categories wrap and scroll from the fourth row on.
  • Prompt library (src/Prompts.cs, vsbridge/ChatPrompts.cs, docs/KNOWLEDGE_LAYERS.md):
    prepared prompts as a new kind of the knowledge - prompts\<name>.md on every level, kind Prompts in the Files tab
    of the knowledge window, from repositories through Sources, in the backups. In the TcAgent Chat / at the start of a
    line or the button Prompts opens a list above the input with search, categories and a preview; Enter inserts the
    prompt (it is not sent, it can be adapted), Ctrl+Enter inserts and sends. {object}, {selection}, {solution} are
    filled from the editor; other values are asked in a card: {input:…} in the text (|a|b a choice, =value a default)
    or params: in the header (types text, number, choice, bool, pou = search list of POUs, GVLs and tasks; default, options,
    required, help); tcagent-send: true sends right after the card; recently used prompts come first; Save as prompt … under
    an own message. Six neutral prompts are shipped, one example for every form. TcAgent.exe prompts [--json].

Known issues

  • The bar of Visual Studio about TcAgent can still appear on a start; blocks of several seconds remain while TwinCAT loads the project. Their
    cause is being looked at for 0.52.1.
  • tc_find_references is not yet confirmed on a very large project, also for 0.52.1.

Assets

  • TcAgent-0.52.0.vsix - Visual Studio 2022: double-click (close Visual Studio first)
  • TcAgent-XaeShell-0.52.0.zip - TwinCAT XAE Shell (preview): unblock the ZIP first (Properties > Unblock, or Unblock-File), extract it, run install-xaeshell.ps1 (see docs/INSTALLATION.md)
  • SHA256SUMS.txt - checksums of both packages

Full changes: v0.51.0...v0.52.0

v0.51.0

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 02 Nov 22:17

[0.51.0] - 2026-11-02

Added

  • Modules (src/Modules.cs, docs/PLUGINS.md): the tools in 13 modules (core, plc-code, test,
    runtime, io, motion, hmi, scope, safety, docs, knowledge, packages, system) that can be switched on and off in a
    modules.json on the company, team, user and project level – company and team can lock a module, core stays on, a
    module needing a switched-off one is off too. A switched-off module is not in the tool list of the AI client and its
    tools are refused with the module's name; the command line keeps every tool. TcAgent.exe modules [enable|disable].
    The server tells the client when the tool list changes with the solution (tools.listChanged).
  • Plugins (src/Plugins.cs): own tools as programs in any language speaking MCP over stdin/stdout, in
    <level>\plugins\<id>\plugin.json, offered as x_<id>_<tool>. Every call goes through the policy, the confirmation
    and the audit log with the class the plugin declares (undeclared = changing, confirmed every time); a plugin uses
    TwinCAT through tcagent/call, i.e. through the built-in tools with all their checks. Plugins of the team and project
    levels run only after TcAgent.exe plugins approve for exactly their content (SHA-256); the company level can allow
    all, none or listed plugins. Example plugin docs/plugins/todo-finder (PowerShell).
  • Tab Modules in the Knowledge window (vsbridge/KnowledgeModules.cs): a check box per module for me (default) or
    this project, grey with the reason when it cannot be changed here; the plugins of every level with their state;
    Approve plugin … shows the program, folder, level, tools and hash - only a mouse click on Approve approves (no
    Enter, no keyboard, no UI automation); details with the tools, dependency, window and the modules.json of every
    level; the status line counts the modules, plugins and tools the agent sees. TcAgent.exe modules --json lists the
    tool names and every level's settings, TcAgent.exe plugins --json the plugins.
  • The TcUnit Tests window stays open when the module Tests is switched off and says so, with "Switch on (for me)".

Changed

  • Documentation: the TcUnit window follows runs started elsewhere (user guide, README), tc_test_results reports only
    the last run, tc_plc_create explains reserved names, the warning about TFS/VSS source control bindings (tc_attach,
    troubleshooting); the XAE Shell installation shows how to unblock the ZIP in PowerShell (Unblock-File) before
    extracting it; modules and plugins in the README, TOOLS.md, KNOWLEDGE_LAYERS.md, PIPELINE.md and the agent skill;
    the live times of the TcUnit window in TCUNIT_TESTS.md.

Fixed

  • XAE Shell: no TcAgent window after installing from a ZIP that was not unblocked. Every extracted file kept the mark
    "downloaded from the internet" (Zone.Identifier), install-xaeshell.ps1 copied it along, and the shell (.NET Framework,
    no loadFromRemoteSources) refused to load the marked TcAgentBridge.dll (0x80131515) - no window, no setup on the
    first start, %LOCALAPPDATA%\TcAgent\app empty, while the script reported success. The script now stops before
    installing (also with -BuildOnly) and says what to do: Unblock the ZIP, extract it again, run it again. It never removes
    the mark itself - that stays the user's decision.
  • TcUnit Tests window: the time of a suite and the total stood still while a test ran - they only counted finished tests.
    Now they count the running test too and go on every half second, like the line of the test itself; the progress line
    shows the time of the run as well ("Running · 120 of 3751 · · 2:13 min"), so a long test does not look like a hang.
  • TcUnit run: up to a minute (and more) between the end of TcUnit and the result in the window. After every run TcAgent
    read the IDE error list (up to 20,000 entries, up to 15 times) for the failure texts - slow with thousands of tests, and
    even without a failed test. Now only when a test failed, within 15 s; the window shows the numbers at once ("reading the
    failure messages …") and the texts follow.
  • The MCP server ignores a byte order mark at the start of the input (clients on .NET Framework write one).
  • The Knowledge and TcUnit windows close the input of the TcAgent.exe they start: an older TcAgent.exe that does not know
    a command (and starts the MCP server instead) ends at once instead of waiting.

Assets

  • TcAgent-0.51.0.vsix - Visual Studio 2022: double-click (close Visual Studio first)
  • TcAgent-XaeShell-0.51.0.zip - TwinCAT XAE Shell (preview): unblock the ZIP first (Properties > Unblock, or Unblock-File), extract it, run install-xaeshell.ps1 (see docs/INSTALLATION.md)
  • SHA256SUMS.txt - checksums of both packages

Full changes: v0.50.0...v0.51.0

v0.50.0

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 01 Nov 16:01

[0.50.0] - 2026-11-01

Added

  • TcAgent with the TwinCAT XAE Shell alone (no Visual Studio 2022, no build tools) – preview: tested in the 32-bit shell
    on a PC that also has Visual Studio 2022 (shell-only simulated with TCAGENT_IDE_ASSEMBLIES); a PC without Visual
    Studio 2022 and the 64-bit shell are not tested yet. Every release gets the package
    TcAgent-XaeShell-<version>.zip (built by build-vsix.ps1) with the extension prebuilt for the 32-bit shell
    (bridge-vs15, built against the shell) and the 64-bit shell (bridge-vs17, the Visual Studio 2022 build - not tested
    in that shell yet), the server and install-xaeshell.ps1. The script installs from the package without compiling and
    copies the server into the extension's folder; on its first start the shell sets TcAgent up like Visual Studio does
    (server to %LOCALAPPDATA%\TcAgent\app, interop from TwinCAT, AI clients after asking).

  • install-xaeshell.ps1 -Vsix <file>: from the source, the server for the shell comes from a VSIX file instead of the VSIX
    installed in Visual Studio 2022. -BuildOnly also checks a package.

  • TcAgent.exe diag names where the IDE automation (EnvDTE) was loaded from.

  • TCAGENT_IDE_ASSEMBLIES: further folders with the IDE's automation assemblies (a shell installed elsewhere).

  • Source control bindings warning: a solution still bound to TFS/VSS (the section in the .sln, Scc*/SAK entries in the
    project files, .vspscc files) made the IDE crash or refuse changes ("Cannot insert project") while TcAgent edited it -
    tc_attach and doctor --solution now warn and say how to unbind; TcAgent does not change these files.

  • tc_plaintext / st import: fromPlc / --from-plc <name> - import a text folder that was exported from a PLC
    project with another name; without it the warning lists the folders found.

  • Delete feedback reports in the Feedback tab: Delete … (Del) asks first (default No) and then removes the selected
    reports and their status records from the feedback file for good (TcAgent.exe knowledge feedback --action delete --key <ids>); the file is held exclusively while it is rewritten, other TcAgent processes retry their append.

  • docs/UI_GUIDELINES.md – the UI/UX rules for every window and dialog of the extension (tabs and ⋯ menu, 4-6 main
    actions, master-detail, states as symbol and word, long actions in the background, keys, empty states, check boxes,
    visible safety information, vocabulary, privacy, theme colors, narrow windows, mockup before building); CONTRIBUTING.md
    and the agent guide (agents/TCAGENT_GUIDE.md, SKILL.md) point to it.

  • TcUnit progress block: the optional outputs Cycle and Cycles of the running test (shown as "cycle x/y").

  • The TcUnit window keeps the last 5 results of every test per solution (%LOCALAPPDATA%\TcAgent\tcunit\history.json).

Changed

  • TcAgent.exe is built against EnvDTE 8.0 (NuGet EnvDTE 8.0.2 / EnvDTE80 8.0.3 instead of 17.0, plus stdole
    7.0.3302 - Microsoft, Visual Studio SDK license as before, not shipped): it uses the EnvDTE of Visual Studio 2022 (17.0,
    compatible) or of the 32-bit XAE Shell (8.0), which it now also finds in the shell's folder. Tested: "check" in a hidden
    Visual Studio 2022 and in a hidden XAE Shell with the shell's own EnvDTE.

  • Messages without a server name the XAE Shell way too.

  • Knowledge window reworked after a UX review (vsbridge/KnowledgeWindow.cs):

    • Top bar with real tabs (the selected one underlined, a badge counts what needs attention there), the platform as a
      short link, ⟳ (F5) and a ⋯ menu with Levels …, Backup now …, Restore …, Refresh and Copy diagnostics.
    • New tab Backups; History is now Workflow runs (with a note instead of an empty chart while there are fewer
      than two runs).
    • Overview starts with what the agent gets in this project (each entry opens the Files tab with that kind) and
      Needs attention (items from a source changed or newer, Git changes, documentation not reachable, open
      blocker/major feedback) with links to the tab; rates show "—" and "needs 5 runs" until there are 5 runs.
    • States as symbol and word instead of a colored dot: ✓ applies, ↷ replaced, ⊘ switched off, ✎ changed locally,
      ↑ newer in the source, ⇅ both changed, ✗ missing, ⚠ not reachable, ○ empty.
    • Files: one toolbar row with Switch off ▾ (for this project / for me) and Source ▾, filters in their own row
      (search with hint and ✕, Ctrl+F), kinds as words, a detail header with the fitting actions as links and the file
      folded; the columns Git and Why only while a line has something in them (Source / license gets the room).
    • Sources: Browse and install … first and highlighted, rare actions under More ▾, Check for updates and Update
      all next to the heading, Copy URL, the output folded while it is empty, empty states.
    • Browse and install dialog: search, kind filter, "Only not installed", state column (installed where, not
      installable), details of the selected line, several items ticked with check boxes (the ticks stay when the filter
      changes; Space ticks the line) instead of a Ctrl/Shift selection that one click beside it would lose.
    • Platforms: the decision for this project on top with Set for this project … and Detect automatically.
    • Documentation: search like the agent right in the tab (Enter), state "○ empty – use Add documents …" in grey instead
      of an error, shorter intro.
    • Feedback: "Show:" filter label, the issue text as an editable section with its own heading.
  • The IDE stays responsive: every call of TcAgent.exe from the knowledge window runs in the background with a thin
    progress bar; before, many actions (merge, propose, backup, restore, platforms, feedback text) blocked the IDE until
    they were done. Calls from the background now also pass the open solution (it was missing there).

  • Feedback: successes and hints in the status line or a yellow info bar below the tabs (with a link such as Open
    folder) instead of a dialog to click away; errors stay dialogs. Long texts in confirmations (merge preview, update
    plan, restore difference, install list) scroll; for risky steps Enter cancels. The status line shows on the right
    what the tab holds.

  • Buttons follow the selection: they are only enabled when they fit the selected entry (toolbar and context menu).

  • Keyboard: F5 refreshes and Ctrl+F jumps to the search box while the window is active (the IDE no longer takes
    them); Enter opens and Del deletes in every list; toolbar buttons can be reached with Tab.

  • Dialogs in the colors of the IDE (light, dark, blue), OK only when the input is valid (checked while typing, the
    reason below the field), the restore choice and the backup list with a filter.

  • TcUnit Tests window in the same style (vsbridge/TcUnitWindow.cs):

    • Tool bar with words: Run all, Run selected (runs the ticked tests), Run failed, Stop, Report and ⋯ (Refresh F5,
      Expand/Collapse all, Save/Load selection …).
    • The counters as labelled filter chips All / Passed / Failed / Off, next to the search (Ctrl+F).
    • Progress line "Running · 4 of 18 · · about … left", afterwards "✖ 2 failed · 16 passed · 24 switched off ·
      time · target …" in red or green.
    • Columns Test / Description / Result / Time instead of Duration / Traits / Error Message; the result as symbol and
      word, for suites in words ("✖ 1 failed · ✔ 3 passed").
    • Suites switched off for the run as one line "⊘ switched off (n)".
    • A test over many cycles shows "◐ running · cycle x/y" (from the progress block) or its running time.
    • Details like the HTML report: Expected / Actual / Message, code link, enable bool, Run again, Copy failure, the last
      5 runs of the test; build errors of a run appear there too.
    • The legend of the symbols in the status line; colors for the light and the dark theme.
    • Check boxes stay the way to choose tests – a click beside them loses nothing; a grey one says why ("no enable bool –
      runs only with its whole suite or Run all").
    • The root line says "runs suites in sequence" / "in parallel" instead of the TcUnit call; top right the state of the
      runs with the target ("Not run yet · 9 tests · target: local runtime").
    • Runs started elsewhere are shown too: a run started in the IDE (activate, login, start), by another client or
      a pipeline on the target of the window appears live like a run of the window. New command TcAgent.exe tcunit watch (the window starts it in the background): reads only over ADS – PLC state, TcUnit's progress and the enable
      bools that decide which tests run; it writes, resets and starts nothing, and the target must be allowed like for
      ads_read. Before, only runs of the window itself and of tc_test_run were shown.
  • TcAgent Chat in the same style (vsbridge/ChatView.cs, ChatWindow.cs, ChatCards.cs, ChatAcp.cs):

    • The result of "Set up clients" as one line in an info bar ("TcAgent x is set up for n clients – restart the open
      ones") with Details (left-aligned, user folders as %LOCALAPPDATA% / %USERPROFILE%) and Copy - no longer a
      block of centered paths in the conversation. Other notices are one left-aligned line.
    • The start shows suggestions to click instead of a welcome text.
    • The backend with a short name ("Claude Code") and a dot for its state: ready / starting or working / error (the
      reason in the tooltip and the status line); a backend that starts per question is checked for its program.
    • Tool calls as compact lines: ◐ while running, ✓ / ✗ with the first line of the result and the time, details
      (parameters and result), diff for tc_plc_write / tc_plc_create (the saved object against what the agent
      writes, compare window...
Read more

v0.48.2

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 31 Oct 14:21

[0.48.2] – 2026-10-31

Fixed

  • vsbridge\install-xaeshell.ps1: the build for the XAE Shell failed with CS0234 (SVsDifferenceService,
    IVsDifferenceService, __VSDIFFSERVICEOPTIONS in Microsoft.VisualStudio.Shell.Interop) - the compare window of the
    knowledge window needs Microsoft.VisualStudio.Shell.Interop.11.0, which is now referenced from the shell's own
    assemblies. A missing interop assembly of the shell is explained in the output.
  • vsbridge\install.ps1 and uninstall.ps1 without administrator rights stopped with an UnauthorizedAccessException
    (uninstall even silently did nothing); both now check the rights before changing anything and say what to do
    (PowerShell "Run as administrator", or the VSIX, which needs no rights).

Added

  • install-xaeshell.ps1 -BuildOnly: only builds for the XAE Shell (normal user, nothing installed, no prompt).

v0.48.1

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 27 Oct 23:27

[0.48.1] – 2026-10-27

Release since v0.28.5: the knowledge of TcAgent in levels (company, user, team, platform, project) with skills,
workflows and Git sources, self-improvement from run logs, a knowledge window to manage all of it, backups of the
knowledge, a chat window on the Agent Client Protocol and issue forms with anonymized reports. The internal versions
0.29.0 to 0.48.0 were not published; their changes are summarized here.

Added

Client neutrality

  • tc_ask_user: questions of the agent with options (recommended first) and a free answer in every AI client – a card
    in the TcAgent Chat, the client's own question dialog (MCP elicitation) elsewhere.
  • %LOCALAPPDATA%\TcAgent\settings.json as the single source of TcAgent's settings and of the registered server;
    setup-clients.ps1 sets up every client from it. TcAgent.exe applies its env at every start (a variable set by the
    client or the pipeline wins).
  • AGENTS.md as the single guide file in a project (CLAUDE.md and GEMINI.md import it).

Knowledge levels and platforms (docs/KNOWLEDGE_LAYERS.md)

  • One scheme for coding rules, risk rules, skills, workflows, lessons, documentation sources and templates on the
    levels built-in → company (TCAGENT_COMPANY) → user → team (TCAGENT_TEAM, several with ;) → platform → project;
    the later level wins. One file per topic, front matter in the Agent Skills format with tcagent-locked /
    tcagent-force, disabled.json switches files off without changing them.
  • Platforms (automation frameworks): <company or user>\platforms\<name>\ or own repositories (TCAGENT_PLATFORMS);
    set in .tcagent\config.json or detected from the referenced libraries and terms of platform.md, ambiguous → the
    agent asks.
  • tc_knowledge (platforms, effective, why, disable/enable, split), scope=team|platform:<name> for the tools that add
    rules, skills and lessons; a shared level in Git changes by a commit on a new branch for a pull request, never pushed.

Skills and workflows

  • Skills in the open Agent Skills format (<level>\skills\<name>\SKILL.md), tc_skills (list, show, add, mirror),
    built-in TwinCAT skills requirements-interview, plc-debugging, plc-code-review. The skills that apply everywhere
    are mirrored into the skill folders of the agent CLIs – by the client setup and at every server start, only what
    changed (TCAGENT_SKILL_MIRROR=0 switches it off).
  • Engineering workflows with checkpoints (<level>\workflows\<name>\WORKFLOW.md, check-ok, build-ok, tests-ok),
    tc_workflow, built-in workflow new-feature (requirements → change plan → code → check → build with 0 errors →
    tests → review → save). A checkpoint step runs the check itself.
  • Hard gate before tc_activate: a build with 0 errors first (TCAGENT_ACTIVATE_GATE=0 switches it off); the refusal
    tells the agent to show the errors and ask before changing code.

Self-improvement

  • Run logs of the workflows, locally in %LOCALAPPDATA%\TcAgent\runs\ (counts and names only, last 100 runs).
  • tc_improve: KPIs per workflow, proposals by fixed rules (step hints, revert, promote lesson, frequent error,
    duplicate lesson, stale tool), apply after asking, evaluation over the next 10 runs, revert, promote with a check for
    project and machine names (privateTerms).

Sources: skills, workflows and rules from Git repositories

  • tc_sources and TcAgent.exe sources: add a repository, search, install (license check: MIT, Apache 2.0, BSD, ISC
    accepted with their notice, source-available and unlicensed refused, others only after confirmation; scripts are
    listed, never run), status, pull, diff, promote. <level>\skills.lock.json pins every item (commit, checksum,
    license); TcAgent.exe sources sync restores exactly these in a pipeline.
  • Overlay skills (metadata.tcagent-extends) adapt a general skill without copying it.
  • Install into every level; a level kept in Git gets a commit on a new branch for a pull request.
  • Local changes of installed items: the state locally changed / upstream newer / both changed (checked on opening,
    refreshing and saving); compare with the installed version (compare window of Visual Studio), revert, keep as own
    version (tcagent-detached), update and merge three-way (conflicts in the merge window of Visual Studio), propose
    upstream as a pull request (a branch in a working copy of the source plus a patch – pushed only when you confirm, to
    the source or your fork), uninstall. tc_sources action=changes|merge|propose|revert|detach|uninstall.

Knowledge window (View > Other Windows, or ⋯ > Knowledge in the chat)

  • Overview (KPI tiles, workflows, improvement proposals), Files (every knowledge file of every level with its status:
    new, add existing, open, rename, move to level with name check, switch off/on, delete, copy path; Git per level with
    fetch, pull, commit, push), Sources (sources and installed items with all actions above, browse and install),
    Platforms (detection, set for the project, new, delete), Documentation (every source of tc_docs with its state:
    add links, folders and documents, search like the agent with hits that open – PDFs on the page of the hit), Feedback
    (see below), History (workflow runs, adopted changes, backups), Levels … (company, team and platform folders in
    settings.json).
  • One vocabulary and order in every tab; toolbar and context menu show the same actions; errors as a message.
  • TcAgent.exe knowledge json|new|move|rename|delete|disable|enable|git|platform|docs|feedback|settings – the actions
    of the window for scripts.

Backup and restore of the knowledge

  • Every level is backed up automatically before every change (knowledge window, chat tools, command line) as a ZIP with
    manifest.json (TcAgent version, level, SHA-256 of every file), only when it changed since its last backup, the last
    20 per level, in %LOCALAPPDATA%\TcAgent\backups\knowledge\. A level in Git: its uncommitted changes only.
  • Restore of the whole level, one file or one skill/workflow: the difference first, then the confirmation; the current
    state is backed up before. Backup … / Restore … in the knowledge window, TcAgent.exe knowledgebase list|backup|diff|restore.

Chat window

  • The chat speaks the Agent Client Protocol (ACP): a persistent session, live text and tool calls, permission cards,
    Stop as session/cancel. GitHub Copilot is the first ACP backend (copilot --acp); setup-clients.ps1 switches the
    former Copilot entry over. The stream-json way stays for Claude Code.
  • Copy diagnostics in the ⋯ menu.

Tests and deterministic first (docs/DETERMINISTIC_FIRST.md)

  • tc_test_skeleton: the TcUnit test suite of a function block, generated the same way every time (enable bools,
    an InitialOutputs test, one test per public method with every parameter, naming and folder of the existing
    suites, instanceName).
  • The TcUnit Tests window shows a run started by an AI client live.

Feedback and support

  • The knowledge window anonymizes tc_feedback reports (names of computer, user, solution and projects,
    privateTerms, user folders, paths, IP addresses / AmsNetIds) for editing and opens them as a prepared GitHub issue –
    you check and send it yourself.
  • TcAgent.exe diag: versions of TcAgent, extension, TwinCAT and IDEs, runtime state, Windows, .NET, knowledge levels
    as a Markdown list without names or paths.
  • GitHub issue forms (bug report, feature request, reports from TcAgent) with a Diagnostics field, questions in the
    GitHub Discussions, private security reports (SECURITY.md).

Runtime data backup – experimental

  • tc_backup / TcAgent.exe backup|restore: persistent variables, the RETAIN/PERSISTENT variables of the code and
    include patterns (recipes, parameters; .tcagent\backup.json) via ADS into one JSON file per PLC; diff; restore
    writes only values that differ to symbols that exist with the same type, only to allowed targets, after confirmation
    and with the PLC stopped unless whileRunning. Experimental: not yet tested against a running PLC.

Changed

  • Coding workflows end with a build with 0 errors, always preceded by tc_check (a pre-compile without code
    generation); the guidance of every agent says so.
  • Agents change code only when the user asked for a change; errors found on the way are reported and the user is
    asked.
  • tc_coding_rules shows the level of every rule file and the platform of the project and lists skills and workflows.
  • Documentation sources are read from every level including the team levels; tc_docs action=sources shows level and
    state; tc_docs_add refuses entries that are neither a URL nor a folder.
  • TCAGENT_LESSONS keeps working; TCAGENT_TEAM\lessons\ replaces it.
  • TcAgentBridge serves several requests at once; messages name no single AI product.
  • setup-clients.ps1 writes a configuration only when it changes and keeps the first and the last 3 backups per file.

Fixed

  • A running chat session kept talking to the server it started with after a TcAgent update; it now restarts with the
    new server. Changes of chat-backends.json take effect without restarting Visual Studio.
  • A test run started from the chat blocked the IDE briefly for every event.
  • tc_test_skeleton left out required inputs, which did not compile.
  • Names with capitals or spaces (platform, skill, source) were refused with a message in the status line only.
  • The backup list in the History tab got no height in a smaller window.

v0.28.5

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 25 Oct 10:04

[0.28.5] – 2026-10-25

Changed

  • TcAgent Chat: permission questions and follow-up questions of the agent are cards in the conversation instead of
    separate dialog windows. A permission card offers Allow once, Allow for this session and Deny. A question card shows
    its options to click, a field for another answer, Answer and Skip. After the answer the card stays in the conversation
    with the decision. New chat, Stop or the end of the session answer an open card with Deny / not answered.
  • TcAgent Chat top bar: only the backend, New chat and a ⋯ menu remain. The menu holds Send editor context,
    Check after changes, TcUnit Tests, Set up clients and the version. The version shows in the top bar only when the
    server and the extension differ or the server is not set up.
  • The agent in the chat knows that permission questions are shown to the user, so it no longer claims that there was
    no question. An error after an allowed call is a real tool error.

[0.28.4] – 2026-10-24

Added

  • TcAgent Chat (Claude Code backend): when Claude needs a permission its rules do not give, e.g. reading a file
    outside the solution folder and the shared folders, the chat window now asks. Options: Allow once, Allow for
    this session
    (the rule Claude Code suggests, e.g. Read in that folder, until the chat session ends) or Deny
    (default; closing the dialog = deny). Before, such calls were refused without a question and the agent only reported
    that it had no access. Technically: the persistent session runs with --permission-prompt-tool stdio and the window
    answers the can_use_tool requests.
  • TcAgent Chat (Claude Code backend): follow-up questions of the agent come as a dialog. Each question shows its
    options to click, with their descriptions (several at once if the question allows it), plus a field for a free answer.
    The answer goes back to the agent, and Cancel tells it that the question was not answered. The agent is asked to use
    this tool (AskUserQuestion) for decisions instead of ending its answer with a question.

Fixed

  • tc_check / TcAgent.exe check ("Check all objects") crashed the TwinCAT XAE Shell in solutions with Remote Manager
    3.1.4020.56 (access violation in TwinCAT System Manager.dll 4020.56, RPC 0x800706BE, unsaved changes lost;
    FB-23CB01DE, FB-BDB62B01, FB-CE48B5F9, FB-D1AD25B9). TcAgent called the newest ITcPlcIECProject* interface of its
    interop on the PLC project item from the tree enumeration. That item is a generic tree item; the call reached the
    old DLL with a method layout it does not have. Now the PLC projects are fetched with LookupTreeItem (the real
    project object), and CheckAllObjects is called by name (IDispatch). Checked with 4020.56 (library project plus TcUnit
    project, no crash, real results) and 4026.19.

v0.28.3

Choose a tag to compare

@ThorstenBrach ThorstenBrach released this 23 Oct 19:22

TcAgent 0.28.3

All changes since v0.26.2: 0.27.0, 0.28.1, 0.28.2 and 0.28.3 (0.28.0 was a local test build only).
Details: CHANGELOG.md. Guide for the new test window: docs/TCUNIT_TESTS.md.

Please read before updating:

  • Confirmations: when nobody can be asked, runtime actions are now refused. That happens in AI clients that have
    no question dialog. For pipelines or unattended agents, set TCAGENT_CONFIRM=off deliberately.
  • Plain-text ST files have a new format. st export rewrites text folders of earlier builds, and importing an old
    folder is refused until it has been exported again.
  • Report command: a report command in .tcagent\tcunit.json runs only after you approve it once.

Highlights

TcUnit Tests window (0.28.1, 0.28.2)

A window in Visual Studio 2022 and the TwinCAT XAE Shell, close to the Visual Studio Test Explorer. Open it with
View > Other Windows > TcUnit Tests, or with the Tests button of the TcAgent Chat.

  • Tree: PLC project > suite instance > test, read from the code. The /// comments are the descriptions.
  • Toolbar: Run all, Run selected, Run failed, Cancel, Refresh, Expand all and Collapse all.
  • Filters and columns: status filter buttons with counts (combinable) and a search box. Resizable columns
    Test / Duration / Traits / Error Message.
  • Progress: "Test n of N" with % done and the remaining time, and the counter "n of N selected".
  • Details: description, setup, steps and expected result from the code; EXP / ACT / MSG, duration and code
    position. A double-click opens the test method.
  • Selection: tri-state ticks for partly selected suites. Test selections can be saved and loaded (*.tcunit.json).
  • Report button: HTML test report of the last run.
  • The tree is read again after a build and when code files are saved.

Test runs without IDE login, for agents and the command line

  • TcAgent.exe tcunit list | run | report and the tool tc_test_run (action=list|run).
  • The selection uses the enable bools bRunSuite / bRun_<TestMethod>, written via ADS before the start. Tests
    without these bools run as before, everywhere (test / sil / hil and pipelines unchanged).
  • A run, step by step:
    1. Build and activate only if the code changed since the last download.
    2. Reset the PLC via ADS, write the selection and start.
    3. Follow the live results per test from TcUnit's own test table.
    4. Reset again. TwinCAT stays in Run mode.
  • Output and control: one JSON event per line, and a line cancel on stdin stops the run. Optional JUnit file
    and progress block.
  • Selections: --tests @file / tests=@file runs a saved selection.
  • Configuration per solution: <solution>\.tcagent\tcunit.json (plcProject, target, timeout, progress,
    report, reportGroupBy).
  • Remote target: it must be allowed in TCAGENT_ALLOW_TARGETS. The window asks once per run.

HTML test report for every project

  • Built from the descriptions in the code:
    • suites and tests with result, duration, failure text, code position and enable bool
    • run information: target, git commit, TcAgent version, selection
    • search and filters, a summary per suite
  • Test case texts in the code: below its first line, a /// comment can hold the sections Setup:, Steps:
    (1. lines), Expected: (- lines) and Link:. tcunit list returns them as details; the window and the
    report show them.
  • Grouping: reportGroupBy (for example Blocks) adds a second view, grouped by a /// section, switchable with
    the suite view.
  • Results per run: kept in %LOCALAPPDATA%\TcAgent\tcunit\<solution>-<hash>\ as last.xml (JUnit) and
    last.json, outside the repository.

Security

0.28.3

  • Package manager: tc_packages_change no longer runs tcpkg through cmd.exe with administrator rights. Before,
    a feed name like x&calc went unchecked into that command line. Now TcAgent itself runs elevated (UAC prompt) and
    starts tcpkg.exe directly, without a shell, only from the program folders or C:\TwinCAT.
  • tcpkg values: checked before the confirmation and again in the elevated process. tc_packages checks them too.
    • package ids and versions: only [A-Za-z0-9._-]
    • feed names: words of these characters with single blanks
    • feed sources: an http(s) URL or an absolute folder
    • options: from a fixed set only
  • Confirmations: if nobody can be asked (no question dialog in the AI client, no TcAgentBridge dialog in the IDE),
    ads_write, activation, PLC start/stop and the other runtime actions are refused with a clear message. They no
    longer run unconfirmed. The command line (test, sil, hil, tcunit run) is not affected.
  • Report command: the report command of .tcagent\tcunit.json runs only after you approve it once per solution
    and command text, through a question in the window or tcunit report --approve <id>. Until then TcAgent's own report
    is made.
  • HTML report: all texts are HTML-encoded, links are only absolute http(s) URLs, and a Content-Security-Policy
    allows no external resources and no script but the report's own.
  • TcUnit runs:
    • The target of tcunit.json is named in the confirmation and checked against the whitelist.
    • Saved selections cannot set a target.
    • @file reads only *.tcunit.json / *.txt files.

0.27.0

  • Bridge pipe: TcAgentBridge.<pid> is open only for the user running Visual Studio / the XAE Shell, and only on
    this PC (own DACL, no network access). Before, Windows granted Everyone/Anonymous read access and the pipe was
    reachable over the network.
  • Bridge check: TcAgent only talks to a bridge served by Visual Studio or the XAE Shell, where the server process
    id must match the pipe name, and connects with impersonation level Identification. A foreign program behind the pipe
    name is refused, and a confirmation asked through it counts as "no".
  • Pipeline examples: pull requests from forks never run on the self-hosted TwinCAT runner. The GitHub workflows skip
    them, and the Azure Pipelines and GitLab examples name the setting that keeps them off.

Changed

  • Plain-text ST files (st export|check|import, tc_plaintext), new format:
    • every block: declaration, empty line, implementation indented by two blanks, END_ line
    • methods, properties and actions follow after the POU's own END_FUNCTION_BLOCK / END_PROGRAM / END_FUNCTION
    • no // @implementation lines any more
    • whitespace at line ends does not count as a change
    • round trip without changes for all checked objects
  • Dependencies: fixed versions of the shipped packages and a NuGet lock file (packages.lock.json), so the VSIX
    ships only license-checked versions. Beckhoff.TwinCAT.Ads is now 7.0.389 (current release line, MIT); PdfPig stays
    at 0.1.16.
  • THIRD-PARTY-NOTICES completed:
    • System.Reactive
    • the Adobe Glyph List (BSD-3-Clause)
    • the Adobe Core 14 AFM files embedded in PdfPig
    • the notices of the .NET runtime, shipped next to TcAgent.exe in the VSIX
  • setup-clients.ps1 also finds the configuration of newer Claude Desktop versions
    (%LOCALAPPDATA%\Claude-Data\...).
  • Agent guidance: agents write TcUnit suites with enable bools and a /// description per test, so the tests can
    later be selected one by one.
  • README: the source code contains no code from Beckhoff; the trademark owner is Beckhoff Automation GmbH & Co. KG.
  • Menu entry View > Other Windows > TcAgent Chat in Visual Studio 2022 and the XAE Shell.
  • Unit tests (dotnet test tests\TcAgent.Tests, no TwinCAT needed):
    • TcUnitDiscoveryTests for the test discovery and the selection
    • GuardsTests for the security checks
    • PlainTextRepositoryTests, objects of a real library with their reference text files
    • PlainTextLayoutTests, rewritten for the new format

Fixed

  • Updating %LOCALAPPDATA%\TcAgent\app\<version>\ while an AI client still runs TcAgent.exe from there: the
    running file is set aside and the new one copied. Before, the old TcAgent stayed in place ("still in use").
  • Test report, view grouped by reportGroupBy: the suite count of a group counts only the suites that ran.

Install

  1. Close Visual Studio / the XAE Shell.
  2. Double-click TcAgent-0.28.3.vsix.

If the same version is already installed, uninstall it first in Extensions > Manage Extensions. Your memory files in
%LOCALAPPDATA%\TcAgent are kept.