TcAgent

mcp
Guvenlik Denetimi
Gecti
Health Gecti
  • License — License: MIT
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Community trust — 11 GitHub stars
Code Gecti
  • Code scan — Scanned 12 files during light audit, no dangerous patterns found
Permissions Gecti
  • Permissions — No dangerous permissions requested

Bu listing icin henuz AI raporu yok.

SUMMARY

AI Agent for TwinCat

README.md

TcAgent

TcAgent – TwinCAT 3 for AI coding agents

Let Claude, GitHub Copilot, Gemini or ChatGPT/Codex work inside your running TwinCAT 3 IDE:
read and write PLC code, check and build, navigate, look up library APIs, configure I/O and tasks, control the runtime.

License: MIT TwinCAT 3.1 Visual Studio 2022 MCP

Video (60 s): from the device manual to the HMI page with one prompt - TcAgent reads the manual, adds and links the EL6001, writes the driver FB, tests it with TcUnit and builds the HMI page
▶ Click for the video in full quality – one prompt: device manual → I/O → driver FB → TcUnit tests → HMI.
The video is a generated visualization to illustrate the workflow more clearly – in practice TcAgent works exactly like this.


From the idea to the running machine

TcAgent does not stop at generating code. The agent works through the whole job in your IDE, and TcAgent holds it to your rules:
a workflow only goes on when its checkpoint is proven, and nothing reaches a PLC without a clean build, an allowed target and your confirmation.

The whole job in seven steps: understand, plan, implement, build, test, review, deploy. TcAgent enforces checkpoints at plan, build and deploy, and lessons, rules and skills stay for the next job.

Step What the agent does With
Understand Reads what you are working on, the project, the real library interfaces and your documents, before it changes anything tc_editor_context, tc_doc, tc_find_references, tc_lib_signatures, tc_docs
Plan Puts you through an interview first: every open decision, one question at a time with a recommended answer, until the specification is complete. No code before you confirmed it, or chose to skip it. Requirements get numbers if you need proof skills requirements-interview, plc-traceability, tc_workflow, tc_coding_rules
Implement Writes PLC code, step chains, I/O links and HMI pages, by your coding rules and from compiled patterns tc_plc_write, tc_plc_create, tc_sfc, tc_link, tc_hmi_page, skill plc-st-patterns
Build Checks without generating code, fixes errors in a limited number of rounds, then builds tc_check, tc_build, tc_errors, skill plc-fix-compile
Test Checks the logic against the requirement, writes and runs TcUnit tests, measures with Scope tc_test_skeleton, tc_test_run, tc_scope, skill plc-spec-review, TcAgent.exe sil
Review Looks for risks a compiler cannot see, by your rules and from several views tc_static_analysis, tc_risk_rules, skills plc-code-review, plc-multi-review
Deploy Activates or loads an online change step by step, and proves that it arrived workflows safe-activation, online-change, tc_activate, tc_plc_online

The same steps run without an AI in your pipeline, see In your CI pipeline. What the agent learns on the way stays
as lessons, rules and skills for the next job.

And after the deploy: the Advisor goes with the plant

The job does not end when the code is on the PLC. The Advisor stays with the project through all phases - it reads and
advises, it never changes the project or the PLC. Each finding comes with evidence and a ready order; you rate it, and
Act on it hands the order to an agent that works through the steps above.

The Advisor goes with the plant from development to operation: Advisor Shadow at night in the pipeline, Advisor Live at commissioning and in operation. It reads and advises, it changes nothing.

Phase The Advisor Started by
Development Shadow: at night, after a commit or a failed pipeline it reviews what changed and finds the cause - the findings wait for you in the morning TcAgent.exe advise --trigger nightly|commit|pipeline, /advise, /review-prj
Commissioning Live: at the running plant it reads values, step chains and I/O and tells you why a station hangs, in the conversation /advise-live in the chat
Operation Live: for maintenance it finds the cause of a fault - started by a person, or by a watch on alarms, PLC exceptions and your fault signals /advise-live, TcAgent.exe advise watch --run

Details: docs/ADVISOR.md.

What the agent can do

