AI Chat

The built-in AI Chat is a conversational assistant that is aware of the TIA Portal project you have open. It lives in the chat view of the workbench: open it from the Activity Bar or with the Command Palette (Ctrl+Shift+P → "Chat"). Send a message in the chat input at the bottom, pick a model in the per-message model picker, and the assistant replies in the chat — calling TIA-aware tools when it needs project context.

The assistant introduces itself as AnyAutomation Studio and gives a short capability summary on first greeting: analyze and document PLC blocks; generate, convert, and review SCL / AWL code; browse and search the open TIA Portal project; create and edit tags and user constants in variable tables; run tests and help debug.

The chat mascot

An animated robot sits in the chat title row, to the left of the title. The title row always renders — even on a fresh, empty chat — so the mascot is visible from the moment a session opens, and a new session shows a New Chat label next to it. The mascot reacts to what is happening:

• At rest it blinks slowly and its eyes follow the pointer.
• While the assistant is responding the eyes keep blinking and keyboard keys flash in sequence.
• After several seconds of continuous responding it shifts into a deeper "thinking" state. This is held back for short responses and is suppressed entirely if your system prefers reduced motion.
• It shows a brief success or error reaction when a response finishes, squints while you type, and goes to sleep after about a minute of idle.

Signing in to a provider

Chat models come from AI providers you sign in to — no API key to paste. The built-in providers use a browser or device sign-in flow, after which their models appear in the chat model picker:

You can also bring your own API key (BYOK) for additional vendors through the native model management.

With the ChatGPT sign-in, the model list shows the models your plan covers.

Where to sign in: an AI Provider button sits in the chat input toolbar. Clicking it opens a Manage AI Provider Sign-In list — one row per provider, each showing whether you are signed in. Select a signed-out row to start the sign-in flow; select a signed-in row to confirm and sign out. While a browser sign-in waits for you, a progress notification lets you cancel it. If the sign-in cannot open its local port, for example because another sign-in is still waiting or Windows has reserved the port, Studio says so and asks you to paste the full address the browser was redirected to. The same list is reachable from the Command Palette (search "AI Provider").

Keeping an eye on your subscription usage

When you are signed in with an account subscription, a provider icon appears in the status bar at the bottom right, next to the Copilot icon. Currently for Claude (Anthropic) and OpenAI (ChatGPT): each signed-in provider gets its own icon side by side. Clicking one opens the usage overview of that subscription:

• Plan and account — the header shows your plan (for example "Claude Max 20x" or "ChatGPT Pro") and, where available, the signed-in e-mail address. The gear next to it opens the provider management.
• Usage bars — one bar each for the current session and the weekly limit; for Claude, additionally a model-specific weekly limit if your account has one. Each bar shows the percentage used and when the limit resets.
• Warnings — as a limit gets close, the bar changes color and a notice appears. Once a limit that applies to your whole account is reached, the status bar icon reads "Limit reached" until that limit resets. A limit that applies to a single model is shown in the usage overview instead: it names the model and suggests switching models, and you can keep working with your other models.

The values refresh when you open the overview and periodically in the background. An icon only appears with an account sign-in; if you use a provider with your own API key there are no subscription limits and no display.

Connecting local AI servers

Besides the sign-in providers, the chat can also draw models from a local or self-hosted AI server — no sign-in required. Ollama, LM Studio, vLLM, and SGLang are supported; the Custom entry additionally connects any OpenAI-compatible endpoint. Local servers are available from the Basic plan.

