About agents🔗

Available agents🔗

The following agents are available by default:

MVTec-specific agents🔗

HALCONSearch: This agent helps to search for a specific HALCON operator, a procedure, or a HALCON Script example. It cannot be used to search for custom procedures.
HScriptCoder: Integrated into HDevelopEVO, this agent is designed to assist developers with HALCON Script coding tasks. Use this agent to access the workspace and suggest modifications of files, or create entire HALCON Script programs. HScriptCoder is based on the Coder agent and thus inherits the features described below.

General-purpose agents🔗

Architect: This agent can access your workspace, it can get a list of all available files and folders and retrieve their content, but it cannot modify files. It can therefore answer questions about the current project, project files and source code in the workspace, such as how to build the project, where to put source code, where to find specific code or configurations, etc.
ClaudeCode: This agent is Anthropic’s AI coding assistant natively integrated into HDevelopEVO. Before using Claude Code, you need to install it. Go to their documentation for more details.
Code Completion: This agent provides inline code completion. It supports both manual and automatic modes for code completion. For more information, see Code completion.
Code Reviewer: Code review assistant that analyzes code changes and returns structured verdicts. Checks completion criteria, build/lint/test evidence, and code quality.
Coder: This agent can access your workspace, it can get a list of all available files and folders and retrieve their content. Furthermore, it can suggest modifications of files. It can therefore assist with coding tasks or other tasks involving file changes. For more information, see Working with Coder.
Codex: OpenAI’s coding assistant powered by Codex.
Command: This agent is aware of all commands that you can execute within HDevelopEVO. Based on the request, it can find the right command and then let you execute it.
Explore: Codebase exploration assistant that extracts and distills information from the codebase. Reports facts about what exists, provides code excerpts, and describes observed patterns.
Orchestrator: This agent analyzes your request against the description of all available chat agents and selects the best fitting agent to answer the request. Your request will then be directly delegated to the selected agent without further confirmation. This is the default agent.
ProjectInfo: This agent helps you create and maintain a project information file (by default .prompts/project-info.prompttemplate), which provides context about your workspace to other AI agents. This file serves as a knowledge base, which helps AI assistants understand your project’s architecture, conventions, and specific requirements.
Terminal Assistant: This agent provides assistance to write and execute arbitrary terminal commands. Based on request, it suggests commands and allows you to directly paste and execute them in the terminal. It accesses the current directory, environment, and the recent terminal output of the terminal session to provide context-aware assistance.
Universal: This agent provides answers to general programming and software development questions. It is also the fall-back for any generic questions you might ask. The universal agent currently does not have any context by default, that is it cannot access the current user context or the workspace.

Working with Coder🔗

Coder is an AI-powered coding chat agent designed to assist with structured code modifications directly within HDevelopEVO. It can browse the workspace, retrieve relevant context, and propose code changes that you can review and apply seamlessly.

Coder can be used for the following:

Text retrieval

Coder can browse the current workspace to find and read the content of relevant code files. As a user, you can augment your queries by mentioning or attaching specific files as context information to your chat messages to get faster and more accurate responses.
Propose changes

Coder provides structured code modifications that can be reviewed and applied automatically.
Fix file issues

Coder can automatically detect and fix issues in files by analyzing diagnostics reported by language servers, linters, and other tools.
Agent mode

Coder can operate as a fully autonomous agent that plans, writes, tests, iterates, and fixes code without requiring manual intervention at each step.
Task context

For complex development tasks, Coder works with task context to provide a structured, reproducible approach with clear planning before implementation.

To interact, type @Coder followed by your request into the chatline. This will also pin @Coder for the ongoing chat session, so in the following messages, you don’t need to mention @Coder again.

Available Coder modes🔗

Coder operates in two distinct modes that offer different levels of autonomy:

Edit Mode: Edit mode is the default interaction model that gives you full control over file changes. The agent proposes changes through structured prompt-based interaction. You review and approve each file modification before it’s committed. Changes are presented as diffs for easy review. Ideal for targeted code modifications where careful review is essential.
Agent Mode: Agent Mode transforms Coder into a fully autonomous developer that can write and modify files without requiring user approval for each change, compile and test the generated code, and interpret results from tests and builds. Further, it can fix its own errors and iterate until everything works correctly.
Agent Mode (“Next”): Agent Mode Next operates autonomously. This refined prompt in combination with several other refinements, for example on tool functions, make the agent more effective, reliable, and autonomous in its approach to coding tasks.

