// The agent
class ClaimAgent extends Thinker<ClaimIn, ClaimOut> {

  ClaimAgent() {
    setObjective(
      "Review the hospital indemnity claim. " +
      "Verify eligibility, check coverage, " +
      "validate documentation, calculate payment.");

    registerTool(GetClaimDataTool.class);
    registerTool(CheckCoverageTool.class);
    registerTool(CalculatePaymentTool.class);
    registerGuardrail(ClaimScopeGuard.class);
  }
}

// A tool: thin data accessor
class GetClaimDataTool extends Tool<ClaimId, ClaimData> {

  ClaimData execute(ClaimId in) {
    return db().get(ClaimData.class, in.id());
  }
}

A closer look

Agents and Tools

If the agent is the human in the workflow, the tools are the software that human reaches for. In Nucleo terms, the agent is a Thinker (the Redouble AI terminology for a loop agent): it receives an objective and a set of tools and decides autonomously which to use, in what order, and how to interpret the results.

Each tool does exactly one thing, with scoped permissions and type-safe inputs and outputs. A workflow can run for hours across dozens of agents, and every step is governed.

Agents are tools too: any Thinker can be registered as a tool on another Thinker. Compose arbitrary DAGs of specialized agents (each with its own objective, tools, and guardrails), and the runtime handles orchestration.

Integrations

Most of your data already has a Java client. Databases, filesystems, S3, SOAP and REST APIs, message queues, internal services. Whatever your enterprise already runs on, your agents connect to it directly, using the libraries, credentials, and access controls your applications already trust. No rewriting data sources into intermediate protocols to make them agent-reachable.

For third-party AI tools, Nucleo speaks MCP (STDIO and HTTP) natively. Paywalled and quota-gated services are handled with credential management and per-call accounting. Every connector sits under the same guardrail, permission, and observability layers as everything else in the runtime.

// Verifies the claim belongs to a project
// the agent is authorized to operate on.
class ClaimScopeGuard extends Guardrail<ClaimId> {

  void validate(ClaimId in) throws GuardrailException {
    Long requested  = db().get(ClaimData.class, in.id()).projectId();
    Long authorized = thinker().scopeId();

    if (!requested.equals(authorized)) {
      throw new GuardrailException(
        "Claim " + in.id() + " is outside scope " + authorized);
    }
  }
}

// Wired into the agent. Runs on every tool invocation.
class ClaimAgent extends Thinker<ClaimIn, ClaimOut> {

  ClaimAgent() {
    registerGuardrail(ClaimScopeGuard.class);
    // ... tools registered here
  }
}

Deterministic Guardrails

When a human uses enterprise software, their permissions are checked and their inputs validated on every call. Agents get the same treatment. Every tool call is validated by guardrails enforced in code: role-based permissions, business logic checks, data scope enforcement. Agent outputs are validated, scoped, and permission-checked before they touch any system. Production-grade rigor, applied consistently across every agent, every tool, every handoff.

// Domain object. Most fields visible to the LLM verbatim.
// One field is summarized on the way out.
class ClaimArtifact extends Artifact {
  Long       id;
  String     memberId;
  LocalDate  dateOfService;
  Money      billedAmount;
  Money      allowedAmount;

  @LLMSummarizable
  String     chartNotes;    // full text in registry; summary to LLM
}

// Tool produces the artifact. Framework wraps it before
// the LLM sees it - chartNotes goes through the summarizer.
class FetchClaimTool extends Tool<ClaimId, FetchClaimOutput> {

  FetchClaimOutput execute(ClaimId in) {
    return new FetchClaimOutput(
      db().get(ClaimArtifact.class, in.id()));
  }
}

Incorruptible Domain Objects

Domain objects are protected at the architectural level: no data deterioration or permissions creep across agent-to-agent handoffs, regardless of chain length. Long chains mean agents can be highly specialized. Specialized agents are more secure, more repeatable, and more resistant to prompt injection. Narrow, well-defined tasks also fit smaller, cheaper models without loss of quality. Better security, better output, lower cost, all flowing from the same architectural decision.

Resource Management

Nucleo allocates every resource precisely across concurrent workflows: database connections, LLM tokens, HTTP permits, custom rate limiters. Agents don't hold any of them while idle; each is acquired for the instant it's needed and released immediately after. Failure domains are isolated at the agent level. Virtual-thread concurrency lets standard hardware host thousands of concurrent agents.

Inference Optimization

The biggest cost of running AI agents is inference – and it's the one cost managed platforms are structurally ill-suited to optimize. They operate outside the agent: they see containers and sessions, but they can't see inside the agent's reasoning. The agent code can't reach down to optimize the runtime it's sitting on either. Two separate worlds.

Nucleo unifies both. The runtime sees every decision the agent makes, and the agent benefits from every optimization Nucleo provides. The result is a pipeline of optimizations only possible when runtime and agent share the same process:

Intelligent Compaction

Automatic four-level context compaction that proactively shrinks the prompt while preserving essential information

Field Summarization

Large data objects are automatically condensed before entering the prompt, with full data still accessible on demand

Incorruptible Domain References

Data flows by reference across agent handoffs, eliminating hallucinated-identifier cascades

Surgical Retry

Failed steps retry in isolation; the rest of the chain stays intact

Pre-execution Guardrails

Bad input caught before the tool runs, before any inference is spent

Open source

Nucleo is open source under the Apache 2.0 license. The code that runs the agents is open to read, to change, and to run, so control is always within reach

Run the Demo

The repository's AGENTS.md sets up the demo and is written for a coding agent to follow. Every step is a command with a checkable result, so it works as a quickstart by hand too.

Read the Documentation

The Docs carry the guides in reading order, an example for each thing the runtime does, and the full API reference.

Want Enterprise Support?

Silverlake is the enterprise platform built on top of Nucleo: compliance, security, observability, SLAs and warranty, with a forward-deployed team.

Nucleo: Intelligence as a Java Component.

Agents and Tools

Integrations

Deterministic Guardrails

Incorruptible Domain Objects

Resource Management

Inference Optimization

Intelligent Compaction

Field Summarization

Incorruptible Domain References

Surgical Retry

Pre-execution Guardrails

Nucleo is open source under the Apache 2.0 license. The code that runs the agents is open to read, to change, and to run, so control is always within reach

Run the Demo

Read the Documentation

Want Enterprise Support?

Ready to Run Agents Inside
Your Own Application?

Agents and Tools

Integrations

Deterministic Guardrails

Incorruptible Domain Objects

Resource Management

Inference Optimization

Intelligent Compaction

Field Summarization

Incorruptible Domain References

Surgical Retry

Pre-execution Guardrails

Nucleo is open source under the Apache 2.0 license. The code that runs the agents is open to read, to change, and to run, so control is always within reach

Run the Demo

Read the Documentation

Want Enterprise Support?

Ready to Run Agents InsideYour Own Application?

Ready to Run Agents Inside
Your Own Application?