Area What it means for you Tools
Your context The agent knows the object, line and selection you are working on – ask "what does this do?" tc_editor_context
PLC code Read, change (optionally as a diff to approve), create POUs, methods, properties, DUTs, GVLs; implement interfaces in one step tc_plc_read, tc_plc_write, tc_plc_create
Plain-text ST The whole PLC code as .st files (one per POU with its methods/properties/actions) for reviews, Git diffs and bulk edits – and back into the project, Ids kept, nothing deleted; also as CI gate tc_plaintext
SFC step chains Read and write sequential function charts as text – steps, actions, transitions, alternative and parallel branches, jumps; renumber steps, step comments, SFC flags tc_sfc
Lessons learned The agent remembers hard-won solutions – what the problem was, why, and how it was solved – and recalls them by itself when the same error comes up again (project, personal or team file) tc_lessons
Chat history The TcAgent Chat keeps its conversations per solution on your PC: open the project again and ask where you stopped – the agent gets a summary with the open tasks of its plan and reads more when needed; ⋯ > Earlier conversations reads, continues or deletes one tc_chat_history
Program documentation Explains the project: call hierarchy, call graph, inheritance hierarchy, class diagram, step chains (SFC and CASE), a short description for every FB, method and function (from comments or derived from the code), findings – one HTML page with zoomable diagrams, explanations kept as project memory; task overview with cycle times and a static risk analysis tc_doc
User manual Manual of FBs, functions and their structs/enums – in the style of your own example documents (Markdown, AsciiDoc or HTML), missing comments explained from the code tc_userdoc
Formatting Ctrl+Alt+F formats the open object the same way every time - indentation, keyword case, aligned declarations, long calls, brackets that show the order of AND/OR, long conditions one operand per line with aligned brackets; every rule configurable per company, team or project, a safety net keeps the meaning, Ctrl+Z takes it back TcAgent.exe format – docs/FORMATTER.md
Inline-Logic-View Ctrl+Alt+B shows the condition at the cursor (IF, ELSIF, WHILE, assignment of a BOOL) as a logic diagram - online green where fulfilled, with the operands that are still missing, fulfilled branches folded; variables followed through inheritance, references, pointers and libraries; ⤢ opens the condition window: De Morgan, turned comparisons and simplifications with a proof that the meaning stays, applied into the editor with one click (Ctrl+Z takes it back), truth table tc_condition, TcAgent.exe condition
Inline-Scope Alt+click any variable in the code (or Ctrl+Alt+T) and see its value over time in a small popup - 20 ms samples, time axis from 5 s to 10 min, zoom with the wheel, pause and scroll back, CSV export; reads only TcAgent.exe watch
Refactoring Meaningful names and comments for what you marked or clicked – every change confirmed by you (Apply / Apply all / Reject) tc_refactor
Navigation Go to definition and find references (read/write) – resolved like TwinCAT itself, across inheritance; opens the object in the editor at the right line tc_goto_definition, tc_editor_open, tc_find_references, tc_plc_search
Library APIs Full interfaces of referenced libraries – also compiled libraries – so the agent never invents an API tc_lib_signatures, tc_plc_references
Check & build "Check all objects" without generating code; real build before activation; compiler vs. runtime messages separated tc_check, tc_build, tc_errors
Tests TcUnit tests read from the code and run like in the Test Explorer: window TcUnit Tests (also in the XAE Shell) with run all / selected / failed, live progress and red/green per test (also for runs started in the IDE or by a pipeline); the same run for agents and on the command line; evaluate TcUnit results; test suites of an FB generated as a skeleton tc_test_run, tc_test_results, tc_test_skeleton
I/O & system Scan EtherCAT and assign adapters, add masters, couplers and terminals offline, link variables in bulk (structs to PDO groups element by element), tasks and PLC task assignment, boot project, config/run mode, licenses (read) tc_io_scan, tc_io_add, tc_link, tc_task, tc_runtime_mode
Projects & files New solutions and PLC projects, PLCopen/XTI export and import, libraries (references, placeholders, repositories, save as library), mapping export/import, archive, TwinCAT version, target platform, variants tc_new_solution, tc_plc_project_add, tc_export, tc_import, tc_library, tc_library_save
Library supply chain SBOM of the PLC project as CycloneDX 1.6 (libraries with version, vendor, purl, SHA-256, git commit) and a library lock file whose check fails the pipeline when a library version changes tc_sbom, tc_library_lock
Quality Static analysis (TE1200) with SARIF export tc_static_analysis
Network ADS broadcast search, add routes, TcCOM module instances tc_route_search, tc_route_add, tc_tccom
System Real-time cores and base time, task core assignment, CoE startup lists of EtherCAT devices, TwinCAT Package Manager (installed/available/outdated packages, install and upgrade with confirmation) tc_realtime, tc_coe, tc_packages, tc_packages_change
IDE dialogs Modal IDE dialogs are detected and reported instead of blocking silently tc_dialogs
Scope Scope configurations (TE130x): charts, axes, channels on PLC variables, record, export CSV/SVDX – also from the pipeline tc_scope_new, tc_scope
HMI TwinCAT HMI (TE2000) pages and regions, controls with PLC bindings and button actions, symbol mapping, build – directly in the project files tc_hmi, tc_hmi_page, tc_hmi_control, tc_hmi_symbol
Motion NC tasks and axes, link an axis to its drive tc_motion, tc_motion_add
TwinSAFE Safety projects, groups, alias devices, connections, CRCs – read only, writing is intentionally not supported tc_safety
Runtime Activate, login/start/stop, read/write variables via ADS – changes only on allowed targets tc_activate, tc_plc_online, ads_read, ads_write
Your rules Coding rules per project/person/company; "remember that I want X" becomes a rule tc_coding_rules, tc_coding_rules_add
Your risk checks Extend the risk analysis with your own rules (regex, tested on the project first), tune or switch off the built-in ones, add checks the agent reviews by reading the code – per project/person/company tc_risk_rules
Skills & workflows How your team does a task, in the open Agent Skills format (built-in: requirements interview, PLC debugging, code review, spec review, alarm diagnosis, ST patterns and more), workflows with checkpoints TcAgent enforces (e.g. your confirmed specification before any code, tc_check with 0 errors before the review; activation only after a clean build) - also the review of a whole project (/review-prj), levels company / user / platform / project tc_skills, tc_workflow, tc_knowledge
Self-improvement Local run logs of the workflows (counts only), KPIs and trends, improvement proposals found by fixed rules – applied only after you agree, measured over the next 10 runs, reverted if they did not help; window TcAgent Knowledge with overview, effective knowledge, sources and history tc_improve
Advisor An agent that reads and advises, never changes: at night or after a failed pipeline it reviews what changed (Shadow), at the running plant it finds where it hangs (Live, also started by a watch); findings with evidence and a ready order - you rate them and send the order to an agent with one click tc_advisor, TcAgent.exe advise – docs/ADVISOR.md
Prompt library Prepared prompts in the TcAgent Chat: / or Prompts lists them with search and preview, placeholders from the editor; on every knowledge level and from Git repositories TcAgent.exe prompts
Settings & targets Tools > TcAgent settings: every TcAgent setting in one window with description and default, export/import, reload of the agent servers; target systems with read/write access (writing time-limited), imported from the TwinCAT routes TcAgent.exe settings, TcAgent.exe targets
TcAgent Chat Answer language, folders shared with the agent (read without asking, kept for this chat or in the knowledge), notice of new versions with release notes and a checked download, About with versions and licenses, Reset TcAgent ⋯ in the chat
Skill sources Skills, workflows and rules from Git repositories with lock file, license check, plugin and version check, and overlay; TcAgent.exe sources sync restores the pinned set in a pipeline tc_sources
Reference Beckhoff InfoSys, your URLs, document folders and network shares – read-only tc_docs, tc_docs_add
Modules & plugins Switch groups of tools on or off per user, project, team or company (a shorter tool list for the agent; the command line keeps everything); your own tools as plugins – any program that speaks MCP, with the same policy, confirmation and audit, project plugins only after your approval; tab Modules in the Knowledge window TcAgent.exe modules, TcAgent.exe plugins – docs/PLUGINS.md

