Skip to main content

How Explyt works

Explyt is an AI agent inside your JetBrains IDE. You state a task in the chat, and the agent gathers project context, picks the right IDE tools, makes changes, and verifies the result. You control which tools it may use and review the edits before you keep them in the project.

The agent and its modes​

The mode determines what the agent focuses on and which tools it can use.

  • General suits most tasks. It can call specialized subagents when the work requires exploring the project first, then changing code and verifying the result.
  • Ask reads the project but does not modify files. Use it to understand unfamiliar code or discuss a solution.
  • Code reads and edits files. It suits ordinary changes in a project.
  • Debug drives the IDE debugger: it sets breakpoints, runs the program, and inspects variable values and the call stack.
  • Test specializes in creating tests.
  • Review focuses on checking changes and can use IDE inspections. The main file-editing tools are unavailable in it, but the tool set depends on your configuration and does not provide a strict technical read-only guarantee.
  • Plan prepares a plan with subtasks and acceptance criteria before a large piece of work.
  • Orchestrator distributes a large task across specialized subagents.

For a full description of each mode and its limits, see Agent modes.

Where the agent gets context​

You can attach a file, a directory, a selected code fragment, a log, or a report to your message. When needed, the agent explores the project further on its own: it finds symbol declarations and usages, reads the file structure, and checks the errors the IDE sees.

The IDE integration gives the agent facts about your current project, not just file text. For example, it can:

  • find usages of a class or method with awareness of the language and code structure;
  • read the code of a linked dependency and check the API of exactly the version used in the project;
  • get the list of configured run configurations;
  • use the results of inspections, tests, coverage, and debugging.

Persistent project context can be written into AGENTS.md, and repeatable instructions into Rules and Skills.

Which tools the agent uses​

The agent works with files and with JetBrains IDE tools. The available set depends on the mode, the IDE, and the language.

To change code, it can create and edit files; to rename symbols, it can apply IDE refactorings, which update declarations and usages. To verify its work, the agent runs IDE configurations, gets structured test and build results, and collects coverage in the supported IDEs. In Debug mode it works with breakpoints, the call stack, and variable values.

The exact list of capabilities per IDE and mode is in the feature matrix. That is a reference table: start with this overview and turn to the matrix when you need to check support for a specific tool.

Permissions and control​

You can allow or forbid individual actions, such as running commands. For files, several levels of control apply:

  • Edit Scope allows changes only in the files and directories selected for the current task;
  • .writeignore forbids writing and creating files at the listed paths but leaves them readable;
  • .readignore forbids reading the listed paths;
  • to close a path for both reading and writing, add it to both files;
  • access to files outside the project is configured separately in the Explyt settings.

Ignore-file rules use gitignore-like patterns, but the documentation does not promise support for the full .gitignore syntax.

Set your limits in advance before a task that touches sensitive files. For example, you can keep tests in .writeignore when the agent should fix the implementation but not change the check itself.

How to verify the result​

Do not treat a chat response as a finished result on its own. Ask the agent to run the appropriate test or build configuration and report what exactly was verified. If the error only shows up at runtime, use Debug mode.

After the changes:

  1. Open Agent Changes and review the diff for each file.
  2. Reject unnecessary edits or ask the agent to fix them.
  3. Run tests, a build, or a coverage check through IDE configurations.
  4. For an independent check, run Auto Review.

This gives the task a verifiable outcome: a concrete diff and a run result, not just a description of the work done.

Where to go next​