Coordination without a coordinator.

// agentspaces-springai/examples/springai-fleet -- SpringAiFleet.Summarizer
// A Spring AI worker on the fleet: a @SpaceAgent bean with an injected
// ChatClient.Builder and one @SpaceTake method.
@SpaceAgent(name = "summarizer", description = "Summarizes a topic into a short briefing",
        goals = {"summarize topics"})
public static class Summarizer {
    private final ChatClient chat;

    Summarizer(ChatClient.Builder builder) {
        this.chat = builder.build();
    }

    @SpaceTake(space = "work", lease = "2m")
    public Summary summarize(Brief brief) {
        return new Summary(brief.topic(),
                chat.prompt().user("Summarize: " + brief.topic()).call().content());
    }
}

// agentspaces-springai/examples/springai-fleet -- SpringAiFleet.Orchestrator
// The fleet's AgentCards become Spring AI tool callbacks: the model's tool loop
// can call the summarizer and translator, wherever they run.
public static class Orchestrator {
    private final ChatClient chat;

    Orchestrator(ChatClient.Builder builder, FleetTools fleet) {
        this.chat = builder.defaultToolCallbacks(fleet.toolCallbacks()).build();
    }

    public String ask(String question) {
        return chat.prompt().user(question).call().content();
    }
}

@SpringBootConfiguration
@EnableAutoConfiguration
@Import(DemoModel.class)
public static class OrchestratorApp {
    @Bean
    Orchestrator orchestrator(ChatClient.Builder builder, FleetTools fleet) {
        return new Orchestrator(builder, fleet);
    }
}

// agentspaces-springai/examples/springai-patterns -- JudgePanel
// Each judge is an ordinary @Ballot agent whose vote is a Spring AI Evaluator.
@AgentSpec(name = "judge", description = "Fact-checks claims against evidence",
        goals = {"judge claims"})
public static final class Judge {
    private final Evaluator evaluator;

    public Judge(Evaluator evaluator) {
        this.evaluator = Objects.requireNonNull(evaluator, "evaluator");
    }

    @Ballot(space = "votes", prefix = "claim:", lease = "10m")
    public String judge(VoteCapability.Proposal proposal) {
        String[] parts = proposal.question().split(EVIDENCE, 2);
        boolean holds = evaluator.evaluate(new EvaluationRequest(
                List.of(new Document(parts.length > 1 ? parts[1] : "")), parts[0])).isPass();
        return holds ? "approve" : "reject";
    }
}

@AgentSpec(name = "lead", description = "Records the panel's verdicts",
        goals = {"record verdicts"})
public static final class Lead {
    @OnDecision(space = "votes", prefix = "claim:", resultLease = "1h")
    public Verdict record(VoteCapability.Decision decision) {
        return new Verdict(decision.proposalId(), decision.winner(), decision.tally().toString());
    }
}

// agentspaces-springai/examples/springai-patterns -- TokenPricedAuction.ModelWorker
// The cheapest model that can handle the task wins it.
@AgentSpec(name = "model-worker", description = "Runs tasks on one model, priced by tokens",
        goals = {"answer prompts"})
public static final class ModelWorker {
    private final String name;
    private final ChatClient chat;
    private final double pricePerThousandTokens;
    private final int maxDifficulty;

    @BidFunction(space = "model-tasks")
    public double bid(ModelTask task) {
        if (task.difficulty() > maxDifficulty) {
            return Double.POSITIVE_INFINITY;
        }
        return pricePerThousandTokens * estimatedTokens(task.prompt()) / 1000.0;
    }

    @SpaceTake(space = "model-tasks", pollTimeout = "PT0.3S")
    public ModelResult run(ModelTask task) {
        return new ModelResult(task.prompt(), chat.prompt().user(task.prompt()).call().content(),
                name, bid(task));
    }
}

// agentspaces-partybus/src/embabel -- PartyBusEmbabelApplication
// The planner's own two actions. Everything between them is a remote fleet
// specialist that the bridge generated from an AgentCard.
@Agent(description = "Plans a trip with the Party Bus fleet's specialists")
public static class PartyBusPlannerAgent {

    @Action
    public SightseeingRequest askForSights(TravelBrief brief) {
        return new SightseeingRequest(brief.tripId(), "planner sights " + brief.to(),
                brief.to(), brief.brief(), brief.departureDate(), brief.returnDate(),
                PartyBus.party(brief.tripId()).contribution());
    }

    @Action
    public ReviewRequest askForReviewsOfTheTopSight(SightseeingOptions sights) {
        PointOfInterest top = sights.pointsOfInterest().isEmpty()
                ? new PointOfInterest("the old town", "", "", "", "")
                : sights.pointsOfInterest().get(0);
        return new ReviewRequest(sights.tripId(), "planner reviews " + top.name(),
                top.name(), top.location());
    }

    @AchievesGoal(description = "Know what travelers say about the trip's top sight")
    @Action
    public ReviewDigest done(ReviewDigest digest) {
        return digest;
    }
}

// agentspaces-partybus/src/embabel -- PartyBusEmbabelApplication.boardTheBus
// The fleet's AgentCards come back in as planner actions for Embabel's GOAP planner.
@Bean
CommandLineRunner boardTheBus(AgentPlatform platform) {
    return args -> {
        Sources sources = Sources.fromEnvironment();
        PartyBus.Seating bus = PartyBus.board(sources, 7700, 7590);
        RemoteActions remote = PartyBusPlanner.remoteActions(bus.plannerPeer());
        PartyBusPlanner.awaitActions(remote, 12, Duration.ofSeconds(30));
        EmbabelRemoteActions bridge = PartyBusPlanner.bridge(remote);
        if (!bridge.deployTo(platform)) {
            throw new IllegalStateException("the fleet agent did not deploy; are the cards in?");
        }
    };
}

// agentspaces-partybus -- PartyBusPlanner.bridge(...)
return new EmbabelRemoteActions(remote, INVOKE_TIMEOUT, "partyBusFleet",
        "The Party Bus fleet's advertised skills: scouts, advisors, watchers");

// agentspaces-partybus -- Scouts.SightseeingScout
// The remote action the planner's SightseeingRequest reaches: an ordinary
// @SpaceTake worker, possibly on another machine.
@AgentSpec(name = "sightseeing-scout",
        description = "Proposes points of interest suited to the travelers and the brief",
        goals = {"propose points of interest"})
public static final class SightseeingScout {
    private final Sources sources;

    @SpaceTake(space = SPACE, lease = "3m", pollTimeout = "500ms")
    public SightseeingOptions scout(SightseeingRequest request) {
        List<Link> web = sources.search("things to do " + request.destination() + " "
                + request.brief(), 10);
        SightseeingOptions found = sources.structured("sights", RESEARCHER
                + "\nPropose six to eight points of interest in and around "
                + request.destination() /* ...the rest of the prompt... */,
                SightseeingOptions.class);
        return new SightseeingOptions(request.tripId(), request.topic(),
                found.pointsOfInterest(), "sightseeing-scout");
    }
}

// embabel-agentspaces -- EmbabelBinderTest.SpaceBoundEmbabelWorker
// The outbound direction: an Embabel action that is also a space worker.
// Its AgentCard is built from the @Agent metadata and the action's types.
@Agent(name = "spaceWorker", description = "Takes tasks from the work space")
public static class SpaceBoundEmbabelWorker {

    @Action
    @ai.badmonkey.agentspaces.agent.annotation.SpaceTake(space = "work")
    public FindingEntry research(TaskEntry task) {
        return new FindingEntry(task.topic(), "done");
    }
}