All 100 tools with parameters: docs/TOOLS.md.

What you can do, explained step by step with example prompts: docs/USER_GUIDE.md.

In your CI pipeline

The same TcAgent.exe runs without an AI on a build server – check, build and TcUnit tests with exit code, JUnit XML
and annotations in the pull request:

TcAgent.exe check --solution MyMachine.sln --junit results\check.xml
TcAgent.exe test  --solution MyMachine.sln --junit results\tests.xml

Or describe the pipeline once in the repository (.tcagent\pipeline.json: doctor, check, build, doc, sil, ...) and let
every CI system – and your PC – run it with one command:

TcAgent.exe ci --init     # starter file with the solution found in the repository
TcAgent.exe ci            # runs the steps, each with a fresh IDE; summary in results\ci-summary.md

TcAgent.exe st export|check|import keeps a plain-text copy of the PLC code (.st files) next to the project –
readable diffs in pull requests, st check as gate, references.json with the library references of each PLC project;
no IDE needed: docs/PLAINTEXT.md.

Ready-made definitions for GitHub Actions, Azure DevOps, Jenkins and GitLab: docs/PIPELINE.md.
A GitHub runner on your PC, a VM or a Beckhoff IPC is set up with one script (setup-runner.ps1); TcAgent.exe doctor
tells you whether a machine is ready and what is missing – step by step in docs/RUNNER_SETUP.md.