How to switch to agent mode:

Navigate to the AI Configuration and select Coder as the active agent.
Choose the agent-mode prompt.
Optionally, switch to a more powerful LLM like Sonnet-4, GPT-4.1 or Gemini-Pro for better results.
Enable notifications to get updates when long-running tasks complete.

Once active, the agent operates differently. It directly writes to the workspace, executes code, and even starts the application when complete.

Tip

To use Coder effectively, describe your programming task in clear, detailed, and natural prompts.
Coder will search your workspace for relevant code, but you can improve efficiency by specifying key locations such as code files that need to be modified, or supporting files that contribute to understanding the task, like interface definitions or similar implementations.
Agent mode preserves traceability of all changes via AI’s changeset feature.

Automatic issue detection and fixing🔗

Coder can identify and automatically fix problems in your code files. To use this feature, ask Coder to fix issues in a specific file. You can use context variables like #currentRelativeFilePath or #file:path to specify which file needs fixing.

Example

@Coder Fix all issues in #_f

When triggered, Coder will:

Open the specified file in an editor.
Collect all issues reported in the problem view including the diagnostics from language servers, linters, and spell checkers.
Propose automated fixes for the identified issues.

How to specify relevant context🔗

There are multiple ways to help Coder find the right files efficiently. Keep in mind that Coder operates with file paths relative to the workspace root:

Using context variables

Coder supports predefined variables that dynamically provide relevant context. You can just type them in your request in the chat input field. This allows you to not just add the file as context but also describe why the file is relevant, for example “Look at #file:src/api.ts as a reference for generating an implementation…”

Here are some examples of the most frequently used variables. You can see the full list of available variables when typing # in the chat input field:

#file:filePath

Inserts the path to the specified file relative to the workspace root. After typing #file:, auto completed suggestions will help you to specify a file. The suggestions are based on the recently opened files and on the file name you give.

#filePath

Shortcut for #file:filePath; after typing # followed by the file name, you can directly start your search for the file you want to add and reference in your message.

#currentRelativeFilePath (shortcut #_f)

The relative path of the currently selected file in the editor or explorer.

#currentRelativeDirPath

The directory path of the currently selected file.

#selectedText

The currently highlighted text in the editor.

This does not include the information from which file the selected text is coming. All files added to the context via variables will also appear in the context overview below the chat input field.
Adding files directly to the context

You can drag and drop files from the file explorer, or use the + button below the chat input field to directly add files to the context of a conversation. In contrast to using variables, you cannot describe the meaning of these files, though.
Natural language

You can describe the location in plain text, such as: “In the … package under src/browser.” While Coder will still need to search, this helps it to focus on the right area of your workspace. Always prefer providing context variables to directly point to relevant files, if you know the correct location of files already. This will lead to faster and more accurate results.

Using the `/remember` command🔗

The /remember slash command provides a convenient way to capture important context from your conversation and add it to the project info file. This command is available when using the Architect or Coder agents.

During a conversation, you may correct the AI agent about project-specific details or provide clarifications about your codebase. The /remember command analyzes your conversation history and extracts these corrections and clarifications, then delegates to the Project Info agent to update the project information file.

The command focuses specifically on information where you corrected the AI’s assumptions or provided context that it couldn’t discover on its own. This helps prevent future AI interactions from making the same mistakes.

To use the command, type /remember after a conversation where you provided corrections or clarifications:

@Coder /remember

You can also provide an optional topic hint to focus the extraction on a specific area:

@Architect /remember testing conventions

The extracted information is then added to your .prompts/project-info.prompttemplate file, making it available for future AI interactions.

Reviewing and applying code changes🔗

Based on your task and the provided context, Coder suggests code changes. This process may take some time. For transparency, you can observe which files Coder accesses in the chat. You can expand function calls such as getFileContent to see which files are accessed. While Coder generates file changes, you can also observe the code generation by expanding the function call arguments.

In the default prompt, Coder uses two functions to suggest changes, and you can also just review the prompt template.

