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.

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. The same list is reachable from the Command Palette (search "AI Provider").

Antigravity (Google)

Antigravity is Google's experimental model sandbox — Gemini 3, Claude, and GPT-OSS models, free with any Google account. Its sign-in lives on its own card: open the Agent Customizations editor, go to the Providers section, and click Sign In on the Antigravity card — no API key is needed.

Before the sign-in starts, a warning spells out what you are connecting to: Antigravity is an experimental sandbox reached through an unofficial client, and Google can limit or withdraw this access at any time. If that trade-off is acceptable to you, continue and sign in with your Google account; afterwards the Antigravity models appear in the chat model picker — chat as usual.

In the Manage AI Provider Sign-In list, Antigravity appears in the Subscription & Accounts group. Antigravity is available from the Basic plan.

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.

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.

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. OpenRouter, Mistral, Groq, Cerebras, DeepSeek, Perplexity, Together AI, Hugging Face, Fireworks AI, Vercel AI Gateway, Arcee AI, Alibaba Model Studio, Z.AI, MiniMax, Moonshot AI, Baidu Qianfan, Volcano Engine, BytePlus, and Kimi Coding are supported. 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.

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.

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.

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.

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.

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.

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. If an image cannot be sent along, for example because it is too large or in an unsupported format, the assistant says so openly instead of silently ignoring it.

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.

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).

Agents

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

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.

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.

In the tool picker the tools are grouped into categories, each with a short description and its own switch: tia, 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.

When the assistant asks to open or show a block, it opens the block's source as a read-only editor — SCL / STL highlighted, XML for graphical languages — and reports a short confirmation in the chat.

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.

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 (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.

There are no exceptions: every managed tool 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. 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.

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.

Other extensions accessing your models

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.

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.