Install

Requirements: Windows 10/11, Visual Studio 2022 with TwinCAT 3.1 XAE (tested with build 4026) and a
TE1030 license (TwinCAT 3 Documentation Generation).

  1. Download TcAgent-<version>.vsix from the releases, close Visual Studio, double-click the file.
    Only the TwinCAT XAE Shell, no Visual Studio 2022? Take TcAgent-XaeShell-<version>.zip instead (preview) – see
    docs/INSTALLATION.md.
  2. Start Visual Studio 2022 with your TwinCAT solution. TcAgent asks once whether it should register itself in the
    AI clients it finds (Claude Desktop/Code, GitHub Copilot in VS and CLI, Gemini CLI, Codex CLI). A backup of every
    changed config file is made.
  3. Ask your agent: "Connect to TwinCAT and show me the PLC project tree." – or press Ctrl+Shift+Q in the code.

No scripts, no administrator rights, no .NET installation needed. Details, client sign-in and troubleshooting:
docs/INSTALLATION.md. Building from source: Build.

TwinCAT XAE Shell: TcAgent controls the shell just like Visual Studio. For the chat window and the inline question in the
shell run vsbridge\install-xaeshell.ps1 once (shell closed, asks for administrator rights).

What changed in each version: CHANGELOG.md.

Use it where you work

Inline question – in the TwinCAT editor press Ctrl+Shift+Q, type, press Enter. You stay in the code; the answer
streams into the chat window. Conditions and values in the code – Ctrl+Alt+B shows the condition at the cursor as
a logic diagram (Inline-Logic-View), Alt+click on a variable (or Ctrl+Alt+T) opens the Inline-Scope. TcAgent Chat – a tool window with backend selection (Claude Code, Copilot CLI,
Gemini CLI, Codex CLI); the editor context is sent along automatically. Your prompts on the right, the agent's answers on
the left, ↑/↓ brings back earlier prompts, and documents (manuals, data sheets, screenshots, long texts) can be pasted or
dropped into the input box for the agent to use. Any MCP client – Claude Desktop, Copilot agent mode in Visual Studio,
or a CLI in your terminal use the very same tools.

Client How it is connected
Claude Desktop claude_desktop_config.json
Claude Code claude mcp add tcagent (user scope) + skill
GitHub Copilot in Visual Studio 17.14+ %USERPROFILE%\.mcp.json – choose Agent mode, enable the tcagent tools
GitHub Copilot CLI ~\.copilot\mcp-config.json
Gemini CLI ~\.gemini\settings.json
ChatGPT / OpenAI Codex CLI ~\.codex\config.toml

The ChatGPT desktop app only connects to MCP servers by URL. TcAgent deliberately stays local (stdio): a tool that
changes PLC code and starts and stops controllers does not belong on the network.

The VS extension looks for new versions once a day (an anonymous request to GitHub, nothing about your solution). It can be
switched off in ⋯ > About TcAgent, or for everybody on the company level: SECURITY.md.

How it works

Architecture: AI clients talk MCP to TcAgent; TcAgent drives Visual Studio via COM, the TcAgentBridge extension via a named pipe and the runtime via ADS

  • TcAgent (src/) – MCP server (.NET 8). Drives the IDE through the TwinCAT Automation Interface and the runtime through ADS.
  • TcAgentBridge (vsbridge/) – Visual Studio extension inside the IDE process. Provides what is not reachable from
    outside: cursor and selection, name resolution and cross references, library interfaces,
    the chat window and the inline question. Without it all other tools still work.
  • Agent guide (agents/TCAGENT_GUIDE.md, SKILL.md) – how an agent works safely with TcAgent; distributed as
    AGENTS.md, GEMINI.md, CLAUDE.md, copilot-instructions.md and as a Claude skill.