Setting up: open the Agent Customizations editor and go to the Providers section. Each server has its own card there with an address field; the usual local address is pre-filled (for example http://localhost:11434 for Ollama or http://localhost:1234/v1 for LM Studio) — adjust it only if your server runs elsewhere. The Custom card starts with an empty address field. If your server requires a key, enter it in the optional API-key field; local servers usually need none.

Address rules: web addresses must start with https://; plain http:// is accepted for localhost addresses only. A rejected address shows an error message right under the field.

Priority on a vLLM server: the vLLM card carries a Priority field. The value travels with every request so your server can order its queue; 0 sends none.

Using models: once the server is running, its models appear automatically in the chat model picker. Select one and chat as usual — tools and agent mode work too.

Thinking on a llama.cpp server: if your Custom endpoint is served by a llama.cpp server, models whose server reports it show an On / Off thinking choice next to the model name in the chat input.

The Manage AI Provider Sign-In list (see above) is grouped in three sections: Subscription & Accounts for the sign-in providers and GitHub Copilot, Cloud Providers for the cloud providers with an API key (see below), and Local & Self-Hosted for the local servers. Each entry in the latter two groups shows Ready or Not configured; selecting one opens the Providers settings page.

If no models appear in the picker, check that the server is running and the address you entered is correct.

Connecting cloud providers with an API key

The chat can also draw models directly from cloud AI providers — using an API key instead of a sign-in. Google Gemini, OpenRouter, Mistral, Groq, Cerebras, DeepSeek, Perplexity, Together AI, Hugging Face, Fireworks AI, Vercel AI Gateway, Arcee AI, Alibaba Model Studio (pay-as-you-go and Token Plan), Z.AI, MiniMax, Moonshot AI, Baidu Qianfan, Volcano Engine, BytePlus, and Kimi Coding are supported. For Google Gemini, create the key in Google AI Studio and paste it on the Google Gemini card. Cloud providers are available from the Basic plan.

Setting up: open the Agent Customizations editor and go to the Providers section. Each cloud provider has its own card there: paste your API key (required — you get it from the provider's console). If needed, you can override the server address; it must start with https://. Z.AI, MiniMax, and Moonshot AI additionally offer a Region choice (for example a global or a China variant); Default is the standard region.

Every provider card — including the local-server cards — offers two more optional fields: Additional model IDs adds comma-separated models the provider does not list itself, and Context window overrides caps per model (model-ID=tokens, comma-separated) how much text Studio sends to that model.

In the Manage AI Provider Sign-In list (see above), the cloud providers appear in their own Cloud Providers group, each with a Ready or Not configured status. Once a key is saved, the provider's models appear automatically in the chat model picker — chat as usual; tools and agent mode work too.

If your key is rejected, check it in the provider's console and paste it again.

If a service answers with a web page instead of a reply, for example a sign-in or a maintenance page, the error message says so.

Cloudflare AI Gateway

If you route your AI traffic through your own Cloudflare gateway, the chat can use it directly. The Cloudflare AI Gateway card in the Providers section asks for four things: your Cloudflare account ID, your gateway ID, the provider your gateway routes to (a dropdown — OpenAI, Groq, Mistral, Workers AI, or a generic OpenAI-compatible option), and your API key.

Once account ID and gateway ID are filled in, a line below the fields shows the resolved address — confirming which gateway your chats will go through. With the key saved, the gateway's models appear in the chat model picker like any other cloud provider. In the Manage AI Provider Sign-In list, Cloudflare AI Gateway appears in the Cloud Providers group; like the other cloud providers, it is available from the Basic plan.

Connecting enterprise cloud providers

Three more providers connect to your own enterprise cloud account rather than a simple API key: Azure OpenAI, Google Vertex AI, and AWS Bedrock. Each is set up on its own card in the Agent Customizations editor → Providers section, and each is available from the Basic plan. In the Manage AI Provider Sign-In list they appear in the Cloud Providers group with a Ready or Not configured status. Once a provider is configured, its models appear in the chat model picker like any other provider.

Azure OpenAI

On the Azure OpenAI card, enter your Azure OpenAI resource endpoint (the https://…openai.azure.com address of your resource), your API key, and the deployment name you created in Azure. Optionally set the API version, and turn on Use Responses API for reasoning deployments. The deployment name(s) you enter become the selectable models; add more through the card's model-IDs field. If Azure pauses briefly for capacity, the chat waits and sends the request again on its own.

Google Vertex AI

On the Google Vertex AI card, enter your Google Cloud project ID and the location (region, for example us-central1). Optionally point credentials file at a Google service-account JSON key file; leave it empty to use your machine's Application Default Credentials (for example a gcloud login). There is no API key. Pick a Gemini model from the card's curated list, or add your own model IDs.

AWS Bedrock

On the AWS Bedrock card, enter your AWS region (for example us-east-1). Optionally enter an access key ID and secret access key (and a session token for temporary credentials); leave them empty to use your machine's ambient AWS credentials (environment variables, a shared profile, or an IAM role). Pick a Claude-on-Bedrock model from the card's list, or add your own model IDs.

Once configured, the provider's models appear in the chat model picker — chat as usual; tools and agent mode work too.

Choosing a model

The model picker in the chat input selects which provider and model answer the next message. Open it to switch models on the fly; "Manage Models…" from the picker opens the native model catalog where BYOK vendors and per-model details are managed. Each message can use a different model.

The picker also lists GPT-6.1 Sol, GPT-6 Sol, GPT-6 Luna and GPT-6 Astra for OpenAI, offered with an API key as well as with the ChatGPT sign-in, Grok 4.7 for xAI, DeepSeek V4.1 Flash, and Qwen3.8 Flash for Alibaba Model Studio (Token Plan).

Thinking effort and context size

Right next to the model name in the chat input, supported models offer two extra per-model choices. Models without these capabilities simply don't show the buttons.

Thinking effort: supporting models show an additional section next to the model name (for example High). Clicking it opens a Thinking Effort picker with the levels the model offers — typically along the lines of Off / Low / Medium / High, with the model's default marked (default); the exact levels vary per model. Higher levels make the model reason more deeply before answering: better on hard problems, but slower and potentially costlier. Off is offered by the models that can drop the extra thinking altogether and gives you the quickest answers; on the few models that always think, Off holds the thinking at the model's own minimum and keeps it out of the answer. Off is never a model's default, so it applies only when you pick it. Your pick is remembered per model.

Where the picker appears: the GPT-6 models offer their full ladder from Low to Max, with an API key as well as with the ChatGPT sign-in; GPT-6 Sol and GPT-6 Luna add Off. Mistral models that can reason show the picker with exactly the levels each model supports, Off included where the model takes it. Claude models you reach through OpenRouter or the Vercel AI Gateway give you the same thinking control as Claude directly. Gemini models each offer the levels of that model, with Off where the model supports it.

Claude models: the level set when you send a message holds for that whole answer, including the tool calls along the way; a change in the picker applies from your next message. If the service sets earlier thinking aside while a long answer is running, a short note appears in the chat and the answer continues.

Context size (Claude models): Claude models with a very large context window show a second section (for example 1M). It opens a Context Size picker with two choices: 1M and 200K. The newest of these models serve the very large window directly and start on 1M; the others start on 200K. Picking 1M where it is offered gives the model its largest window, so very long sessions fit, and the context-usage indicator shows the fill level against that window. Picking 200K caps the session at the smaller size to limit usage: the conversation is summarized earlier so it keeps fitting, which can lower cost on long sessions. Your pick is remembered per model, and the context-usage indicator follows it immediately.

Prompt caching

To keep long conversations affordable, chat providers reuse the unchanging parts of a session from a short-lived cache on their side, so follow-up messages in the same conversation are faster and use less of your quota. Two things make this visible and adjustable.

Seeing how much was reused. Hover the context-usage indicator to open its breakdown. After a reply that reused cached context, a line shows what share of your prompt was served from the prompt cache — a higher share means that turn spent less of your quota. The line appears only when part of your prompt came from the cache.

Keeping Claude's cache warm longer. For Claude models, the reused context normally stays cached for about five minutes between messages. If you work in long sessions with longer pauses, open the Settings (Ctrl+,), search for prompt cache, and turn on the option to keep the Anthropic prompt cache warm for one hour. Writing to the cache costs a little more, so this pays off only for long-running sessions with gaps between messages; leave it off otherwise.

Keeping the cache warm while the assistant works. During long runs with many tool calls, the cached context of a Claude conversation is kept warm so the next step starts without delay. A Cache warming setting (Ctrl+,) decides this: off, or warm while the assistant is working, which is the preset.

Long conversations

So that very long conversations keep going without hitting the model's context limit, the chat automatically summarizes older parts of the history when needed. When a conversation is getting long, the chat lets you know it will be summarized soon, and it shows a brief note while it is summarizing and once it is done, including when it makes room in the middle of a longer reply and not only before your next message. The assistant double-checks each summary and, if it left out something important such as your latest question or a key detail, redoes it once. Your most recent messages are kept unchanged. Even when a conversation gets very full – for example after you attach several large files – the chat makes room on its own and keeps going rather than stopping.

Tuning the summary. Two settings (Ctrl+, then search for compact) set how much room is held back for the answer itself and how much of the recent conversation is kept word for word after a summary. Both can also be set for a single model, so a small and a large model can work with different values.

If a summary does not come through because the model doing the summarizing spent its whole budget on thinking, the chat says so and suggests another model for the summary or a larger reserve. Stopping an answer also stops a summary that was about to run.

If a request outgrows the context window of a Cerebras model, the chat summarizes it and sends it again on its own.

You can also trigger the summary yourself: type /compact in the chat input. To steer what the summary focuses on, add an instruction – for example /compact focus on the code changes. Whenever there is anything to condense, /compact does it; if there is nothing to summarize yet, the chat tells you so.

Very large content – the full source of a big block, or a large file you attach – may be shortened when needed so it does not slow the conversation down. The full content stays available: the assistant sets it aside and reads it back on demand when it needs it again.

Visible reasoning

While a model thinks, its reasoning streams live into a collapsible "thinking" section within the answer — expand it to follow along, collapse it to keep the chat tidy. How the section presents itself is adjustable in the Settings (Ctrl+,) via the chat Thinking Style setting: collapsed, collapsed with a preview of the latest thought, or a fixed scrolling view.

Proactive TIA project context

While a TIA Portal project is connected, the assistant automatically receives a short summary of it on every turn — the project name, the TIA Portal version, and the available PLC names — without you having to attach anything. This lets the assistant answer project questions in context; for anything deeper it calls the TIA tools to read blocks, walk the tree, or search the catalog. When no project is connected, nothing is injected.

The open file as context

The file you currently have open in the editor is offered to the assistant as context. In Ask mode it is included automatically. When you are working with an agent, it appears as a dimmed suggestion in the chat input instead — click the suggestion (or its plus button) to add it to your message, or remove it with its close button once added. Text you have selected in the editor is always included either way. For example, an open block-type template (.scriban, opened in a text editor via Open Template in Text Editor) can be added with one click and discussed directly. You can also ask the assistant to change the open template: the edit appears as a proposal in the editor that you review and Keep or Undo before saving.

Images and screenshots as context

You can show the assistant pictures: paste a screenshot straight into the chat input (Ctrl+V) or drag an image file onto it. The image appears as an attachment above your message, the assistant sees it when it answers, and follow-up questions in the same conversation keep referring to it. This works with any model that understands images. An image may be up to about 4.5 MB, and one message carries up to eight images and about 16 MB of images in total; an image beyond those limits, or in an unsupported format, is left out and the assistant says so openly instead of silently ignoring it, while the rest of the message is still sent. Pasted text is treated the same way: text you paste into the chat input is attached as a snippet above your message, even when it is a single line.

Excel workbooks and other files as context

Drag an Excel workbook (.xlsx) onto the chat input or pick it through Add Context..., and the assistant reads its contents: every sheet reaches it as a table, with dates, numbers and the last computed result of formulas. You can ask straight away which invoices are open, have amounts summed up, or compare two sheets. Hidden sheets are sent along and marked as hidden. For a very large workbook the assistant receives the beginning and tells you that it cannot see the rest; name the sheet or the range you mean and it works from there.

A password-protected workbook cannot be opened by the assistant; it tells you so, and you remove the protection in Excel or save a copy without the password.

Other files that are not text, such as PDF, Word, archives or an .xls file in the old Excel format, cannot be read by the assistant. It does know that you attached them, knows their name and size, and tells you openly what it can and cannot do with them. Save an .xls file as .xlsx in Excel and it arrives as a table. Text files such as .csv, .txt or source code are sent in full, as before. When you attach a folder, the assistant knows it is a folder and reads the files inside it as needed.

GitHub issues and pull requests as context

When you are signed in to GitHub (Accounts menu), the Add Context... menu of every chat input offers Issue... and Pull Request.... Pick one, choose the repository if several are open, and search for the item; it is attached to your message so the assistant can read its description, comments or changes without you copying anything. Pasting the link of an issue or pull request into the input attaches it the same way. Without a GitHub sign-in the two entries are not shown.

Dictating instead of typing

The chat input carries a microphone icon. Click it (or press Ctrl+I in the input) and simply speak your message – the spoken text appears in the input and can still be edited before you send it. Clicking again ends the dictation. On the very first dictation AnyAutomation Studio downloads a speech-recognition model once; after that, recognition runs entirely locally on your machine and nothing is sent to a cloud. Several languages are recognized, including English and German. Dictation also works in the editor and in the terminal. If you prefer not to use it, hide it via a right-click on the microphone.

When you end a dictation, the text recognized up to that point stays in the input, so nothing you have already said is lost. A recording you forget to stop ends on its own after 20 minutes. On a machine without internet access you can bring the speech model in by hand: run Install Dictation Model from Local Package... from the Command Palette, pick the model package (a .zip file) or the folder it was unpacked into, and confirm with Install.

Searching your own documentation

You can point the assistant at external documentation websites — a vendor manual, an API reference, a standards portal — and have it search them when it answers. Open the command palette, run Documentation: Add Site, paste the site's address and give it a name. AnyAutomation Studio downloads the pages and prepares them for search, then tells you how many pages it added.

From then on, just ask the assistant about that documentation in chat and it pulls the most relevant passages into its reply. You can also add and search sites by asking it directly ("add the docs at …", "search the docs for …").

Manage your sites from the command palette or the documentation entry in the status bar (it shows how many you have): Documentation: Resync Site refreshes a site after it changes, Documentation: Remove Site deletes it, and Documentation: Show Sites opens a quick menu with all of these actions. Under Settings → Documentation Sites you can limit how many pages to download and how deep to follow links.

Documentation search uses the same connection as the codebase index, so set the embedding address and model under Settings → Codebase Index first.

Selection action bar

Select code in the editor and a small floating bar appears just below the selection, with AI actions for that selection:

• Ask for Edits — opens inline editing (also via Ctrl+I): describe the change you want, and the proposal appears as a diff in the editor that you keep or undo.
• Quick Question — ask a short question about the selection and get the answer right there, without opening chat. Type your question in the input and press Enter; the answer is shown only — nothing in your code is changed. Press Esc to close it. The question runs on your signed-in model — if none is signed in, a Sign in link appears instead.
• Add Selection to Chat — attaches the selected code to chat as context, to discuss it at length.
• Fix — appears when the selected line carries a reported diagnostic, and lets the AI propose a fix.

The bar appears automatically on every selection. You can hide it from the settings (Ctrl+,) if you prefer.

Inline completion (Tab)

Beyond the chat, the assistant can suggest code right where you are typing — a grey "ghost text" continuation that you accept with Tab. Run Select Inline Completion Model from the Command Palette (Ctrl+Shift+P) and pick a coder model from one of your providers. A fast local coder model is recommended for the snappiest typing.

Only providers that support fill-in-the-middle (FIM) code completion appear in this list — for example Mistral Codestral, DeepSeek, or a local Ollama / coder server. Chat-only subscriptions such as ChatGPT, Claude, or Gemini do not appear here, because they have no dedicated code-completion mode; use those for chat and for the other AI features instead. If the list is empty, configure a coder/FIM provider first (see Connecting local AI servers and Connecting cloud providers with an API key above).

Once a model is selected, suggestions appear as you type; press Tab to accept the one shown, or keep typing to ignore it. Run the command again to switch models, or clear the selection to turn inline completion off. You can also see and change this model in the Feature Models section of the Agent Customizations editor (see below) without the Command Palette.

Suggesting your next edit

Beyond inline completion, the assistant can predict what you are about to change next — as a concrete edit to an existing spot, which may be elsewhere in the file than your cursor. After you make a change (for example, renaming something), the suggested follow-up edit appears as a diff in the editor, with a marker in the left margin. Press Tab to jump to the suggestion and accept it; press Tab again to move on to the next suggested spot. This lets you click through repetitive changes — such as a rename across every usage — one step at a time.

Run Select Next-Edit (NES) Model from the Command Palette (Ctrl+Shift+P) and pick a model from one of your providers; a capable model gives the best predictions. This model is independent of the chat model and the inline-completion model. Suggestions appear only after you have recently made a change; keep typing to ignore one. Run the command again to switch models, or clear the selection to turn the feature off. This model is also shown in the Feature Models section of the Agent Customizations editor (see below), where you can pick or clear it.

Applying a reply to a file

When the assistant shows a code block in its reply, you can apply it straight into a file. The code block carries an Apply in Editor (or Apply to <file>) button. Clicking it merges the change into the target file and shows it as a diff preview in the editor first — accept it or reject it; nothing is written without your confirmation.

The merge runs on your own model. By default it uses the model you last used in chat; run Select Fast Apply Model from the Command Palette (Ctrl+Shift+P) to pick a dedicated model for it — a fast model keeps applies snappy. If no model is available, run that command. You can also set this model from the Feature Models section of the Agent Customizations editor (see below). In an untrusted workspace, applying is disabled.

Choosing the model for each AI feature

Several AI features run on a model you choose, separately from the chat model: Inline Completion (Tab), Next Edit Suggestions, Apply, Conversation Summarization (condensing long chats), and Ambient Hints (blame explanations and terminal risk notes). Each can be set from its own Command Palette command, but the Feature Models section of the Agent Customizations editor gathers all five in one place so you can see and change them without the palette.

Open the Agent Customizations editor (chat gear → Open Customizations) and pick Feature Models in the sidebar. Each feature shows a short description, its current model (as provider: model, or Not set), and buttons to Select Model / Change Model or Clear it. Select opens the same model picker as the matching command, listing the models from the providers you have configured. The models you can pick come from your configured providers (see Signing in to a provider and the connect-provider sections above).

The model lists differ by feature: Inline Completion lists only FIM/coder-capable providers (such as Codestral, DeepSeek, or a local coder server — see Inline completion (Tab) above), because it needs fill-in-the-middle completion. The other four — Next Edit Suggestions, Apply, Conversation Summarization, and Ambient Hints — list every model you are signed in to, including chat subscriptions such as ChatGPT, Claude, or Gemini.

Running a session in isolation

When you start a new chat session that can edit your files, you can keep its edits out of your open project until you are ready for them. A small isolation mode control appears when you start a new session, with two choices:

• Worktree (the default) — the session works on a separate, isolated copy of your project. Your open files are left untouched while the assistant works; you review what it changed and apply it to your project when you are ready.
• Folder — the session edits your open project directly.

The control appears only when your project is a git repository; without one, the session simply runs in your folder. Your choice is remembered for the next session.

While a session runs in Worktree mode:

• Files it opens or edits live in the isolated copy, and any editor tab showing one of those files is marked with a coloured left edge, so you can tell it apart from your open project.
• You review the session's changes and apply them to your project when you are ready — nothing reaches your open files until you do.
• The isolated copy is cleaned up automatically when you close the session. If a window closes unexpectedly, any copies it left behind are tidied up the next time you start Studio.

Running several attempts at once (Best-of-N)

Sometimes one take on a request isn't enough — you want to see a few and keep the best. Best-of-N runs the same prompt several ways at the same time, lets you compare the results, and adopts the one you prefer.

Type your prompt in the chat box, then click the Run Best-of-N button next to Send (or run Run Best-of-N from the Command Palette). A short dialog asks two things:

• How many attempts to run in parallel — between 2 and 5 (3 by default).
• Which model each attempt uses — keep the same model for every attempt for a straight comparison, or choose a different model per attempt to compare providers side by side.

Each attempt runs as its own isolated session (as described above), so the attempts never interfere with each other or with your open project. A slim banner appears above the chat box with one chip per attempt, showing its model and status (Preparing, Running, Done, Error). Click a chip to switch the view to that attempt and read its reply and changes.

When you have a favourite:

• Click Adopt on its chip to keep that attempt as your active session. The others are discarded and their isolated copies are cleaned up.
• Apply the adopted attempt's changes to your project the same way as any isolated session — from its Changes view.
• Click Discard All to end the run and discard every attempt without keeping one.

If you pick the same model for every attempt, the replies may come out very similar; choosing a different model per attempt gives you the most variety to compare. Best-of-N is available for Local chat sessions in a git project, just like isolation mode.

Agent Customizations editor

All AI customization is managed in a single native editor. Open it from the chat gear → Open Customizations, from the Command Palette, or from the Open Agent Customization link in the AnyAutomation Settings editor (Ctrl+,). Its sidebar includes a section for external MCP servers (see AI Integration); the sections most relevant to TIA work are:

• Agents — the AI personas (system prompt + a curated tool list). Pick the active agent from the chat agent picker.
• Skills — reusable task playbooks you invoke from chat.
• Instructions — Siemens reference guides that are auto-applied to the chat context where they match the active file (for example, opening an .scl file pulls in the SCL / styleguide guides).
• Tool Approvals — the per-tool approval gate (see below).
• Feature Models — which model powers each AI feature (see Choosing the model for each AI feature above).

Tools switched off

If every tool is switched off in Configure Tools, the chat says so above the reply and offers a Configure Tools button. The assistant still answers, but it cannot read your project or run anything until you switch tools back on. Should a request fail, the message names the reason (for example a rate limit at the provider, or a conversation that has grown too large for the model) together with the provider's own details.

Agents

The following expert agents ship with Studio. Each is selectable as the active agent and carries its own system prompt and tool list:

Only the agents your plan includes are offered. An agent for a feature your plan does not cover is not listed at all, and it appears by itself as soon as your plan covers it, with no restart and no setup.

Skills

Skills are task playbooks you invoke from chat. The shipped skills cover the common TIA workflows: explore / describe / document the project, explain / describe / document a block, generate / review / optimize SCL, convert AWL to SCL, write unit tests, run a safety check, compare blocks, and export blocks. For EPLAN: explore the project and export it as PXF/PDF, and edit pages, devices, properties, and reports. For commissioning: work through the acceptance report, propose test steps, and record what you tested.

Skills follow your plan the same way the agents do: a skill for a feature your plan does not cover is not offered, and it appears by itself as soon as your plan covers it.

Instructions

The Instructions section lists the reference guides the assistant can draw on (the Siemens Programming Styleguide, the SCL and AWL→SCL references, the OPC UA reference, the Unit-Testing reference, the Canvas reference, and the Forge templating reference for writing your own block-type templates). Where a guide declares a file pattern, it is applied to the chat context automatically when a matching file is active.

The Siemens guides are license-gated: they resolve and feed the model only while your account holds an active AI-chat entitlement (Basic, Pro, Pro+, Enterprise, or an active Trial). With an entitled license they simply work — there is no key, dialog, or extra step. On sign-out or a tier downgrade they stop resolving.

Delegating to sub-agents

The assistant can hand a focused sub-task to one of your agents — it picks the agent by name, the agent works on its own with its own tool set, and it returns a result that the assistant folds into its answer.

Each hand-off appears as a collapsible block, titled with the agent name and the model it used. While the agent works, you can watch its progress live: the block's title shows its latest activity, and expanding the block reveals its reasoning and draft answer growing as it goes, alongside the tools it uses. When the agent finishes, the block shows its final result and stays in the conversation for later review.

When the assistant hands off to several agents in one step, they run at the same time — their blocks grow concurrently rather than one finishing before the next starts (up to five per step).

An agent can declare its own model; the hand-off then runs on that model. If it is not signed in, the hand-off continues on your current model and notes that in the block.

During a task the assistant automatically follows your project's rule files and can load a skill on demand.

Running a multi-step workflow

For a big job that needs many agents working together — reviewing every block in a project, running a proposal-then-independent-check pass, fanning a task out over a long list and merging the results — you can ask the assistant to run a workflow. Just describe what you want in your own words ("run agents over every block and summarize each", "review this, then have a second agent verify it", "fan these out in parallel and combine them"). The assistant then prepares a short plan and orchestrates several specialist agents to carry it out. A normal question or a single edit is not a workflow; the assistant only sets one up when you have clearly asked for this kind of multi-agent work.

You approve before it starts. Before any workflow runs, a dialog titled Run AI workflow? appears. It shows the workflow's name and a one-line description, the phases it will go through (when it has them), how many agents it may use and how many run at once, and the token budget if one was set. Nothing runs until you click Run Workflow — clicking Cancel calls it off and the assistant simply tells you it did not run. This confirmation cannot be skipped.

Watching it run. Once you approve, the workflow appears as a single progress block in the chat. It updates live: the phase it is in, how many agents are running, finished, reused, or failed, how many tokens it has spent (against the budget when you set one), and the latest progress notes. Each agent it starts shows up as its own nested block, streaming its work just like a normal sub-agent hand-off, several at a time. When the workflow finishes it shows a final status and its result; you can leave it collapsed in the conversation for later.

Setting a budget. You can cap how much a workflow may spend by asking for it ("keep it under 200000 tokens"). When the cap is reached, no new agents start — the ones already running finish — and the workflow stops there. Without a cap it runs until the work is done or it hits its built-in limits (up to 50 agents in total).

Stopping and resuming. Press the stop button to cancel a running workflow. Because every agent that already finished is remembered, the result tells you the run can be resumed. Ask the assistant to continue that run (in the same chat) and it picks up where it stopped: the agents that already completed are replayed instantly from memory instead of running — and being paid for — again, and only the remaining work runs.

Workflows require the Pro plan or higher. On a lower plan, the assistant tells you the feature is not included instead of running one.

Ultracode

Ultracode is a switch that lets the assistant take on the biggest jobs on its own. When it is on, the assistant starts a multi-agent workflow by itself as soon as a job is large and multi-step, and those workflow runs start without asking you to confirm each one. You turn Ultracode on next to your chosen thinking level, not instead of it, so you keep full control over how hard the model thinks.

How to turn Ultracode on. Open the model settings next to the model name in the chat input (the same menu as Thinking effort and context size above). Below those sections is a Workflow section with an Ultracode switch. Turn it on. The switch is shared across all your models and takes effect from your next message. It is shown on every model, so you can use Ultracode whichever model you are working with. Its violet row glows while you hover over it and rests as a steady violet marker once it is on; if your operating system hides animations, the glow stays off.

What you need. Ultracode needs the Pro plan or higher. On a lower plan, turning it on has no effect: workflows only run when you ask, and each run still shows its confirmation.

Keeping cost in check. Because Ultracode starts workflows on its own, you decide how many specialist agents run at the same time. Open the Agent Customizations editor (chat gear → Open Customizations), pick Tool Approvals in the sidebar, and on the Workflows card enter your limit under Max Parallel Agents (at least 1, default 4, no upper limit); confirm with Enter or click outside the field. The fewer agents run at once, the lower the cost.

Run a task in the background

Prefix a task with /background (for example /background Analyze FB10 for unused tags) to let it run without tying up the chat. The chat answers right away with "Running in the background. Track progress in the Sessions view." and is free for your next message, while a session appears in the Sessions view with the task as its label and a spinner.

The assistant works on its own. When it finishes, the session flips to Done (or Failed) and a notification appears. Open the session to read the full conversation — your task and the assistant's answer. Each background task is independent, so several can run at once.

Project rule files

Beyond the built-in Instructions, the assistant automatically discovers rule files in your opened project and uses them as reference for its answers. It looks for the common formats — .cursor/rules/*.mdc, a top-level .cursorrules, AGENTS.md, and .github/instructions/*.instructions.md — and applies each according to how it is written:

Because these files come from the opened project, the assistant treats them as reference material — guidance it follows where it makes sense, never instructions that override your request. Discovery is on by default; turn it off with the Project rules setting in the AnyAutomation Settings (Ctrl+,) if you prefer the assistant to ignore them.

Tools

The assistant has a set of TIA Portal-aware tools that operate against the connected project. Every tool call appears live in the chat with a clear label that names the key details (such as the name being searched or the block being read), so during longer actions you always see what is running. Finished calls expand to their full details. The assistant can also reference tools in a prompt by name from the chat tool picker. Tools that become available while an answer is running stay available for the rest of that conversation. When the assistant looks up where a name is used, it reads the same prepared project sources as the Project Search: the first lookup on a project prepares them once, every later lookup is quick, and it also works on a project opened offline.

In the tool picker the tools are grouped into categories, each with a short description and its own switch. The TIA Portal tools come in ten groups, tia-project (projects, project tree, import and export), tia-blocks (program blocks, data types and tag tables), tia-hardware (devices, modules and subnets), hmi-unified (WinCC Unified screens and objects), hmi-classic (WinCC Comfort and Advanced screens), tia-security (project protection, users and roles), tia-online (online connection, download and upload), tia-safety (the safety program), tia-multiuser (Multi-User sessions and servers) and tia-library (the project library), all switched on to begin with; alongside them sit agents, files, docs, eplan, opcua, forge, scada, trace, canvas-tools, unit-tests, visual-context and commissioning. The switch on a category turns the whole group on or off; expand a category to switch single tools inside it. Every tool sits in exactly one category, so switching one off keeps it off.

Only the categories your plan includes are offered. A category your plan does not cover is not listed at all, and it appears by itself as soon as your plan covers it, with no restart and no setup.

Switch off the categories and tools you do not use: every tool that is on travels with each message, so a shorter tool list makes every request smaller and saves tokens. From time to time a short tip above the chat input reminds you of this, with a link that opens Configure Tools.

When the assistant asks to open or show a block, it opens the block's source in an editor — SCL and STL with syntax highlighting, and graphical languages (LAD, FBD) as their text source — and reports a short confirmation in the chat.

Reading and editing graphical blocks

A graphical block (LAD or FBD) can be shown two ways: as its graphical networks, or as the same logic in text source. A control in the block editor switches between the graphical view and the source view, so you read a block whichever way suits you.

Because a graphical block has a text source form, the assistant works with graphical blocks the same way it does with SCL text blocks: it reads their logic, and it can change them. Ask it to adjust a network or add a new one and the change appears as a proposal you review; once you save and confirm the upload, the edited block is written back into TIA Portal, with the same confirmation as any other project change. That is what lets the assistant write and edit graphical blocks, not only text ones. You can keep chatting while the upload runs: a message you send meanwhile goes out right away.

Organizing project folders

Ask the assistant to tidy up the structure of a PLC and it creates, renames, moves and deletes folders under Program blocks, PLC data types and PLC tags, and moves blocks, data types and tag tables into a folder you name. It asks before every change and names the folder and the PLC it touches. Moving a folder or moving blocks, data types or tag tables into another folder, and renaming a folder under Program blocks or PLC data types, exports the contents and imports them again in the new place; the program is compiled as part of the change, and the assistant tells you the result. Review it before you save the project.

Projects, archives and Multi-User sessions

Ask the assistant to open a project file or to unpack a project archive into a folder and it opens the project in a new TIA Portal and connects Studio to it; a protected project asks you for its credentials in Studio, the assistant never sees them. It archives the open project to a file you name, and it closes the project, with or without saving, after you confirm. When Studio only attached to a TIA Portal you had already running, closing detaches Studio and your project stays open in TIA Portal.

With Multi-User Engineering it lists the servers registered on your computer, their server projects and the local sessions of a project, checks a local session out into a folder, opens a local session file, saves it, tells you whether the session is up to date, lists the objects with their check-in marks, marks and unmarks objects and checks the marked changes in with your comment. It also adds a project to a server, changes or removes a registered server connection and removes a local session from the server. Every change asks for your confirmation first, and the assistant names the server, the project and the session it touches. Multi-User needs the Pro plan.

Ask about the project library and it copies a block into the master copies, creates a block from a master copy, creates, renames and deletes library folders, master copies and types, writes a committed version of a type to an XML file and cleans unused versions or unused types out of the library. Deleting and cleaning up cannot be undone, so it asks first. The project library needs the Pro plan.

To replace the whole program of a PLC with the files of an export folder, ask for an Import All: the assistant deletes the program of that PLC and imports the folder in its place, keeping know-how protected blocks and the items you marked as protected in the Project Explorer, and it tells you when the import was rolled back and the PLC is unchanged. The file limit of your plan applies as it does in the Export Folder view. It compiles afterwards and asks you to review before you save.

Blocks, tags and data block interfaces

The assistant renames a block, creates an instance data block for a function block, creates a PLC data type with one placeholder member, reads, creates and changes a single PLC tag, deletes several tags in one step or a whole tag table, and lists the software units of a PLC and the blocks of a unit. It reads the interface of a data block or a PLC data type, member by member with data type and retain setting, and changes the members of a global data block: it renames a member, changes its type or its HMI access flags, adds a member and removes one. The interface of a function block, a function or an organization block is changed through its source, which the assistant edits and imports. It exports and imports the watch and force tables of a PLC, exports technology objects, and exports blocks and data types as XML only when you ask for the plain exchange files.

Hardware, online connection and download

The assistant imports the devices of an AutomationML file into the hardware configuration, overwriting devices with the same name, reads the device items of a station and the whole hardware tree, sets a single attribute of a device or module, the IP address or PROFINET name of a network interface and the start address of a module, each after your confirmation.

It reads whether a PLC is online, which connection paths TIA Portal offers for it and which devices a network adapter can reach, compares the project with the online CPU, goes online and offline, previews what a download would do and downloads the project to the controller at the IP address you name, with the choice of loading only the changed blocks so the CPU stays in RUN where possible. It uploads a station from a controller into a folder without touching your project, or uploads named blocks, data types and tag tables from the controller into the open project, overwriting the objects of the same name. Going online, a download and an upload each ask for your confirmation and name the PLC and the address. A controller that asks for a password is not loaded by the assistant; it asks you to run that download yourself. These online tools need the Pro plan.

Safety program

Ask about the safety program of a fail-safe PLC and the assistant reads whether a safety login is needed, the safety runtime groups, the F-signature of every safety block and the safety blocks of a device. It writes the F-signatures to a text file, writes the safety printout as PDF or XPS and logs TIA Portal out of the safety program, each after your confirmation. There is no login through the assistant: when the safety program asks for its password, you log in yourself in TIA Portal. These tools need the Pro plan.

Classic HMI devices

For a WinCC Comfort or Advanced device the assistant reads a screen with its themed colors resolved, the screen overview, a faceplate type from the project library, the text and graphic lists with their entries and the graphics of the project. It imports a screen from its exchange document and exports the items of a device, screens, tag tables, scripts, connections and lists, as files into a folder or imports such files back, replacing items of the same name. Imports ask for your confirmation; a WinCC Unified device is handled by the Unified tools instead.

Reading a block's live values

When you have a block open with Live Values turned on — its operand values shown inline while you are online — you can ask the assistant about those values directly in chat ("what is the current value of …", "are any of these stale?"). It reads the values currently shown in that block and reports them back, quoting each operand and its value; ask again for a fresh reading. Live block values are included from the Pro plan (also during the free trial) — on a lower plan the assistant tells you the feature is not included instead.

WinCC Unified devices

Ask the assistant about a WinCC Unified device and it reads what the device holds: its screens and the objects on them, its tags and tag tables, alarms and alarm classes, connections, text and graphic lists, logs and runtime settings, and the full properties of any one of them by name. A tag's GMP settings, its confirmation type, mandatory commenting and function rights, are part of that only while GMP is switched on for the device and the tag is GMP relevant. About a screen it answers from a short overview of that screen, the tags it uses, the values a faceplate container hands to its type, and the properties the installed TIA Portal version cannot read. On a device with thousands of tags its list can be narrowed by name or by tag table, and it says how many entries it left out; ask about a tag table and it says how many tags the table holds. For a text or graphic list it reads the entries, each with the value or the range it covers and the text in every project language, or the graphic it shows.

Ask about the plant model of the project and it reads the plant view with its nodes, the plant object type of a node and the plant object tags of a device with their members and logging tags. It creates the plant view and its nodes, a node also with a plant object type, renames and deletes them, assigns the view its HMI device and changes the acquisition cycle, the acquisition mode, the connection and the PLC tag of a plant object tag. What TIA Portal does not offer, it says: a plant object tag is neither created nor deleted, a project holds one plant view, and the view and its nodes have no check.

Ask about the project library and it reads its types with their kind, their versions, their state and the fields of a type, exports a type as documents into its staging folder and imports a type or a new version from there, finds where a type is used, in the PLCs, the classic HMI devices and on the screens of the WinCC Unified devices, and creates, releases, discards, sets as default and deletes versions, each of these changes after your consent. It does not edit the screen content of a faceplate type, because TIA Portal does not offer that.

It changes them as well. On a screen it moves single objects, resizes them, renames them, changes their text and adds or removes them, and every object it does not name stays as it was. It binds a property to a tag, a script, a flashing or a text or graphic list and removes a binding again, and it sets or removes the script an event runs, on an object and on the parts of a control alike, the columns of an alarm control, the curves and axes of a trend control, the elements of a tool bar; for a script binding it names when the script runs and which tags trigger it, and a binding TIA Portal does not keep is named in its answer. A new object it adds gets the settings TIA Portal gives a new object of that kind and a name of its own, a faceplate container the faceplate type it shows; it duplicates objects, aligns and distributes them, changes their drawing order, and resizes a screen to the display of its device. While that screen is open in front of you in the editor, the change lands there unsaved, so you see it before it goes into the project; a screen you do not have open is changed in the project itself once you confirm, and a screen sitting in a tab you cannot see is left alone until you bring that tab to the front or close it. It creates and renames screens, and creates, renames and deletes screen folders. It adds, changes and removes tags, tag tables, alarms, alarm classes, connections, data logs and alarm logs, and renames tags, tag tables, alarms, alarm classes, connections, logs and audit classes; it adds, changes and removes the entries of a text or graphic list and creates a list that is missing; and it removes whole text and graphic lists, the entries going with them, while a screen object that shows the list is left as it is. It also reads and changes the runtime settings, and it can have TIA Portal check the device and report what it objects to, without changing anything.

It sees every HMI editor you have open, not only the screens: an open tag table, alarm tab, object detail view or script appears in its picture of your editors with the device and the object, and an open tag table, alarm tab or object detail view can be attached to a chat turn from the attachment menu. A change it makes to an open tag table or alarm tab lands there as an unsaved edit, exactly where a typed change lands: the editor switches to edit mode, the changed cells show the new value, and nothing reaches TIA Portal until you click Save to TIA. It also creates discrete alarms from a table of rows you give it, duplicates and deletes screens, finds the tag table a tag belongs to and names the spelling the project stores the tag under, tells which WinCC Unified devices the project holds and which languages it carries, exports the files of a device as exchange documents or as a workbook, naming the columns and rows of every workbook file, and imports them back, re-words the entries of a system text list, sets the comment and the value range of a text or graphic list, and changes the value and value type of a tag's thresholds. It reads the script modules of a device, in pieces when a module is long, changes a line by naming the text to replace or replaces the whole source, and creates a module. Where TIA Portal offers no way, it says so: a threshold cannot be added, deleted or renamed, a system text list keeps the entries it has, and a script module is neither deleted nor renamed.

The assistant asks before each change and names the device and the objects it touches. Creating, changing, renaming or deleting anything on a WinCC Unified device needs the Pro plan and is unlocked during the free trial; reading stays available on every plan, and so does the check the assistant asks TIA Portal to run over one kind of object, which can be narrowed to one tag table. For larger HMI work the assistant hands off to its HMI Engineer specialist. You can also pick HMI Engineer yourself in the chat agent picker, so a whole session stays on the Unified device; it is offered on every plan, and a change it makes needs the Pro plan like any other.

Tool approvals

Tools that change the project are gated before they run. In the Tool Approvals section of the Agent Customizations editor, every managed tool your plan includes (TIA, EPLAN, Visual Context and Commissioning Report) offers the same four levels:

A choice takes effect immediately for that tool's in-chat confirmation prompt. Always Allow and Always Deny persist across window reloads; Allow in This Session resets to Ask Every Time after a reload. A Reset All link clears every override.

The tools are grouped the way the Configure Tools picker groups them: one card per group, with the group's icon, name and description. Click a group's header to fold the card away or to open it again; Studio remembers which cards you folded. The header also carries a dropdown that sets the level for every tool of the group at once; it reads Mixed while the tools of the group have different levels. Next to it a badge counts the group's tools and, once you changed one, how many of them are no longer at Ask Every Time. Tools that belong to no group are listed under Other Tools.

There are no exceptions among the tools you are offered: every one of them follows the level you picked for it, including the tools that create or export a commissioning report, record results, remove a test step, or change an EPLAN project. Tools your plan does not cover carry no row here, and their rows come back with the levels you had set as soon as your plan covers them. At Ask Every Time the confirmation appears in the chat, and the card itself also lets you allow that tool for the session or for good instead of only for that one call. At Allow in This Session or Always Allow, or while the chat is approving tool calls for you, the tool runs without asking. Always Deny comes before everything else: a tool set to it is refused without asking, whatever else you have allowed. One thing stands outside these levels: a change the assistant wants to make to the files that configure your tools or your package sources is always confirmed with you, whatever you allowed in advance.

Mutating tools confirm before applying a change unless you allowed them in advance, and destructive tools (deleting a block or device) state in the confirmation that the action cannot be undone. After a confirmed change succeeds, the TIA Portal Project Explorer refreshes automatically.

Permissions under the chat input

Below the chat input sits a permissions button (Set Permissions) that decides, on top of the per-tool levels above, how freely the assistant may act in the running conversation. Click it and choose Default permissions (it asks whenever your approval settings do not already cover an action), Allow all (tool calls run without asking) or Autopilot (Preview) (the assistant keeps working on its own until the task is done). The last two ask you to confirm once before they take effect, and your organization's policy can switch them off. The button is offered while the assistant may act on your project, not in Ask mode.

Default permissions carries a Sandboxing for terminal switch. Turn it on and the terminal commands the assistant proposes run inside a sandbox that limits what they may reach in the file system and on the network, and a command that runs there is no longer confirmed one by one. The button then reads Default permissions (sandboxed). A command that has to step outside the sandbox, or that needs unrestricted network access, still asks you first. Creating and running a task always asks you first, whatever level is set, and so does a git diff that writes its output to a file.

Other extensions accessing your models and tools

Other installed extensions may also want to use the AI models you have set up in Studio. The first time an extension tries, Studio asks once: a dialog names the extension and you decide with Allow or Cancel. Without your consent the extension gets no access, so your connected accounts and API keys stay under your control. Studio remembers a granted permission; you can revoke it at any time from the accounts menu in the activity bar. The built-in AI chat and the Studio features that ship with it need no approval.

The same applies to the Studio tools. The first time an extension you installed tries to run one of them, Studio asks once: the dialog names the extension and the tool it wants to run, and you decide with Allow or Cancel. If you cancel, the tool does not run. If you allow it, that extension may use the Studio tools until you withdraw the permission, again from the accounts menu in the activity bar. The AI chat and the features that ship with Studio need no approval here either. Shortcuts, menu entries, links or status bar items that an extension adds on its own, and the task and debug configurations of a project, cannot trigger the Studio automation either: such an entry stays without effect, and a task or debug configuration that names one says so when you run it.

External MCP servers

Beyond the built-in TIA tools, the AI chat can connect to external MCP servers and surface their tools in the same tool picker. See AI Integration for how to add and enable them. In the Agent Customizations editor, each server shows the file that defines it; a click on it opens that file.

Links and terminal output in an answer

Right-click a link in an answer for Copy Link; for a link to a file, Open With... opens it in an editor of your choice. Terminal output in an answer wraps to the width of the chat by default; in the chat settings it can keep the width of the terminal and scroll sideways.