13 posts tagged with "agent mode"

An agent decides which tool to call almost entirely from one thing: the tool's description. Not its name, not its parameters — the sentence or two that says "Read the contents of a file in the project" is what the model weighs when it picks read_file over run_command.

Until now those descriptions were string literals compiled into the plugin. You could switch a tool off, but you couldn't tell the model anything about the tools that remained. So "use ./gradlew, never a global gradle" or "prefer semantic search over grep in this repo" meant repeating yourself in every prompt, or editing the plugin.

You can now rewrite any built-in tool's description from Settings.

Agent Mode is fast. You describe a migration, walk away, and come back to a finished answer and a changed project. The answer tells you what the agent says it did. Until now, DevoxxGenie had nothing to show you what it actually did.

That gap had a name: issue #705. The old Git Diff/Merge feature was removed back in 0.4.x because MCP tooling had made it obsolete — and nothing replaced the part people actually missed. A user put it plainly on the closed issue a few days ago:

Was just desperately searching why this feature is not available. Could someone point me in the right direction how to get a diff/merge view for approving changes suggested by an agent?

Fair question. Here's the answer, shipping in v1.13.0.

The local AI story on the Mac has always been a bit of a scavenger hunt. The models live in a Hugging Face cache, the server is a Python process you babysit in a terminal, the performance numbers are whatever flew past in the logs, and the chat UI is a browser tab pointed at localhost. It all works, but nothing about it feels like it belongs on a Mac.

Nativ fixes that with one opinionated move: it puts the whole workflow — chat, model management, serving, monitoring, and even hardware telemetry — inside a single native SwiftUI app. And as of DevoxxGenie 1.10.1, it's a first-class provider in the plugin, sitting right next to Ollama and LM Studio in the LLM Providers list.

Agent Mode is at its best when you stop babysitting it. Turn on "auto-approve read-only tools", let it explore, let it run your tests, and go get coffee.

The moment that stops being comfortable is run_command. Ninety-nine commands out of a hundred are ./gradlew test or git status. The hundredth is git reset --hard — and the agent runs it with the same cheerful confidence.

DevoxxGenie now lets you name that hundredth command in advance.

DevoxxGenie just passed a milestone worth celebrating: more than 72,000 downloads, and in this month alone 29,330 active users firing up the plugin inside IntelliJ IDEA. Thank you. Genuinely.

A smaller, opt-in slice of those users also share anonymous usage analytics. No prompts, no code, no file contents, no personal data, just coarse aggregated signals about which features get enabled, which providers get used, and which models get picked. The goal is simple: stop guessing about what matters and start building for how people actually work.

Even from that opted-in subset, more than 18,000 telemetry events over the past month paint a remarkably clear picture. A few of the patterns surprised me. Here is the story the data tells.

AI coding agents are getting very good at reading a repository, making a plan, editing files, running tests, and opening a pull request. But most of them still have one surprisingly human problem: they forget.

Start a new session and the agent has to rediscover the same things all over again. Why did we choose this architecture? Which fix already failed? What naming convention did the team settle on? Which test is flaky? What did the user explicitly prefer last time?

That is where Engram fits in. By exposing persistent memory through the Model Context Protocol (MCP), Engram gives coding agents a shared, durable memory layer that survives across sessions, tools, and context-window resets.

For months, DevoxxGenie's RAG pipeline worked beautifully — as long as you stayed in chat mode. Index your project into ChromaDB, ask a question, and the most relevant code chunks would automatically appear in the prompt as a <SemanticContext> block. It was invisible, automatic, and effective.

Then we shipped Agent Mode, and RAG fell off a cliff.

Users would ask conceptual questions like "which slides discuss MCP?" or "where do we explain the indexing pipeline?" and the agent would ignore the rich semantic context we had just injected. Instead, it reached for search_files — a regex grep — and returned nonsense. The semantic context had become wallpaper: present, but unseen.

DevoxxGenie has long had a way to bottle up reusable prompts as Commands: the /test, /explain, /review style slash commands that expand a template before sending it to the model. With the latest release we are adding a second, complementary mechanism called Skills: portable SKILL.md files on disk that the LLM itself decides to activate while it is thinking.

The big difference: Commands are typed by you, Skills are picked by the model. And because Skills live in the same directories that Claude Code, Codex and Gemini's .agents-aware tools already use, the same file can teach all four assistants the same playbook.

Security issues rarely announce themselves. Hardcoded API keys, injection vulnerabilities and outdated dependencies sit quietly in your codebase until someone finds them — ideally you, before anyone else does.

With v0.9.17, DevoxxGenie integrates three best-in-class open-source security scanners directly as LLM agent tools. Your AI assistant can now scan your project on demand, interpret the results in context, explain each finding, suggest remediations, and automatically create prioritised backlog tasks — all from a single prompt.

In the previous blog post, we introduced CLI Runners — a way to use your existing AI subscriptions (Claude Pro, Copilot, Gemini, etc.) directly inside IntelliJ by piping prompts to external CLI tools. CLI Runners solved the "double-paying" problem, but they communicate through plain text over stdin/stdout. That works, but it's a bit like having a conversation by passing notes under a door.

ACP Runners open that door. Instead of unstructured text, they use the Agent Communication Protocol — a structured, bidirectional communication layer built on JSON-RPC 2.0 — to turn your IDE into a proper agent hub.