Safety and guardrails

TcAgent can activate configurations, start and stop PLCs and write variables. The guardrails live in the server and
apply to every client:

Setting (MCP config env) Effect
TCAGENT_ALLOW_TARGETS AmsNetIds allowed for activation, online commands, ADS writes. Default local = this PC only
TCAGENT_MODE agent (default), propose (code changes only as a diff; reading, check and build still work, no other changes), ask (read-only)
TCAGENT_CONFIRM runtime (default): you confirm every activation, PLC start/stop, ADS write, runtime mode change, route and package change – a Yes/No dialog in Visual Studio for the TcAgent Chat, the client's own question dialog elsewhere; if nobody can be asked, the action is refused · all: also project changes · off: never ask (pipelines - a deliberate setting)
TCAGENT_SOLUTION optional, part of the solution path to pin one Visual Studio instance. Not needed normally: the chat always uses its own IDE, a single open solution is found automatically, with several the user picks from a list
TCAGENT_AUDIT audit log of every changing call (default %LOCALAPPDATA%\TcAgent\audit.jsonl)
TCAGENT_RULES additional coding rules (files/folders, ;-separated); TCAGENT_RULES_GATE=0 disables the one-time gate
TCAGENT_RISK_RULES additional risk rules for tc_doc action=risks (files/folders, ;-separated)
TCAGENT_KNOWLEDGE additional knowledge sources (URLs/folders, ;-separated)
TCAGENT_SEARCH search service for tc_docs (searxng:<url> or google:<key>:<id>)

Never allow targets with real machines without agreement. Safety projects (TwinSAFE) are never downloaded or
activated by the agent. See SECURITY.md.

Your files: rules, lessons, memory

Everything TcAgent learns about your project and your way of working lives in plain Markdown/JSON files – on six levels
(built-in, company, you, team, platform, project), so the company standard, your personal style, your team, the automation
framework and the project's conventions (in Git) work together:

Where TcAgent keeps coding rules, risk rules, skills, workflows, prompts, lessons learned, reference sources and manual templates on six levels from built-in to project, and the files that are not layered

Knowledge window

TcAgent Knowledge in Visual Studio / the XAE Shell (View > Other Windows, or ⋯ > Knowledge in the chat) shows
all of it in one place: every rule, skill, workflow and lesson of every level with its status and why it applies, the
Git sources of skills and what changed in them, the platforms of the project, the documentation the agent looks things
up in, the agent's feedback reports, the workflow history – and backups of the knowledge, made automatically before
every change. New, add existing, rename, move to another level, switch off, delete, Git, install from a source, merge a
newer version, propose a change upstream: all from the window, with the same menus in every tab - select several items
with Shift or Ctrl and the action applies to all of them. The tab Storage shows what TcAgent keeps on your PC and
cleans it up (recycle bin, once a day automatically for the safe areas).

The knowledge window, tab Files: every knowledge file of every level with its status; a skill from a Git source shows that it was changed locally

Every tab with screenshots: User guide – The knowledge window.

Coding rules

Put your conventions in Markdown – TcAgent shows them to every agent before it writes code, whatever the client:

File Applies to
<solution>\.tcagent\coding-rules.md (and coding-rules\*.md) the project – shared via Git
%LOCALAPPDATA%\TcAgent\coding-rules.md (and coding-rules\*.md) you personally
TCAGENT_RULES e.g. company rules on a network share

Say "remember: step sequences always as CASE over an enum" and the agent adds it as a rule (tc_coding_rules_add).
Template: docs/coding-rules.example.md.

Risk rules