changeSet_writeChangeToFile: Will rewrite the full file with a new, changed version. This is usually very robust, but might take a while to complete.
changeSet_replaceContentInFile: Will only replace specific segments of text within a file. This is faster but may require multiple attempts if the content to be replaced is ambiguous or if there are many similar patterns in the code.

Coder will usually select the best of the two functions above, based on the proposed change. If you experience continous issues, specifically, if the changeSet_replaceContentInFile function continuously fails, you can experiment with changing the default prompt or switching to the prompt variant coder-rewrite which will only rewrite files.

Configuring AI agents🔗

The AI Configuration view allows you to review and adapt agent-specific settings. Select an agent on the left side and review its properties on the right:

Enable Agent: Disabled agents will no longer be available in the chat or UI elements. Disabled agents also won’t make any requests to LLMs.
Language Model: Select to which language model the agent sends its requests. Some agents have multiple “purposes,” allowing you to select a model for each purpose.

Editing prompts🔗

You can open and edit prompts for all agents from the AI Configuration view. Click to open the prompt template editor. Changes saved in the prompt editor will take effect with the next request made to the corresponding agent.

You can reset a prompt to its default using the button in the AI Configuration view or the Revert toolbar item in the prompt editor.

As some agents come with several prompt variants, you can choose the active variant in the drop-down box. To create user-defined variants, browse to the prompt templates directory and create or copy a new file starting with the same ID as the default prompt of an agent.

You can use variables and functions in prompts. Variables are replaced with context-specific information at the time of the request (for example, the currently selected text), while functions can trigger actions or retrieve additional information.

Global variables: You can find an overview of all variables shared across agents in the Variables tab of the AI Configuration view.
Agent-specific variables: You can find variables declared and used exclusively by one agent in the agent’s configuration.

Variables are used with the following syntax:

{{variableName}}

Tool functions are used with the following syntax:

~{functionName}

Prompt template and fragment locations🔗

By default, custom prompts, prompt variants, and prompt fragments are created and read from user-wide local directories that can be configured in the settings AI Assistants > Prompt Templates. This setting is valid for all of your projects. In addition, you can configure workspace-specific directories and files that are available as prompts and prompt fragments to introduce project-specific adaptations and additions.

You can specify workspace-relative directories settings for individual files, relevant file extensions for prompt templates, and fragments under AI Assistants > Prompt Templates.
Workspace-specific prompts have priority, so you can override the prompts of the available agents in a workspace-specific way. Furthermore, these workspace-specific templates are accessible via the prompt fragment variable #prompt:filename in both the chat interface and agent prompt editors.

Prompt fragments enable you to define reusable parts of prompts for recurring instructions given to the AI. These fragments can be referenced both in the chat interface, for one-time usage, and within the prompt templates of agents, to customize agents with reusable fragments. For example, you can define a prompt fragment that specifies a task, provides workspace context or coding guidelines, and then reuse it across multiple AI requests without having to repeat the full text.

To support this functionality, HDevelopEVO includes a special variable #prompt:promptFragmentID that takes the ID of a prompt fragment as an argument.

Custom agents🔗

Custom agents enable you to define new chat agents with custom prompts on the fly. These agents are then immediately available in the default chat.

To define a new custom agent, navigate to the AI Configuration and click on Add Custom Agent. This opens the .yml file where all available custom agents are defined.

Custom agent configuration

id: obfuscator
name: Obfuscator
description: This is an example agent. Please adapt the properties to fit your needs.
prompt: Obfuscate the following code so that no human can understand it anymore. Preserve the functionality.
defaultLLM: openai/gpt-4o

The key fields are:

id: Unique identifier for the agent
name: Display name of the agent
description: Brief explanation of what the agent does
prompt: Default prompt that the agent will use for processing requests
defaultLLM: Language model used by default

Agent-to-agent delegation🔗

Agent-to-agent delegation is a powerful feature in HDevelopEVO that enables one AI agent to delegate specific tasks to another specialized agent. This creates multi-agent workflows where each AI agent can focus on its dedicated responsibility, leading to better automation and specialization.

The delegation system allows agents to:

Delegate specialized tasks: One agent can hand off specific work to another agent that’s better suited for the task.
Chain workflows: Create complex, multi-step processes by connecting different agents.
Maintain context: The delegating agent can pass along necessary context and continue its work after delegation.
Automate repetitive tasks: Set up workflows where routine tasks are automatically handled by specialized agents.

