An agent is part of the application, not a way around it.

/// Grades the fruit that arrives.
1[Actor(Roles = [PackhouseRole.Grader])]
public class Inspector : Agent {
2  public static Person Principal => new Person { Email = "[email protected]", DisplayName = "Inspector" };
3  public override string Purpose => "You grade the fruit that arrives at the packhouse, one crate at a time.";
4  public override List<SkillBase> Skills => [new GradeCrate(), new DescribeDelivery(), new QuickLook(), new ReadTheLedger(), new MarkDelivery()];
  // It marks crates by itself: nothing it does leaves the packhouse.
5  public override Permits May => Permits.ChangesAlone();
}

/// Judges one crate.
1public class GradeCrate : Skill<Crate, Grade> {
  public override string Description => "Grade one crate of fruit.";
2  public override string Instructions => "Weigh the crate first. A crate under 10 kg is short: flag it \"short\" and say so in the grade.";
3  public override List<ActionInfo> Tools => [Actions.Of(Weigh), Actions.Of(FlagCrate), Actions.Of(CondemnCrate)];
4  public override string Brief(Crate c) => $"Crate {c.Code}. Its id is {c.Id}.";
5  public override string? Check(Grade g) => g.Score < 0 || g.Score > 10 ? "A score is from 0 to 10." : null;

/// One crate of fruit.
entity Crate {
  [Required, Unique, MaxLength(40)] string Code;
  CrateStage Stage = CrateStage.Arrived;
  /// Who brought it.
  [Required] Person Grower;
  decimal Kilos;
  /// What the inspector found: "", "short", "bruised".
  [MaxLength(40)] string Flag = "";
  /// Who changed the crate last.
  [ModifiedBy] Guid? ChangedBy;
  /// Not fit to pack. Only the lead says so.
  bool Condemned = false;
  [MaxLength(300)] string CondemnedWhy = "";
  /// Which line it goes to.
  [MaxLength(40)] string Line = "";
  security {
    // A grower sees and annotates the crates they brought; the lead and the graders see every crate.
1    allow read, update when IsGrower where Grower == user;
2    allow read, update when IsLead || IsGrader;
    allow read when IsAuditor;
    allow create when IsGrower || IsLead;
    // The lead and the graders may condemn a crate; a grower may not — and so nobody may for a grower.
3    deny update Condemned, CondemnedWhy when !IsLead && !IsGrader;
  }
}

/// Have the inspector grade a crate, for whoever asks.
public AgentOutcome<Grade> Inspect(Crate crate) {
1  return await Agents.Of<Inspector>().Do(new GradeCrate(), crate, about: "Crate " + crate.Code);
}

/// The same, by the sorter — who has somebody to consult.
public AgentOutcome<Grade> InspectCarefully(Crate crate) {
2  return await Agents.Of<Sorter>().Do(new GradeCrate(), crate, about: "Crate " + crate.Code);
}

/// The same, at a glance and on a small budget.
public AgentOutcome<Grade> Glance(Crate crate) {
  return await Agents.Of<Inspector>().Do(new QuickLook(), crate, about: "Crate " + crate.Code);
}

/// Two crates graded at once: both pieces of work are in flight, and each is awaited where its result is wanted.
public List<AgentOutcome<Grade>> InspectBoth(Crate first, Crate second) {
3  var a = Agents.Of<Inspector>().Do(new GradeCrate(), first, about: "Crate " + first.Code);
  var b = Agents.Of<Inspector>().Do(new GradeCrate(), second, about: "Crate " + second.Code);
  return [await a, await b];
}

/// Says nothing about what it may do alone.
[Actor(Roles = [PackhouseRole.Grader])]
1public class Clerk : Agent {
  public static Person Principal => new Person { Email = "[email protected]", DisplayName = "Clerk" };
  public override string Purpose => "You settle the crates that arrive at the packhouse.";
  public override List<SkillBase> Skills => [new SettleCrate()];
2  public override AsksPeople People => new AsksPeople { MayChoose = true, WhenStuck = true, Most = 2 };
}

/// Moves crates by itself — but a change of line is proposed every time, and it never condemns.
[Actor(Roles = [PackhouseRole.Grader])]
public class Porter : Agent {
  public static Person Principal => new Person { Email = "[email protected]", DisplayName = "Porter" };
  public override string Purpose => "You carry crates where they belong.";
  public override List<SkillBase> Skills => [new SettleCrate(), new SettleByTheBook(), new CountCrates()];
  public override Permits May => new Permits {
3    Changes = Leave.Alone, ProposeEveryTime = [Actions.Of(MoveToLine)], Never = [Actions.Of(CondemnCrate)],
  };
}

workflow ClaimFlow {
1  Tracks = Claim.Stage; Autostart = false; Initial = Open;
  /// The grower takes the claim back.
  event Withdraw();
  state Open {
    subscribe Withdraw();
    enter {
      this.Item.Run = Workflow.Current?.Id;
2      var outcome = await Agents.Of<Clerk>().Do(new SettleCrate(), this.Item.Crate, about: "Claim on " + this.Item.Crate.Code);
3      this.Item.Finding = outcome.Done ? outcome.Result.Finding : outcome.Status.Name + ": " + outcome.Problem;
      goto Settled;
    }
4    on Withdraw { goto Withdrawn; }
  }
  terminal success Settled { }
  terminal cancel  Withdrawn { Message = "the grower took the claim back"; }
}

void stopping_the_process_calls_off_the_work_it_was_waiting_for() {
  runas (Ada) {
    var crate = Crate.Single(c => c.Code == "A-2");
    var script = AgentScript.Of(
      Says.Tool("It is short.", Actions.Of(FlagCrate), FlagArgs(crate, "short")),
      Says.HandBack(new Grade { Score = 4, Finding = "Short." }));
    ScriptedAnswer.Stub((model, request) => { new Heard { What = "asked", About = model }; return script.Answer(model, request); });
    OpenClaim(crate);
    Workflow.Settle(Claim.Single());
  }
  runas (Dana) {
    Assert.Equal(AgentTaskStatus.Waiting, AgentTask.Single().Status);
1    Assert.Equal(ProposalStatus.Waiting, AgentProposal.Single().Status);
  }
  // The grower takes the claim back while the clerk's proposal waits for the lead.
  runas (Ada) {
2    WithdrawClaim(Claim.Single());
    Workflow.Settle(Claim.Single());
    Assert.Equal(ClaimStage.Withdrawn, Claim.Single().Stage);
  }
  Background.Settle();
  runas (Dana) {
    Workflow.Settle(AgentWorkWait.Single());
    Assert.Equal(AgentWorkWaitStatus.CalledOff, AgentWorkWait.Single().Status);
    // The app is told that nobody waits for the work any more — and the kit calls it off.
    Assert.Equal(1, Heard.Count(h => h.What == "no longer awaited"));
    GoOn(AgentTask.Single().Id);
    var receipt = AgentTask.Single();
    Assert.Equal(AgentTaskStatus.Cancelled, receipt.Status);
    Assert.Equal("It was called off: The process that was waiting for it was stopped.", receipt.Outcome);
    // Nothing more was asked of a model, the proposal can no longer be approved, and nothing it proposed was done.
3    Assert.Equal(1, Heard.Count(h => h.What == "asked"));
    Assert.Equal(ProposalStatus.Withdrawn, AgentProposal.Single().Status);
    Assert.Throws<AgentRefused>(() => ApproveAgentProposal(AgentProposal.Single()));
    Assert.Equal("", Crate.Single(c => c.Code == "A-2").Flag);
    Assert.True(VerifyTrace(receipt).Intact);
  }

void the_record_says_every_step_in_order_in_plain_words() {
  var task = GradedByAda();

  Assert.Equal(["Started", "ModelCall", "ToolCall", "ToolResult", "ModelCall", "ToolCall", "ToolResult", "ModelCall", "Ended"],
1               Trajectory.Kinds(task));
  Assert.Equal([
    "Inspector was given grade crate: Crate A-2.",
2    "Small (chosen by llm:default) asked for a tool; it cost $0.0006.",
    "It asked for Weigh (reads only); it is one of this work's tools, so it runs as the agent, for whoever asked.",
    "Weigh answered.",
    "Small (chosen by llm:default) asked for a tool; it cost $0.0007.",
3    "It asked for FlagCrate (changes data); it is one of this work's tools, so it runs as the agent, for whoever asked.",
    "FlagCrate answered.",
    "Small (chosen by llm:default) asked for a tool; it cost $0.0009.",
    "Done. It handed back its result.",
  ], Trajectory.Said(task));
}