DEV Community: sekka

How I stopped Claude Code from ignoring my conventions

sekka — Wed, 03 Jun 2026 21:16:01 +0000

Github repo: https://github.com/datallmhub/claude-governance

Adaptive execution for Java agents: reason-aware retries and budget-aware routing

sekka — Wed, 27 May 2026 08:20:52 +0000

If your LLM agent retries a 429 fifty times overnight, retries a 400 three times before giving up, and sends every request to your top-tier model until the run budget is gone, those aren't bugs in the model. They're missing two cheap policies your orchestration layer should be making for you.

AgentFlow4J v0.7.0 (Java multi-agent orchestration on Spring AI) ships those two policies.

1. Reason-aware retries

A RetryPolicy that counts attempts is blind to why a call failed. v0.7.0 adds a FailureClassifier that sorts every failure into one of three categories:

Category	What the graph does
`TRANSIENT`	Retry. If the failure carries a `Retry-After` hint, that delay is honoured instead of the computed backoff.
`PERMANENT`	Stop immediately — no further attempts.
`OVER_BUDGET`	Stop and surface an `InterruptRequest` so a human can approve more budget and resume.

The default classifier already understands JDK I/O exceptions, Spring AI / Spring Web 5xx + 429 (parsing Retry-After) vs other 4xx, and BudgetExceededException, all detected by class name, so agentflow4j-graph keeps zero compile-time Spring dependency.

Adding your own rules composes via orElse:

FailureClassifier domain = cause -> {
    if (cause instanceof QuotaExhaustedException) return FailureClassification.overBudget("monthly quota hit");
    if (cause instanceof InvalidPromptException)  return FailureClassification.permanent("rejected by guardrail");
    return null; // unknown — defer to the default
};

RetryPolicy policy = RetryPolicy.exponential(3, Duration.ofSeconds(1))
        .withClassifier(domain.orElse(FailureClassifier.defaults()));

Existing policies that only set the legacy retryOn predicate keep their exact behaviour, the classifier falls back to it when it returns null.

2. Budget-aware routing

BudgetPolicy already caps the cost of a run. v0.7.0 lets it shape which model handles which request:

BudgetPolicy budget = BudgetPolicy.hierarchical(
        BudgetLimits.run(5.00), estimator, meter);

// Use "premium" while ≥ $1.00 remains, then "fallback".
RoutingStrategy router = RoutingStrategy.budgetAware(
        budget, BudgetPolicy.Scope.RUN, 1.00,
        "premium", "fallback");

CoordinatorAgent desk = CoordinatorAgent.builder()
        .executor("premium",  premiumAgent)
        .executor("fallback", fallbackAgent)
        .routingStrategy(router)
        .build();

While the run budget has more than $1.00 remaining, the coordinator sends work to premium. The moment less remains, it degrades to fallback. Reading the live BudgetPolicy.remaining(...) counter is free, no extra LLM call to "classify complexity."

This is the one cost-aware routing lever that's both deterministic and provably cheaper: classifying complexity ex-ante with an LLM would itself cost a call (chicken-and-egg), and self-confidence routing doubles the cost. Reading counters is free.

A 30-second runnable demo

The cookbook ships a recipe that wires both features end-to-end:

git clone https://github.com/datallmhub/agentflow4j-cookbook.git
cd agentflow4j-cookbook
mvn -pl 06-cost-aware-routing exec:java

No API key required, Ollama optional, the recipe falls back to a deterministic stub. You should see the first three tickets handled by premium, then the squad switching cleanly to fallback once remaining drops below $2.00. The retry scene then shows a flaky node recovering on attempt 3 with 50ms → 98ms exponential+jitter backoffs, followed by a classification table.

Install

<dependency>
    <groupId>com.github.datallmhub.agentflow4j</groupId>
    <artifactId>agentflow4j-starter</artifactId>
    <version>v0.7.0</version>
</dependency>

Via JitPack: add https://jitpack.io to your <repositories> if you haven't.

Where next

Recipe 06 source: github.com/datallmhub/agentflow4j-cookbook/tree/main/06-cost-aware-routing
Resilience docs: datallmhub.github.io/agentflow4j/resilience
Release notes: github.com/datallmhub/agentflow4j/releases/tag/v0.7.0

Run your first AI agent in Java — for free, with Mistral

sekka — Tue, 26 May 2026 21:04:54 +0000

Every "build an AI agent" tutorial I find assumes two things: you write Python, and you have a paid OpenAI key. I write Java and I didn't want to pay just to experiment.

So here's the version nobody writes: a real LLM-backed agent, on the JVM, for free — using Mistral's free tier and AgentFlow4J, an open-source orchestration runtime on top of Spring AI. About ten minutes, start to finish.

Step 1 — Create a Mistral account

Go to console.mistral.ai and sign up (email, Google, or GitHub). You land on La Plateforme, the developer console.

Step 2 — Get a free API key

Open API Keys → Create new key, name it, copy it (you only see it once).

Export it in your shell — never commit it:

export MISTRAL_API_KEY="sk-...your-key..."

mistral-small is covered by the free tier, which is plenty for building and testing.

Step 3 — Add the dependencies

AgentFlow4J ships via JitPack. Add it plus Spring AI's Mistral starter:

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>

<dependency>
    <groupId>com.github.datallmhub.agentflow4j</groupId>
    <artifactId>agentflow4j-starter</artifactId>
    <version>v0.7.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-mistral-ai</artifactId>
</dependency>

Step 4 — Point Spring AI at Mistral

# application.yml
spring:
  ai:
    mistralai:
      api-key: ${MISTRAL_API_KEY}
      chat:
        options:
          model: mistral-small-latest
          temperature: 0.3

Step 5 — Write and run an agent

@Bean
CommandLineRunner demo(ChatClient.Builder chatClientBuilder) {
    Agent assistant = ExecutorAgent.builder()
            .name("assistant")
            .chatClient(chatClientBuilder.build())
            .systemPrompt("You are a concise, helpful assistant. Answer in one sentence.")
            .build();

    return args -> {
        AgentResult result = assistant.execute(
                AgentContext.of("What is backpressure in reactive streams?"));
        System.out.println("\nMistral says: " + result.text() + "\n");
    };
}

Run with MISTRAL_API_KEY set, and you get a real answer from Mistral — your first LLM agent in Java, for free.

Why a runtime, not just a ChatClient?

A single call is easy. Real systems chain agents, pass state, retry, and need guardrails. That's what AgentFlow4J adds on top of Spring AI: graph orchestration, typed state, checkpoint/resume, and governance gates (budget caps, tool/state policies, human approval) — all idiomatic Java, no Python, no sidecar.

The cookbook has five runnable recipes (RAG, ticket triage, web research, Slack bot, batch processing) if you want to go further.

It's open source (Apache 2.0). If you've been wanting to build agents without leaving the JVM, I'd genuinely love your feedback: github.com/datallmhub/agentflow4j