Skip to content

AI Terminology and How Junie Works

Introduction

Modern AI coding assistants are built from multiple components working together. Understanding the terminology helps explain why tools such as Junie are much more capable than a standalone chatbot.

Core AI Terminology

LLM (Large Language Model)

An LLM is the component responsible for reasoning and generating responses.

Examples include:

  • Claude
  • GPT
  • Gemini

The LLM understands requests, generates code, and makes decisions, but on its own it cannot directly interact with files, IDEs, or build systems.

Agent

An agent is a system that uses an LLM to achieve a goal by performing multiple actions.

Instead of producing a single response, an agent can:

  • Analyze a task
  • Create a plan
  • Use tools
  • Evaluate results
  • Continue until the task is complete

Agent Framework

The agent framework is the software layer that manages the workflow between the LLM and available tools.

Its responsibilities include:

  • Planning work
  • Executing actions
  • Collecting results
  • Iterating when problems are found

The framework turns a conversational model into a system that can perform real work.

Tools

Tools are capabilities that can be used by the agent.

Examples:

  • File editing
  • Project search
  • Terminal commands
  • Build execution
  • Test execution
  • Git operations

The agent decides when and how to use these tools.

Skills

A skill is a reusable workflow, instruction set, or procedure that guides the agent.

Skills are typically implemented as:

  • Markdown documents
  • Prompt templates
  • Workflow definitions

Skills do not change the model itself. Instead, they provide reusable knowledge about how a task should be performed.

MCP (Model Context Protocol)

MCP is a standardized way to expose tools and context to AI systems.

It allows AI agents to interact with external systems in a consistent manner.

MCP can be used as part of an AI solution, but it is not the same thing as the agent itself.

How Junie Works

High-Level View

Junie combines a powerful LLM with an agent framework and deep IDE integration.

Conceptually:

Junie
  = LLM
  + Agent Framework
  + IDE Integration
  + Tools
  + Skills

Role of the LLM

The LLM is responsible for:

  • Understanding requests
  • Creating plans
  • Reasoning about code
  • Generating solutions

Junie can work with several modern LLMs rather than relying on a single proprietary model.

Role of the Agent Framework

The agent framework manages the workflow.

For a task such as:

Upgrade this project to a newer CMake version.

The framework can:

  1. Inspect the project
  2. Find relevant files
  3. Modify source code
  4. Run builds
  5. Analyze errors
  6. Apply fixes
  7. Run tests
  8. Verify the result

IDE Integration

Junie gains additional context from the JetBrains IDE.

This can include:

  • Project structure
  • Symbols and references
  • Refactoring support
  • Code inspections
  • Build integration

This provides far more project awareness than a normal chat-based AI.

Custom Commands

Junie allows users to define reusable commands using Markdown files.

A custom command can describe:

  • A process
  • Coding standards
  • Validation steps
  • Project-specific workflows

These commands can be viewed as reusable skills that help the agent perform tasks consistently.

Summary

A useful mental model is:

LLM              = Intelligence
Agent Framework  = Orchestrator
Tools            = Capabilities
Skills           = Procedures
IDE Integration  = Project Knowledge

Junie is not simply an LLM. It is a complete agent system that combines reasoning, tooling, workflows, and IDE integration to perform complex software development tasks.