Link to recording:
Introduction
Artificial Intelligence has evolved rapidly from simple code assistance tools to systems capable of executing complex engineering workflows. In industrial automation, this evolution is often described as Agentic Engineering—the combination of Large Language Models (LLMs) with specialized tools, engineering knowledge, and runtime environments that allow AI to actively participate in software development, testing, debugging, and system configuration.
The key difference between traditional AI assistants and agentic systems is that agentic systems do not only generate text or code. They can interact with engineering environments, execute tasks, analyze results, adapt their actions, and continue working toward a defined goal.
Why Agentic Engineering Matters
Industrial automation projects share several characteristics that make them suitable for AI-assisted workflows:
- Large code bases
- Repetitive engineering tasks
- Extensive configuration work
- Hardware and software dependencies
- Long validation and testing cycles
- Significant amounts of documentation
Many engineering activities are not difficult but are time-consuming and error-prone. Examples include:
- Migrating projects between software versions
- Converting legacy implementations to newer architectures
- Fixing compiler warnings
- Resolving configuration inconsistencies
- Generating HMI screens
- Setting up communication mappings
- Creating repetitive engineering structures
Agentic Engineering aims to reduce the effort spent on these activities while allowing engineers to focus on system design and domain expertise.
What Is an Agentic Engineering System?
An Agentic Engineering system consists of several layers:
1. Large Language Model (LLM)
The LLM provides reasoning capabilities and understands:
- Natural language requirements
- Engineering documentation
- Source code
- Configuration files
- Diagnostics information
2. Tooling Layer
The tooling layer allows the AI to interact with the real world.
Examples include:
- Code compilation
- Simulation control
- File manipulation
- Project modification
- PLC communication
- Testing frameworks
- Documentation search
Without tooling, an AI can only suggest solutions. With tooling, it can execute and validate them.
3. Engineering Knowledge
Engineering-specific knowledge is delivered through:
- Instructions
- Skills
- Templates
- Documentation access
- Context providers
This allows AI to understand technologies, coding standards, naming conventions, and project architectures.
4. Validation and Feedback
The most valuable capability of Agentic Engineering is the ability to validate its own work through:
- Compilation
- Simulation
- Automated testing
- Runtime diagnostics
- Logbook analysis
This creates a closed feedback loop where the AI can identify mistakes, apply corrections, and re-test solutions.
Why B&R Industrial Automation Is Well Positioned
Modern automation systems increasingly rely on textual and structured project formats.
Key enablers include:
- Text-based project files
- Structured configuration formats
- Machine-readable documentation
- Simulation environments
- Programmatic interfaces to controllers
- Accessible diagnostics and logbooks
These characteristics make automation projects understandable and manipulable by AI systems.
When engineering assets are stored as text rather than binary data, AI tools can:
- Read projects directly
- Modify configuration files
- Generate source code
- Refactor legacy implementations
- Analyze system structures
AI-Assisted Development Workflow
A typical Agentic Engineering workflow follows a cycle:
Step 1: Requirement Analysis
The engineer provides a specification or goal.
Examples:
- Create a state machine
- Add a motion axis
- Generate an HMI
- Implement an OPC UA model
- Migrate an existing project
Step 2: Code and Configuration Generation
The agent creates:
- Program logic
- Variable declarations
- Data structures
- Hardware configurations
- Communication mappings
Step 3: Build Verification
The project is compiled automatically.
The AI:
- Reads compiler output
- Detects errors
- Applies fixes
- Rebuilds the project
This loop continues until the project compiles successfully.
Step 4: Automated Testing
Compilation alone does not guarantee system correctness.
The next stage includes:
- Simulation startup
- Variable monitoring
- Input stimulation
- Output verification
- State-transition testing
The AI interacts with the system similarly to a human engineer but at significantly higher speed.
Step 5: Runtime Diagnostics
The agent can analyze:
- Logbooks
- Warnings
- Runtime faults
- Communication errors
It then attempts corrective actions and verifies the result through additional testing.
HMI Engineering with AI
One of the most promising applications is Human-Machine Interface development.
An AI workflow can:
- Create page structures
- Generate navigation
- Configure user roles
- Setup permissions
- Bind variables
- Configure events
- Implement layouts
The generated HMI can then be automatically tested using browser automation frameworks.
The validation process may include:
- Screenshot analysis
- Layout verification
- Navigation testing
- User authentication testing
- Permission checking
- Interaction validation
This transforms HMI development from a largely manual process into an iterative, AI-assisted workflow.
Automated Testing as a Core Capability
A major challenge in engineering automation systems is ensuring generated code actually works.
Agentic Engineering addresses this through automated validation.
An AI system can:
- Start simulations
- Connect to virtual controllers
- Read variables
- Write signals
- Execute test scenarios
- Verify outputs
Instead of only generating code, the AI becomes responsible for proving that the implementation behaves as expected.
This significantly increases trust in generated solutions.
Practical Use Cases
Several categories of tasks benefit particularly well from Agentic Engineering.
Legacy Migration
Examples include:
- Framework upgrades
- Architecture changes
- Technology transitions
- Version migrations
AI can analyze existing implementations and convert them into newer formats while preserving functionality.
Error Reduction
AI is effective at identifying:
- Logic inconsistencies
- Comparison errors
- Runtime warnings
- Configuration mistakes
By inspecting large code bases systematically, agents can uncover issues that might otherwise remain hidden.
Log and Diagnostic Analysis
Machine diagnostics often contain large amounts of text data.
AI systems can:
- Analyze logbooks
- Interpret event sequences
- Examine protocol traces
- Identify root causes
This significantly reduces troubleshooting effort.
Engineering Automation
Agents can build engineering artifacts such as:
- Configuration files
- OPC UA models
- Mapping structures
- Access definitions
- Communication setups
Tasks that previously required hours of repetitive work can be completed in minutes.
The Importance of Open Tooling
A critical success factor for Agentic Engineering is openness.
AI systems require:
- APIs
- Command-line interfaces
- Documentation access
- Structured file formats
- Standardized integration points
Closed systems limit the value of AI because the agent cannot interact effectively with the engineering environment.
Open tooling enables:
- Continuous integration
- Automated testing
- Workflow automation
- Digital engineering pipelines
- Multi-agent systems
Challenges and Limitations
Although the progress is impressive, Agentic Engineering is not a replacement for experienced engineers.
Current limitations include:
- Hallucinations
- Incomplete understanding of requirements
- Incorrect assumptions
- Context limitations
- Non-deterministic behavior
Successful implementations therefore rely on:
- Validation loops
- Automated testing
- Human review
- Domain-specific instructions
- Engineering expertise
The role of engineers shifts from manually creating every artifact to defining goals, validating outcomes, and improving workflows.
Outlook
The convergence of Information Technology (IT) and Operational Technology (OT) is accelerating. Agentic Engineering represents another major step in this evolution.
Future systems are expected to provide:
- Deeper IDE integration
- AI-native engineering workflows
- Autonomous testing environments
- Multi-agent collaboration
- Enhanced simulation-driven development
- Automated lifecycle management
Rather than replacing engineers, these technologies will likely become powerful force multipliers that reduce repetitive work and accelerate innovation.
Conclusion
Agentic Engineering extends AI from a passive assistant into an active engineering participant. By combining reasoning models with tooling, domain knowledge, validation frameworks, and automation interfaces, it becomes possible to generate, test, debug, and refine automation solutions with minimal manual effort.
The real breakthrough is not AI-generated code. The breakthrough is the creation of closed engineering loops where AI can generate, verify, learn from feedback, and improve the result autonomously. For industrial automation, this has the potential to fundamentally change how engineering projects are developed, maintained, and evolved over the coming years.
Session 1 – Q&A
1. Can we download the files used in the demo?
We will be releasing the Agentic Engineering template and other tools used in this demo in the future. For this webinar, we only showcased functionality that is currently under development. These files are also used for our Getting Started Workshop for customers. For more details, get in touch with your local B&R sales representative.
2. What are the benefits of using B&R mapp View instead of connecting directly to an OPC UA server and developing the HMI with tools such as Visual Studio Code, GitHub Copilot, and JavaScript?
Quality and Reliability
mapp View is a tested and supported product.
Responsibility and Compliance
With mapp View, customers receive a validated software package, including documentation and certifications.
If customers build their own AI-generated solution, they become responsible for:
- Cybersecurity
- Threat modeling
- Supplier evaluation
- Certification processes
- CRA compliance
- Long-term maintenance
Support
If a mapp View application has an issue, B&R Support can assist.
If a custom AI-generated solution has an issue, the customer owns the problem.
Bug Ownership
Customers often expect vendors to help identify and fix issues.
With a self-developed AI solution, debugging and maintenance remain entirely with the developer.
3. Can the live demo example be shared (e.g., via a local B&R office)?
We will be releasing the Agentic Engineering template and other tools used in this demo in the future. For this webinar, we only showcased functionality that is currently under development. These files are also used for our Getting Started Workshop for customers. For more details, get in touch with your local B&R sales representative.
4. How can I start implementing this workflow today? I would like to use agents to check code quality and run tests. What tools do you recommend?
You should set up at least the following:
-
Access to build Automation Studio projects using BR.AS.Build.exe
-
Project-specific instructions explaining:
- Project structure
- Important conventions
- Architecture guidelines
-
Coding guidelines and Automation Studio-specific rules, such as:
- Adding new files to
Package.pkg - Adding programs to
Cpu.sw - Other project-specific requirements
- Adding new files to
-
Reproducible workflows implemented as skills, for example:
- Adding a task
- Compiling the project
- Adding a device to
Hardware.hw - Creating libraries
- Running tests
We can offer you a Getting Started Workshop for customers or consultancy. For more details, get in touch with your local B&R sales representative..
5. What models have you used in your tests? I saw Claude Sonnet, but I assume it was used through GitHub Copilot. What are your experiences with mixed codebases containing both ST and C? Did you also try native Claude or other models?
At ABB, we currently use GitHub Copilot as the primary harness, so all testing and development shown in this webinar has been performed using that environment.
In general, different LLMs are best suited for different types of tasks:
- Small models – targeted implementations and simple tasks
- Mid-sized models – general-purpose development work
- Large models – complex planning, architecture work, and deep codebase analysis
Mixed codebases are not a problem. The mapp View example shown during the webinar already involved a different language and syntax (XML). The same principle applies when working with both Structured Text (ST) and C in a single project.
6. Where can I find the skills for migrating VC4 to mapp View using Agentic Engineering?
These skills will be included in the Agentic Engineering template that will be released in the future.
At the moment, this is still work in progress.
7. Does this whole approach only work if you have the right samples and skills?
Short answer
Yes.
Long answer
Yes, but large codebases provide additional advantages. When a project contains a significant amount of existing code, the agent can use it as a reference and infer syntax, conventions, and implementation patterns more accurately.
8. How long does it typically take to create instructions, and how do I get started?
It depends on the complexity of the project and whether an AI agent can generate an initial version from existing examples.
Creating instructions can take anywhere from:
- A few minutes
- Several hours
- One day or more
Instructions are never truly finished. They evolve continuously and should be refined based on:
- The codebase
- Team experience
- Lessons learned during agentic coding sessions
We can offer you a Getting Started Workshop for customers or consultancy. For more details, get in touch with your local B&R sales representative.
9. In which version of Automation Studio will this be available? Only AS6?
The current plan is to support AS6 only.
as-cli will most likely not work with AS4.
The Agentic Engineering Template may work to some extent with AS4, but there are significant differences between AS4 and AS6:
- XML file structures changed
- New functionality was added
- Existing functionality evolved
As a result, migration-related skills may produce mistakes when used with AS4 projects.
The MCP servers support both AS4 and AS6.
10. Werden die bereits erstellten Beschreibungen (.md-Files) wie Skills von B&R zur VerfĂĽgung gestellt?
Yes. We will be releasing the Agentic Engineering template and other tools used in this demo in the future.
For this webinar, we only showcased functionality that is currently under development.
These files are also used for our Getting Started Workshop for customers. For more details, get in touch with your local B&R sales representative.
11. Would a migration from AS4.12 with ACP10 to AS6 with mapp Motion be a good use case for the Agentic Engineering approach?
Yes.
This is one of the strongest use cases for Agentic Engineering.
In essence, you are translating from one technology stack or “language” to another, which is a scenario where AI agents can provide significant value.
12. AI seems to do all the work based on help files, predefined skills, and instructions. However, it must also rely on specifications describing what the project should do. These specifications are typically written by humans. Can you show examples of such specifications?
Good observation.
To keep the webinar focused, a large part of the planning process was intentionally skipped.
Successful Agentic Engineering requires:
- Detailed requirements
- Well-defined architecture
- Clear software specifications
Machine requirements alone are not sufficient. They need to be translated into software requirements that explain how the system should behave and how features should work.
Example workflow for machine automation projects
- Create machine requirements
- Create software requirements
- Define requirements for individual machine modules and their interactions
- Use the planning capabilities of your AI harness (e.g.,
/plan) to create an implementation strategy - Refine the plan until it satisfies all requirements
- Implement the solution
A larger model is typically best suited for planning and architecture, while implementation can often be handled effectively by a smaller, faster model.
This topic is also covered by our Getting Started Workshop for customers. For more details, get in touch with your local B&R sales representative.
13. Wann ist eine vollständige Implementierung in Automation Studio geplant, sodass man AS nicht mehr verlassen muss?
There are currently no plans to integrate Agentic Coding directly into Automation Studio 6.
To use Agentic Engineering with B&R, you will need:
-
An AI coding environment such as:
- GitHub Copilot
- Claude Code
- OpenCode
- Similar tools
-
The B&R VS Code extensions that will be released in the future
Combined with:
- The Agentic Engineering Template
- MCP servers for contextual help
as-clifor Automation Studio automation
This will provide a complete AI Engineering environment for B&R AS6 projects within Visual Studio Code.
Session 2 – Q&A
14. Hi, is logger analysis possible with a prompt, or is it necessary to direct the AI to the logger file’s path?
Yes. as-cli will support logbook reading directly through the PVI interface.
Alternatively, you can manually provide a system dump or log file for the agent to analyze.
15. Can I modify and work directly from Claude Code?
Yes.
Our tools are designed to work with all major AI coding harnesses on the market, including local models.
They provide:
- B&R domain knowledge
- Automation Studio project structures
- B&R-specific syntax guidance
- Automation Studio interaction capabilities
- Testing and validation capabilities
This allows you to use your preferred AI coding environment while benefiting from B&R-specific expertise.
16. Where can I find more information about the Local B&R Help & Community MCP Servers? How can they be used?
The MCP servers are available on the B&R Community GitHub:
For additional background and examples, see:
17. Have you had any experience using motion simulation (Scene Viewer, etc.) together with AI agents?
Scene Viewer is primarily a visualization tool rather than a simulation engine, so using it alongside agents should not be a problem.
At the moment, Scene Viewer does not expose any dedicated tools that an AI agent can directly interact with.
Regarding tools such as:
- Simulink
- RobotStudio
- iPhysics
- Blender
I do not yet have experience generating complete digital twins with AI agents. Some of these platforms already provide their own MCP servers or command-line tooling that could potentially be integrated into an agentic workflow.
18. When are you planning to release the AS CLI tool?
There is currently no confirmed release date.
The current plan is to make it available during 2026.
19. Will there be training modules or content on Automation Academy covering the use of these agents?
The current plan is to provide:
- Workshops
- Consulting services
through local B&R AI experts.
At this time, no Automation Academy online course or formal training program is planned.
20. When you mention that a conversion from VC4 to mapp View may be possible in the near future, does that mean VC4 will become open (text-based), or do you mean a closed conversion tool?
VC4 is already fully text-based and uses XML as its underlying markup language.
This allows an AI agent to:
- Read VC4 projects
- Analyze their structure
- Translate them into mapp View projects
Because not everything can be converted 1:1, we are pursuing an agent-based migration approach rather than a traditional conversion tool.
21. Have you tried designing an HMI in Figma first and then transforming it into an Automation Studio project?
Not yet.
However, Figma already provides:
- MCP server capabilities
- Strong AI integrations
Based on these capabilities, this should be a relatively straightforward workflow to implement in the future.
22. When the AI generates an error, does it recognize and fix it within the same loop, or do you need to retrigger it for cleanup?
This is one of the key differences between vibe coding and proper Agentic Engineering.
A successful agentic workflow includes:
- Validation
- Testing
- Verification steps
This is exactly why we are preparing capabilities such as:
as-cli- MCP servers
- Reusable skills
These components allow an agentic loop to validate results continuously and detect errors automatically before moving to the next step.
23. How many credits were used for the complete build-up task?
I used Claude Sonnet 5 (High) for all tasks while taking advantage of promotional pricing.
Session Statistics
- Total duration of all sessions: 1 hour 45 minutes
- Total AI credits consumed: 2,050 credits
Pricing Used
| Token Type | Credits per 1M Tokens |
|---|---|
| Input | 200 |
| Output | 1,000 |
| Cache Read | 20 |
| Cache Write | 250 |
Summary: All sessions combined consumed approximately 2,050 AI credits.