⭐ Flagship pattern — Custom Strategy with Domain Modeling

Start → [Identify Problem] → [Fix Problem] → [Verify Solution] → [Adjust] → … → Finish
                                                    │
                                       CriticResult<T>
                                       ├─ successful == true  → Finish, emit input  (AccountIssueSolution)
                                       └─ successful == false → Adjust, pass feedback (String) → re-verify

// Illustrative — your own type. Generic here only to show reusability.
public record CriticResult<T>(
        boolean successful,   // pass/fail verdict the router branches on
        String feedback,      // nullable — why it failed / how to adjust
        T input               // the typed artifact under review, e.g. the itinerary
) {
    public static <T> CriticResult<T> pending() {
        return new CriticResult<>(false, null, null);
    }
}

// Equally fine — a concrete, non-generic shape for one domain:
// public record ItineraryReview(boolean approved, String notes, TravelItinerary itinerary) {}

public record AccountIssueSolution(String accountId, String diagnosis, String resolution) {}

public interface SolutionCritic {
    @SystemMessage("You verify proposed account-issue solutions. Be strict.")
    @UserMessage("""
        Verify this proposed solution for the reported problem.
        Problem: {{problem}}
        Proposed solution: {{solution}}
        Set successful=true only if it fully resolves the problem.
        If not, set successful=false and give concrete feedback on what to adjust.
        """)
    @Agent(value = "Verifies a proposed solution and returns a typed verdict", outputKey = "criticResult")
    CriticResult<AccountIssueSolution> verify(@V("problem") String problem,
                                              @V("solution") AccountIssueSolution solution);
}

public interface Adjuster {
    @UserMessage("""
        The previous solution was rejected. Revise it using the feedback.
        Problem: {{problem}}
        Previous solution: {{solution}}
        Reviewer feedback: {{feedback}}
        """)
    @Agent(value = "Adjusts a solution based on critic feedback", outputKey = "solution")
    AccountIssueSolution adjust(@V("problem") String problem,
                                @V("solution") AccountIssueSolution solution,
                                @V("feedback") String feedback);
}
// plus IdentifyProblem (outputKey="problem") and FixProblem (outputKey="solution") agents

UntypedAgent verifyAdjustLoop = AgenticServices.loopBuilder()
        .subAgents(adjuster, critic)                 // adjust, then re-verify
        .maxIterations(5)
        .exitCondition(scope ->
                scope.readState("criticResult", CriticResult.<AccountIssueSolution>pending()).successful())
        .build();

UntypedAgent resolver = AgenticServices.sequenceBuilder()
        .subAgents(identifyProblem, fixProblem, critic, verifyAdjustLoop)
        .outputKey("criticResult")
        // emit the TYPED solution on success — not a summary string
        .output(scope ->
                scope.readState("criticResult", CriticResult.<AccountIssueSolution>pending()).input())
        .build();

AccountIssueSolution solution = (AccountIssueSolution) resolver.invoke(Map.of(
        "problem", "",
        "request", "Customer 8842 cannot log in after a password reset"));

public interface Planner {
    default void init(InitPlanningContext initPlanningContext) { }
    default Action firstAction(PlanningContext planningContext) { return nextAction(planningContext); }
    Action nextAction(PlanningContext planningContext);   // returns call(...) or done()
}

public class CriticDrivenStrategy implements Planner {
    private AgentInstance identify, fix, verify, adjust;
    private int iterations = 0;
    private final int maxIterations;

    public CriticDrivenStrategy(int maxIterations) { this.maxIterations = maxIterations; }

    @Override public void init(InitPlanningContext ctx) {
        List<AgentInstance> a = ctx.subagents();          // wire by name in real code
        this.identify = a.get(0); this.fix = a.get(1);
        this.verify   = a.get(2); this.adjust = a.get(3);
    }

    @Override public Action firstAction(PlanningContext ctx) {
        return call(identify);                            // Start → Identify Problem
    }

    @Override public Action nextAction(PlanningContext ctx) {
        AgenticScope scope = ctx.agenticScope();
        String last = ctx.previousAgentInvocation().agentName();

        if (last.equals(identify.name())) return call(fix);      // Identify → Fix
        if (last.equals(fix.name()))      return call(verify);   // Fix → Verify

        // After Verify (or after Adjust → re-verify), branch on the TYPED result
        CriticResult<AccountIssueSolution> result =
                scope.readState("criticResult", CriticResult.pending());

        if (result.successful()) return done();                  // successful==true → Finish
        if (++iterations > maxIterations) return done();         // safety bound

        if (last.equals(verify.name())) {                        // successful==false → Adjust
            scope.writeState("feedback", result.feedback());     // pass feedback (String)
            return call(adjust);
        }
        return call(verify);                                     // Adjust → re-verify
    }
}

UntypedAgent resolver = AgenticServices.plannerBuilder()
        .subAgents(identifyProblem, fixProblem, critic, adjuster)
        .planner(() -> new CriticDrivenStrategy(5))
        .outputKey("criticResult")
        .output(scope ->
                scope.readState("criticResult", CriticResult.<AccountIssueSolution>pending()).input())
        .build();