The static risk analysis (tc_doc action=risks, the HTML documentation, TcAgent.exe doc --risks --fail-on high in the
pipeline) works the same way: <solution>\.tcagent\risk-rules.md (project, in Git), %LOCALAPPDATA%\TcAgent\risk-rules.md
(personal) and TCAGENT_RISK_RULES (company). In one Markdown file you can

  • switch off a built-in rule, change its severity or its thresholds (- long-code: limit=200),
  • add your own text rules (## Rule memcpy-without-sizeof with find/require, unless, kinds, objects, severity, message),
  • list checks a regex cannot decide (## Checks) – the agent verifies them by reading the code.

Say "check from now on that every MEMCPY uses SIZEOF": the agent tests the rule on your project (tc_risk_rules action=test),
shows the findings and saves it after your OK (action=add). Template: docs/risk-rules.example.md.

Documentation and knowledge sources

The agent looks things up instead of guessing (tc_docs, read-only): Beckhoff InfoSys is built in; add URLs, document
folders and network shares per project (<solution>\.tcagent\knowledge.md, .tcagent\knowledge\) or personally
(%LOCALAPPDATA%\TcAgent\). PDF, Word, HTML, Markdown, text, XML, CSV, JSON and ST files are indexed; extracted text is cached.

Feedback loop

Agents report problems, missing features and unclear descriptions through tc_feedback (with version, client, machine and
solution) – into a local file or a shared team folder (TCAGENT_FEEDBACK). tc_feedback action=list|summary|resolve and
TcAgent.exe feedback --open --markdown feedback.md turn them into a triage list for GitHub issues; the knowledge window
anonymizes a report and opens it as a prepared issue. That is where the next improvements come from – see
CONTRIBUTING.md. Questions go to the GitHub Discussions; TcAgent.exe diag (or ⋯ > Copy
diagnostics
in the chat) gives the versions an issue needs.

Build from source

git clone --recurse-submodules https://github.com/ThorstenBrach/TcAgent.git
cd TcAgent

# developer build (TcAgent + extension), then install the extension as administrator
powershell -ExecutionPolicy Bypass -File .\build.ps1
powershell -ExecutionPolicy Bypass -File .\vsbridge\build.ps1
powershell -ExecutionPolicy Bypass -File .\vsbridge\install.ps1

# or the installable package bin\TcAgent-<version>.vsix
powershell -ExecutionPolicy Bypass -File .\build-vsix.ps1

# unit tests (no TwinCAT needed)
dotnet test tests\TcAgent.Tests

Requirements: Windows 10/11, Visual Studio 2022 with TwinCAT 3.1 XAE (tested with 4026), TE1030 license, .NET 8 SDK.
The Automation Interface interop is generated from your local TwinCAT installation and is never redistributed.

src/                    TcAgent (MCP server, .NET 8)
vsbridge/               TcAgentBridge (VS 2022 extension, .NET Framework): chat window, inline ask, installer;
                        install-xaeshell.ps1 builds and installs it for the TwinCAT XAE Shell
agents/TCAGENT_GUIDE.md agent guide (source for AGENTS.md / GEMINI.md / CLAUDE.md / copilot-instructions.md)
SKILL.md                the same guide as a Claude skill
setup-clients.ps1       registers TcAgent in all AI clients (run automatically by the VSIX)
setup-runner.ps1        sets up a GitHub Actions self-hosted runner for TwinCAT pipelines
build.ps1, build-vsix.ps1, test.ps1
tests/TcAgent.Tests/     unit tests of the file logic (xUnit, no TwinCAT): dotnet test tests\TcAgent.Tests
docs/                   installation, tool reference, CI pipelines (docs/pipeline/), images

Roadmap

  • SIL/HIL: first version available (TcAgent.exe sil / hil, see docs/PIPELINE.md) – simulated I/O next
  • Motion: axis parameters (drive links are available)
  • TwinSAFE: analyze and propose on top of the read-only view – never download

Known limitations

  • Windows with Visual Studio 2022 or the TwinCAT XAE Shell (both tested the same way).
  • Scope and HMI changes are written to the project files while the project is unloaded in the IDE and reloaded afterwards –
    unsaved changes in their open editors are saved first. Scope needs matching Scope packages for the IDE (see troubleshooting).
  • Every Automation Interface call runs on the IDE's UI thread – while the agent works, the IDE can pause briefly.
  • Tested with TwinCAT 3.1 build 4026; other builds may need adjustments.
  • The runtime data backup (tc_backup, TcAgent.exe backup|restore) is experimental – not yet tested against a running PLC.

Legal

TcAgent is an independent open-source project and is not affiliated with Beckhoff Automation, Microsoft,
Anthropic, GitHub, Google or OpenAI. TwinCAT is a registered trademark of Beckhoff Automation GmbH & Co. KG; all other
trademarks belong to their owners. The source code of TcAgent contains no code from Beckhoff.
Check the license terms of your TwinCAT installation for your use case. Third-party components and their licenses:
THIRD-PARTY-NOTICES.md. Use at your own risk, see LICENSE.

License

MIT © 2026 Thorsten Brach

Yorumlar (0)

Sonuc bulunamadi