Agent skills🔗

Restriction

Agent skills are still in an alpha state. Use with care.

Agent skills provide a way to extend AI agents with reusable instructions and domain knowledge. Skills are defined in SKILL.md files that contain specialized guidance, workflows, or domain-specific knowledge that agents can leverage when responding to requests.

A skill is a directory containing a SKILL.md file with YAML frontmatter, defining name and description and markdown content that provides instructions or knowledge for agents. For example, you might create a “code-review” skill that defines how code reviews should be performed in your project, or a “testing” skill that specifies your testing conventions and requirements.

Skills allow you to:

Capture specific conventions and guidelines in a reusable format
Provide domain-specific knowledge to AI agents
Create consistent workflows that agents can follow
Share specialized instructions across your team

Using skills🔗

There are two ways to use skills in your AI chat requests:

Slash commands

The easiest way to use a skill is via a slash command. Type /skillName in the chat input. For example, if you have a skill named “code-review”, type:
/code-review Please review the changes in my current file
⤷ The skill’s instructions will be injected into the request, guiding the agent’s response.
On-demand loading by agents

Agents can also load skills dynamically. When the skills variable is included in an agent’s prompt, the agent receives a list of all available skills with their names and descriptions. The agent can then use the getSkillFileContent function to load the full content of any skill it determines to be helpful for the current request.

This approach is useful for agents that need to select the most appropriate skill based on the user’s request, rather than requiring the user to specify a skill explicitly.

Creating skills🔗

To create a skill manually:

Create a directory for your skill in one of the skill directories.
The directory name must be lowercase kebab-case, for example code-review, test-generation.

Create a SKILL.md file inside the directory with the following structure:

Example

---
name: code-review
description: Provides guidelines for performing thorough code reviews focusing on quality, maintainability, and best practices.
---
# Code Review Skill
## Overview
This skill provides instructions for performing comprehensive code reviews.
## Review Checklist
    1. **Code Quality**: Check for clean, readable, and maintainable code.
    2. **Error Handling**: Ensure proper error handling and edge cases.
    3. **Performance**: Look for potential performance issues.
    4. **Security**: Check for security vulnerabilities.
    5. **Testing**: Verify adequate test coverage.
## Guidelines
    - Be constructive and respectful in feedback.
    - Explain the reasoning behind suggestions.
    - Prioritize issues by severity.
    - Suggest improvements, not just point out problems.

The YAML frontmatter, between the --- markers, must include:

name: Must be lowercase kebab-case and match the directory name exactly
description: Brief description of the skill (maximum 1 024 characters)

The Markdown content after the frontmatter contains the actual instructions that will be provided to the agent.

Skill directories🔗

Skills are discovered from multiple locations in the following priority order:

Project-specific skills for the workspace: .prompts/skills/ in your workspace root
User-configured: Directories listed in the ai-features.skills.skillDirectories preference

To add additional skill directories, configure the ai-features.skills.skillDirectories setting in your preferences. You can use ~ to reference your home directory:
```
{
  "ai-features.skills.skillDirectories": [
    "~/my-skills",
    "/shared/team-skills"
  ]
}
```
User-wide global defaults: ~/MVTec/HDevelopEVO/skills/ (Linux) or %APPDATA%\Roaming\MVTec\HDevelopEVO\skills (Windows)

You can view all discovered skills in the Skills tab of the AI Configuration view.

CreateSkill agent🔗

The CreateSkill agent helps you create new project-specific skills through the AI chat interface. Instead of manually creating the directory structure and SKILL.md file, you can describe the skill you want and the agent will generate it for you.

How to use the CreateSkill agent:

Mention the agent in the chat: @CreateSkill.
Describe the skill you want to create.
⤷ The agent will generate a properly structured SKILL.md file with appropriate frontmatter and content.

For example:
@CreateSkill: Create a skill for documenting TypeScript functions that includes JSDoc conventions and example formats

The CreateSkill agent supports two modes:

Default Mode: Proposes the skill file as a changeset for you to review before applying
Agent Mode: Writes the skill file directly to disk

Note

To use the CreateSkill agent, you need to add .prompts/skills to the list of skill directories in your configuration. This allows the agent to save newly created skills to your project’s local skills directory.