The Core module of the Agent Development Kit for Java is the foundation everything else builds on. If you're evaluating whether to adopt ADK Java for a production agent, understanding what ships in Core tells you where the seams live, what you inherit for free, and where you'll need to extend.

This walkthrough covers the runtime boot sequence, the interfaces you actually implement, and the classes that show up in every non-trivial agent.

Advertisement

What Core provides

Core ships four things you use directly and a handful you rarely touch:

  • Agent runtime — event loop, tool dispatch, LLM call orchestration.
  • Agent lifecycle — initialization, execution, cleanup phases with hooks.
  • Tool integration framework — the contracts you implement to expose capabilities.
  • Session context — the mutable state passed through a single agent invocation.

Everything else — Dev UI, evaluation, A2A transport, Maven plugin — sits outside Core and depends on it.

The boot sequence

When you instantiate an agent, Core walks a deterministic path:

  1. Resolve model configuration (Gemini variant, temperature, output tokens).
  2. Register tools via the tool registry.
  3. Compile the instruction template into the runtime prompt.
  4. Wire the session context and event listeners.
  5. Signal ready — the agent will now accept invocations.

Boot is intentionally synchronous. The advantage: failures show up before you take traffic.

Advertisement

Classes you will touch

// The base you extend for a plain LLM-backed agent
public class MyAgent extends LlmAgent {
  @Override
  public String getInstruction() { return "You are a helpful assistant."; }

  @Override
  public List<Tool> getTools() { return List.of(new MyCustomTool()); }
}

LlmAgent, Tool, Session, AgentContext — these four types make up 80% of what you touch. Everything else is optional.

Where extension happens

Core exposes extension points at three levels:

  • Tools — implement Tool to add new capabilities.
  • Callbacks — pre/post hooks on invoke, tool call, model call, error.
  • Runtime substitution — swap the executor if you need custom threading semantics.

Most production agents only touch tools + callbacks. Runtime substitution is escape-hatch territory.

What Core does NOT include

By design, Core stays lean. You will not find:

  • Persistent session storage — bring your own (Redis, Postgres).
  • Rate limiting or quota enforcement — add via callbacks or a proxy.
  • Multi-agent orchestration — that's a higher-level concern, not Core.
  • Prompt versioning — Core sees the compiled instruction, not history.

Everything above lives in higher modules or your app layer. This is a feature, not a gap.

Read Core code once before writing your first agent — the boot sequence and extension points inform every design decision after.