The durable runtime for AI agents

import { DatabaseSync } from 'node:sqlite'
const Texts = z.array(z.string())

export const Notes = defineAgent({
  name: 'NotesAgent',
  id: { user: z.string() },
  methods: {
    add: method({ input: { text: z.string() }, returns: z.void() }),
    find: method({ input: { term: z.string() }, returns: Texts }),
  },
}).implement({
  init: () => {
    fs.mkdirSync('/data', { recursive: true })
    // SQLite uses this agent's durable file system, not a server:
    const db = new DatabaseSync('/data/notes.db')
    db.exec('CREATE TABLE IF NOT EXISTS notes (text TEXT NOT NULL)')
    return { db }
  },
  methods: {
    add({ text }) {
      this.db.prepare('INSERT INTO notes VALUES (?)').run(text)
    },
    find({ term }) {
      const rows = this.db
        .prepare('SELECT text FROM notes WHERE text LIKE ?')
        .all(`%${term}%`)
      return Texts.parse(rows.map((row) => row.text))
    },
  },
})

import { generateText, Output } from 'ai'
import { anthropic } from '@ai-sdk/anthropic'
import { openai } from '@ai-sdk/openai'
const Review = z.object({ ok: z.boolean(), notes: z.string() })
const Draft = z.object({ text: z.string(), review: Review })

export const Drafter = defineAgent({
  name: 'DraftAgent',
  id: { topic: z.string() },
  methods: {
    write: method({ input: { idea: z.string() }, returns: Draft }),
  },
}).implement({
  init: ({ id }) => ({ topic: id.topic }),
  methods: {
    async write({ idea }) {
      // draft with one provider, review with another:
      const draft = await generateText({
        model: openai('gpt-4.1'),
        prompt: `Product update on ${this.topic}: ${idea}`,
      })
      const { output } = await generateText({
        model: anthropic('claude-sonnet-4-5'),
        output: Output.object({ schema: Review }),
        prompt: `Review this product update:\n${draft.text}`,
      })
      return { text: draft.text, review: output }
    },
  },
})

export const Planner = defineAgent({
  name: 'PlannerAgent',
  id: { topic: z.string() },
  methods: { plan: method({ input: {}, returns: Plan }) },
}).implement({
  init: ({ id }) => ({ topic: id.topic }),
  methods: {
    async plan() {
      // wait for a typed result from a Rust ResearchAgent:
      const facts = await ResearchAgent.get(this.topic).gather()
      // send now, without waiting for a result:
      SlackAgent.get('ops').post.trigger(facts.summary)
      // discover agents, their methods, and available tools:
      const agents = reflection.getAllAgentTypes().map((a) =>
        `${a.name}: ${a.methods.map((m) => m.name).join(', ')}`)
      const tools = reflection.getAllToolTypes().map((t) => t.name)
      return { facts, agents, tools }
    },
  },
})

import { setTimeout as sleep } from 'node:timers/promises'

export const Checkout = defineAgent({
  name: 'CheckoutAgent',
  id: { orderId: z.string() },
  // webhooks require this agent to have an HTTP mount:
  http: http.mount('/checkout/{orderId}'),
  methods: {
    pay: method({ input: { amount: z.int() }, returns: z.void() }),
  },
}).implement({
  init: ({ id }) => ({ orderId: id.orderId }),
  methods: {
    async pay({ amount }) {
      const paid = createWebhook()
      await createPaymentLink(this.orderId, amount, paid.getUrl())
      // schedule a call on another agent for tomorrow:
      const reminder = Mailer.client.get({ orderId: this.orderId })
        .remind.schedule(inDays(1))
      // it waits here for days if needed, using no CPU or memory:
      const event = PaymentEvent.parse((await paid).json())
      reminder.cancel()
      if (event.status !== 'succeeded') return
      // sleep for a week; its deadline survives restarts:
      await sleep(7 * 24 * 60 * 60_000)
      await sendSurvey(this.orderId)
    },
  },
})

export const Writer = defineAgent({
  name: 'WriterAgent',
  id: { doc: z.string() },
  http: http.mount('/docs/{doc}'),
  methods: {
    draft: method({
      input: { brief: z.string() },
      // clients resume this Durable Stream from an offset:
      returns: s.stream(z.string()),
      http: http.post('/draft'),
    }),
  },
}).implement({
  init: () => ({}),
  methods: {
    draft({ brief }) {
      return AgentStream.from((async function* () {
        for (const section of ['Summary', 'Details', 'Actions']) {
          // completed model calls are not repeated on recovery:
          const reply = await openai.responses.create({
            model: 'gpt-4.1',
            input: `${brief}\nWrite the ${section} section.`,
          })
          yield reply.output_text
        }
      })())
    },
  },
})

export const Stock = defineAgent({
  name: 'StockAgent',
  id: { sku: z.string() },
  methods: {
    restock: method({ input: { n: z.int() }, returns: z.void() }),
    level: method({
      input: {}, returns: z.int(),
      // repeat calls come from a cache, without loading the agent:
      // the cache clears when a restock succeeds:
      // outgoing HTTP, agent calls and key-value writes fail:
      readOnly: true,
    }),
  },
}).implement({
  init: () => ({ units: 0 }),
  methods: {
    restock({ n }) { this.units += n },
    level() { return this.units },
  },
})

import { SqliteClient } from "@golemcloud/effect-golem/sqlite"
const Texts = Schema.Array(Schema.String)

export const Notes = defineAgent({
  name: "NotesAgent",
  id: { user: Schema.String },
  methods: {
    add: method({
      input: { text: Schema.String }, success: Schema.Void,
    }),
    find: method({
      input: { term: Schema.String }, success: Texts,
    }),
  },
}).implement({
  init: () => Effect.gen(function* () {
    fs.mkdirSync("/data", { recursive: true })
    // SQLite uses this agent's durable file system, not a server:
    return yield* SqliteClient.make({ filename: "/data/notes.db" })
  }).pipe(Effect.tap((db) =>
    db`CREATE TABLE IF NOT EXISTS notes (text TEXT NOT NULL)`)),
  methods: (db) => ({
    add: ({ text }) => db`INSERT INTO notes VALUES (${text})`.pipe(
      Effect.asVoid, Effect.orDie),
    find: ({ term }) => db`SELECT text FROM notes
      WHERE text LIKE ${`%${term}%`}`.pipe(
      Effect.map((rows) => rows.map((row) => row.text)),
      Effect.flatMap(Schema.decodeUnknownEffect(Texts)),
      Effect.orDie),
  }),
})

import { LanguageModel } from "effect/ai"
import { AnthropicLanguageModel } from "@effect/ai-anthropic"
import { OpenAiLanguageModel } from "@effect/ai-openai"
const Review = Schema.Struct({
  ok: Schema.Boolean, notes: Schema.String,
})
const Draft = Schema.Struct({ text: Schema.String, review: Review })

export const Drafter = defineAgent({
  name: "DraftAgent",
  id: { topic: Schema.String },
  methods: { write: method({
    input: { idea: Schema.String }, success: Draft,
  }) },
}).implement({
  init: ({ topic }) => Effect.succeed({ topic }),
  methods: ({ topic }) => ({
    write: ({ idea }) => Effect.gen(function* () {
      // draft with one provider, review with another:
      const draft = yield* LanguageModel.generateText({
        prompt: `Product update on ${topic}: ${idea}`,
      }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4.1")))
      const { value } = yield* LanguageModel.generateObject({
        schema: Review,
        prompt: `Review this product update:\n${draft.text}`,
      }).pipe(Effect.provide(
        AnthropicLanguageModel.model("claude-sonnet-4-5")))
      return { text: draft.text, review: value }
    }).pipe(Effect.provide(providers), Effect.orDie),
  }),
})

export const Planner = defineAgent({
  name: "PlannerAgent",
  id: { topic: Schema.String },
  methods: { plan: method({ input: {}, success: Plan }) },
}).implement({
  init: ({ topic }) => Effect.succeed({ topic }),
  methods: ({ topic }) => ({
    plan: () => Effect.gen(function* () {
      // wait for a typed result from a Rust ResearchAgent:
      const research = yield* ResearchAgent.get(topic)
      const facts = yield* research.gather()
      // send now, without waiting for a result:
      const slack = yield* SlackAgent.get("ops")
      yield* slack.post.trigger(facts.summary)
      // discover agents, their methods, and available tools:
      const agents = (yield* Reflection.getAllAgentTypes).map((a) =>
        `${a.name}: ${a.methods.map((m) => m.name).join(", ")}`)
      const tools = (yield* Reflection.getAllToolTypes())
        .map((t) => t.name)
      return { facts, agents, tools }
    }).pipe(Effect.scoped, Effect.orDie),
  }),
})

export const Checkout = defineAgent({
  name: "CheckoutAgent",
  id: { orderId: Schema.String },
  // webhooks require this agent to have an HTTP mount:
  http: Http.mount("/checkout/{orderId}"),
  methods: {
    pay: method({
      input: { amount: Schema.Int }, success: Schema.Void,
    }),
  },
}).implement({
  init: ({ orderId }) => Effect.succeed({ orderId }),
  methods: ({ orderId }) => ({
    pay: ({ amount }) => Effect.gen(function* () {
      const paid = yield* Webhook.create
      yield* createPaymentLink(orderId, amount, paid.url)
      // schedule a call on another agent for tomorrow:
      const mailer = yield* Mailer.client.get({ orderId })
      const reminder = yield* mailer.remind.schedule(inDays(1), {})
      // it waits here for days if needed, using no CPU or memory:
      const payload = yield* paid.await
      const event = yield* payload.decode(PaymentEvent)
      yield* reminder.cancel()
      if (event.status !== "succeeded") return
      // sleep for a week; its deadline survives restarts:
      yield* Effect.sleep("7 days")
      yield* sendSurvey(orderId)
    }).pipe(Effect.scoped, Effect.orDie),
  }),
})

export const Writer = defineAgent({
  name: "WriterAgent",
  id: { doc: Schema.String },
  http: Http.mount("/docs/{doc}"),
  methods: {
    draft: method({
      input: { brief: Schema.String },
      // clients resume this Durable Stream from an offset:
      success: WitTypes.AgentStream(Schema.String),
      http: [Http.post("/draft")],
    }),
  },
}).implement({
  init: () => Effect.void,
  methods: () => ({
    draft: ({ brief }) => Effect.succeed(
      Stream.fromIterable(["Summary", "Details", "Actions"]).pipe(
        Stream.mapEffect((section) =>
          // completed model calls are not repeated on recovery:
          LanguageModel.generateText({
            prompt: `${brief}\nWrite the ${section} section.`,
          }),
        ),
        Stream.map((reply) => reply.text),
        Stream.provide(OpenAiLanguageModel.model("gpt-4.1")),
        Stream.provide(openai), Stream.orDie,
      ),
    ),
  }),
})

export const Stock = defineAgent({
  name: "StockAgent",
  id: { sku: Schema.String },
  methods: {
    restock: method({
      input: { n: Schema.Int }, success: Schema.Void,
    }),
    level: method({
      input: {}, success: Schema.Int,
      // repeat calls come from a cache, without loading the agent:
      // the cache clears when a restock succeeds:
      // outgoing HTTP, agent calls and key-value writes fail:
      readOnly: true,
    }),
  },
}).implement({
  init: () => Ref.make(0),
  methods: (units) => ({
    restock: ({ n }) => Ref.update(units, (u) => u + n),
    level: () => Ref.get(units),
  }),
})

use rusqlite::Connection;
#[agent_definition]
pub trait NotesAgent {
  fn new(user: String) -> Self;
  fn add(&mut self, text: String) -> Result<(), AppError>;
  fn find(&self, term: String) -> Result<Vec<String>, AppError>;
}
fn open() -> Result<Connection, AppError> {
  fs::create_dir_all("/data")?;
  // SQLite uses this agent's durable file system, not a server:
  let db = Connection::open("/data/notes.db")?;
  db.execute_batch(
    "CREATE TABLE IF NOT EXISTS notes (text TEXT NOT NULL)")?;
  Ok(db)
}
struct NotesAgentImpl;
#[agent_implementation]
impl NotesAgent for NotesAgentImpl {
  fn new(_user: String) -> Self { Self }
  fn add(&mut self, text: String) -> Result<(), AppError> {
    open()?.execute("INSERT INTO notes VALUES (?)", [text])?;
    Ok(())
  }
  fn find(&self, term: String) -> Result<Vec<String>, AppError> {
    let db = open()?;
    let mut stmt =
      db.prepare("SELECT text FROM notes WHERE text LIKE ?")?;
    let rows = stmt.query_map([format!("%{term}%")], |r| r.get(0))?;
    Ok(rows.collect::<Result<_, _>>()?)
  }
}

use golem_ai_llm::LlmProvider;
use golem_ai_llm_anthropic::{Anthropic, AnthropicConfig};
use golem_ai_llm_openai::{OpenAI, OpenAiConfig};
#[derive(Schema)] pub struct Review { ok: bool, notes: String }
#[derive(Schema)] pub struct Draft { text: String, review: Review }

#[agent_definition]
pub trait DraftAgent {
  fn new(topic: String) -> Self;
  async fn write(&self, idea: String) -> Result<Draft, AppError>;
}
struct DraftAgentImpl { topic: String }
#[agent_implementation]
impl DraftAgent for DraftAgentImpl {
  fn new(topic: String) -> Self { Self { topic } }
  async fn write(&self, idea: String) -> Result<Draft, AppError> {
    // draft with one provider, review with another:
    let draft = text(OpenAI::send(
      OpenAiConfig::from_env()?,
      vec![user(&format!("Product update on {}: {idea}",
        self.topic))],
      model("gpt-4.1"),
    ).await)?;
    let review = json(Anthropic::send(
      AnthropicConfig::from_env()?,
      vec![user(&format!("Review this product update:\n{draft}"))],
      json_model::<Review>("claude-sonnet-4-5"),
    ).await)?;
    Ok(Draft { text: draft, review })
  }
}

#[agent_definition]
pub trait PlannerAgent {
  fn new(topic: String) -> Self;
  async fn plan(&self) -> Result<Plan, AppError>;
}
struct PlannerAgentImpl { topic: String }
#[agent_implementation]
impl PlannerAgent for PlannerAgentImpl {
  fn new(topic: String) -> Self { Self { topic } }
  async fn plan(&self) -> Result<Plan, AppError> {
    // wait for a typed result from a TypeScript ResearchAgent:
    let facts = ResearchAgent::get(self.topic.clone())?
      .gather().await?;
    // send now, without waiting for a result:
    SlackAgent::get("ops".into())?
      .trigger_post(facts.summary.clone())?;
    // discover agents, their methods, and available tools:
    let agents = reflection::get_all_agent_types()?.iter()
      .map(|a| format!("{}: {}", a.name(), a.methods().iter()
        .map(|m| m.name()).collect::<Vec<_>>().join(", ")))
      .collect();
    let tools = reflection::get_all_tool_types()?.iter()
      .map(|t| t.lookup_name().to_string()).collect();
    Ok(Plan { facts, agents, tools })
  }
}

use golem_rust::wasip3::clocks::monotonic_clock::wait_for as sleep;

// webhooks require this agent to have an HTTP mount:
#[agent_definition(mount = "/checkout/{order_id}")]
pub trait CheckoutAgent {
  fn new(order_id: String) -> Self;
  async fn pay(&mut self, amount: u64) -> Result<(), AppError>;
}
struct CheckoutAgentImpl { order_id: String }
#[agent_implementation]
impl CheckoutAgent for CheckoutAgentImpl {
  fn new(order_id: String) -> Self { Self { order_id } }
  async fn pay(&mut self, amount: u64) -> Result<(), AppError> {
    let paid = create_webhook()?;
    create_payment_link(&self.order_id, amount, paid.url()).await?;
    // schedule a call on another agent for tomorrow:
    let reminder = MailerAgentClient::get(self.order_id.clone())
      .schedule_cancelable_remind(in_days(1))?;
    // it waits here for days if needed, using no CPU or memory:
    let event: PaymentEvent = paid.await.json()?;
    reminder.cancel();
    if event.status != "succeeded" { return Ok(()); }
    // sleep for a week; its deadline survives restarts:
    sleep(7 * 24 * 60 * 60 * 1_000_000_000).await;
    send_survey(&self.order_id).await?;
    Ok(())
  }
}

#[agent_definition(mount = "/docs/{doc}")]
pub trait WriterAgent {
  fn new(doc: String) -> Self;
  #[endpoint(post = "/draft")]
  // clients resume this Durable Stream from an offset:
  fn draft(&self, brief: String) -> AgentStream<String>;
}
struct WriterAgentImpl;
#[agent_implementation]
impl WriterAgent for WriterAgentImpl {
  fn new(_doc: String) -> Self { Self }
  fn draft(&self, brief: String) -> AgentStream<String> {
    let (mut out, stream) = AgentStream::new();
    spawn_local(async move {
      for section in ["Summary", "Details", "Actions"] {
        // completed model calls are not repeated on recovery:
        let reply = text(OpenAI::send(
          OpenAiConfig::from_env().expect("no OpenAI config"),
          vec![user(&format!(
            "{brief}\nWrite the {section} section."))],
          model("gpt-4.1"),
        ).await).expect("model call failed");
        if out.write_one(reply).await.is_err() { return; }
      }
    });
    stream
  }
}

#[agent_definition]
pub trait StockAgent {
  fn new(sku: String) -> Self;
  fn restock(&mut self, n: u64);
  // repeat calls come from a cache, without loading the agent:
  // the cache clears when a restock succeeds:
  // outgoing HTTP, agent calls and key-value writes fail:
  #[read_only]
  fn level(&self) -> u64;
}
struct StockAgentImpl { units: u64 }
#[agent_implementation]
impl StockAgent for StockAgentImpl {
  fn new(_sku: String) -> Self { Self { units: 0 } }
  fn restock(&mut self, n: u64) { self.units += n; }
  fn level(&self) -> u64 { self.units }
}

Scala, MoonBit and Go agents each have their own durable file system too, but no supported SQLite library.

import ai.{generateText, Output}
import aisdk.anthropic.anthropic
import aisdk.openai.openai
final case class Review(ok: Boolean, notes: String) derives Schema
final case class Draft(text: String, review: Review) derives Schema

@agentDefinition()
trait DraftAgent extends BaseAgent:
  class Id(val topic: String)
  def write(idea: String): Future[Draft]

@agentImplementation()
final class DraftAgentImpl(topic: String) extends DraftAgent:
  def write(idea: String): Future[Draft] =
    for
      // draft with one provider, review with another:
      draft <- generateText(
        model = openai("gpt-4.1"),
        prompt = s"Product update on $topic: $idea",
      )
      reviewed <- generateText(
        model = anthropic("claude-sonnet-4-5"),
        output = Output.`object`[Review],
        prompt = s"Review this product update:\n${draft.text}",
      )
    yield Draft(draft.text, reviewed.output)

@agentDefinition()
trait PlannerAgent extends BaseAgent:
  class Id(val topic: String)
  def plan(): Future[Plan]

@agentImplementation()
final class PlannerAgentImpl(topic: String) extends PlannerAgent:
  def plan(): Future[Plan] =
    // wait for a typed result from a Rust ResearchAgent:
    ResearchAgentClient.get(topic).gather().map: facts =>
      // send now, without waiting for a result:
      SlackAgentClient.get("ops").post.trigger(facts.summary)
      // discover agents, their methods, and available tools:
      val agents = Reflection.getAllAgentTypes().orThrow.map: a =>
        s"${a.name}: ${a.methods.map(_.name).mkString(", ")}"
      val tools = Reflection.getAllToolTypes().orThrow.map(_.name)
      Plan(facts, agents, tools)

// webhooks require this agent to have an HTTP mount:
@agentDefinition(mount = "/checkout/{orderId}")
trait CheckoutAgent extends BaseAgent:
  class Id(val orderId: String)
  def pay(amount: Int): Future[Unit]

@agentImplementation()
final class CheckoutAgentImpl(orderId: String)
    extends CheckoutAgent:
  def pay(amount: Int): Future[Unit] =
    val paid = HostApi.createWebhook()
    for
      _ <- createPaymentLink(orderId, amount, paid.url)
      // schedule a call on another agent for tomorrow:
      reminder <- MailerAgentClient.get(orderId)
        .remind.scheduleCancelableAt(inDays(1))
      // it waits here for days if needed, using no CPU or memory:
      event <- paid.await().map(_.json[PaymentEvent]())
      _ = reminder.cancel()
      _ <- if event.status != "succeeded" then Future.unit
           else
             // sleep for a week; its deadline survives restarts:
             sleep(7 * 24 * 60 * 60_000)
               .flatMap(_ => sendSurvey(orderId))
    yield ()

@agentDefinition(mount = "/docs/{doc}")
trait WriterAgent extends BaseAgent:
  class Id(val doc: String)
  @endpoint("POST", "/draft")
  // clients resume this Durable Stream from an offset:
  def draft(brief: String): AgentStream[String]

@agentImplementation()
final class WriterAgentImpl(doc: String) extends WriterAgent:
  def draft(brief: String): AgentStream[String] =
    val sections = Iterator("Summary", "Details", "Actions")
    AgentStream.fromPull: () =>
      if !sections.hasNext then Future.successful(None)
      else
        val section = sections.next()
        // completed model calls are not repeated on recovery:
        openai.responses.create(ResponseParams(
          model = "gpt-4.1",
          input = s"$brief\nWrite the $section section.",
        )).toFuture.map(reply => Some(reply.output_text))

@agentDefinition()
trait StockAgent extends BaseAgent:
  class Id(val sku: String)
  def restock(n: Int): Unit
  // repeat calls come from a cache, without loading the agent:
  // the cache clears when a restock succeeds:
  // outgoing HTTP, agent calls and key-value writes fail:
  @readOnly
  def level(): Int

@agentImplementation()
final class StockAgentImpl(sku: String) extends StockAgent:
  private var units = 0

  def restock(n: Int): Unit = units += n
  def level(): Int = units

Scala, MoonBit and Go agents each have their own durable file system too, but no supported SQLite library.

#derive.golem_schema
struct Review { ok : Bool; notes : String } derive(FromJson)
#derive.golem_schema
struct Draft { text : String; review : Review }

#derive.agent
struct DraftAgent {
  topic : String
}

fn DraftAgent::new(topic : String) -> DraftAgent {
  { topic, }
}

pub async fn DraftAgent::write(
  self : Self, idea : String,
) -> Draft {
  // draft with one provider, review with another:
  let draft = @llm.generate_text(
    model=@llm.openai("gpt-4.1"),
    prompt="Product update on \{self.topic}: \{idea}",
  )
  let review : Review = @llm.generate_object(
    model=@llm.anthropic("claude-sonnet-4-5"),
    prompt="Review this product update:\n\{draft}",
  )
  { text: draft, review }
}

#derive.agent
struct PlannerAgent {
  topic : String
}

fn PlannerAgent::new(topic : String) -> PlannerAgent {
  { topic, }
}

pub async fn PlannerAgent::plan(self : Self) -> Plan {
  // wait for a typed result from a Rust ResearchAgent:
  let facts = @research.ResearchAgentClient::get(self.topic)
    .gather()
  // send now, without waiting for a result:
  @slack.SlackAgentClient::get("ops").trigger_post(facts.summary)
  // discover agents, their methods, and available tools:
  let agents = @reflection.get_all_agent_types().map(a =>
    "\{a.name()}: \{a.methods().map(m => m.name()).join(", ")}")
  let tools = @reflection.get_all_tool_types()
    .map(t => t.lookup_name())
  { facts, agents, tools }
}

#derive.agent
// webhooks require this agent to have an HTTP mount:
#derive.mount("/checkout/{order_id}")
struct CheckoutAgent {
  order_id : String
}

fn CheckoutAgent::new(order_id : String) -> CheckoutAgent {
  { order_id, }
}

pub async fn CheckoutAgent::pay(self : Self, amount : Int) -> Unit {
  let paid = @webhook.create()
  create_payment_link(self.order_id, amount, paid.url())
  // schedule a call on another agent for tomorrow:
  let reminder = MailerAgentClient::get(self.order_id)
    .schedule_cancelable_remind(in_days(1))
  // it waits here for days if needed, using no CPU or memory:
  let body = @json.parse(paid.wait().text())
  let event : PaymentEvent = @json.from_json(body)
  reminder.cancel()
  if event.status != "succeeded" { return }
  // sleep for a week; its deadline survives restarts:
  @monotonicClock.wait_for(7UL * 24 * 60 * 60 * 1_000_000_000)
  send_survey(self.order_id)
}

#derive.agent
#derive.mount("/docs/{doc}")
struct WriterAgent {
  doc : String
}

fn WriterAgent::new(doc : String) -> WriterAgent {
  { doc, }
}

#derive.endpoint(post="/draft")
pub fn WriterAgent::draft(
  self : Self,
  brief : String,
  // clients resume this Durable Stream from an offset:
) -> @schema.AgentStream[String] {
  @schema.AgentStream::produce(async fn(out) {
    for section in ["Summary", "Details", "Actions"] {
      // completed model calls are not repeated on recovery:
      let reply = @llm.generate_text(
        model=@llm.openai("gpt-4.1"),
        prompt="\{brief}\nWrite the \{section} section.",
      )
      guard out.write_one(reply) is Accepted else { return }
    }
  })
}

#derive.agent
struct StockAgent {
  sku : String
  mut units : Int
}

fn StockAgent::new(sku : String) -> StockAgent {
  { sku, units: 0 }
}

pub fn StockAgent::restock(self : Self, n : Int) -> Unit {
  self.units += n
}

// repeat calls come from a cache, without loading the agent:
// the cache clears when a restock succeeds:
// outgoing HTTP, agent calls and key-value writes fail:
#derive.read_only
pub fn StockAgent::level(self : Self) -> Int {
  self.units
}

Scala, MoonBit and Go agents each have their own durable file system too, but no supported SQLite library.

var g = genkit.Init(ctx,
    genkit.WithPlugins(&openai.OpenAI{}, &anthropic.Anthropic{}))

type Review struct {
    OK    bool   `json:"ok"`
    Notes string `json:"notes"`
}
type Draft struct {
    Text   string
    Review Review
}
type DraftID struct{ Topic string }
type WriteIn struct{ Idea string }

var Drafter = golem.DefineAgent[DraftID](
    golem.Spec{Name: "DraftAgent"})
var Write = Drafter.Method[WriteIn, Draft]("write")
var _ = Drafter.Implement(func(id DraftID) *DraftID {
    return &id
}).Handle(Write, golem.Adapt(func(d *DraftID, in WriteIn) Draft {
    // draft with one provider, review with another:
    draft := golem.Must(genkit.GenerateText(ctx, g,
        ai.WithModelName("openai/gpt-4.1"),
        ai.WithPrompt("Product update on "+d.Topic+": "+in.Idea)))
    review, _, err := genkit.GenerateData[Review](ctx, g,
        ai.WithModelName("anthropic/claude-sonnet-4-5"),
        ai.WithPrompt("Review this product update:\n"+draft))
    golem.Must0(err)
    return Draft{Text: draft, Review: *review}
}))

type PlannerID struct{ Topic string }

var Planner = golem.DefineAgent[PlannerID](
    golem.Spec{Name: "PlannerAgent"})
var Plan = Planner.Method[golem.Unit, PlanResult]("plan")
var _ = Planner.Implement(func(id PlannerID) *PlannerID {
    return &id
}).Handle(Plan, golem.Adapt0(func(p *PlannerID) PlanResult {
    // wait for a typed result from a Rust ResearchAgent:
    facts := researcher.MustGetResearchAgent(
        researcher.ResearchAgentID{Topic: p.Topic}).MustGather()
    // send now, without waiting for a result:
    slack.MustGetSlackAgent(slack.SlackAgentID{Channel: "ops"}).
        MustTriggerPost(facts.Summary)
    // discover agents, their methods, and available tools:
    var agents, tools []string
    for _, a := range reflection.DiscoverAgentTypes() {
        var methods []string
        for _, m := range a.Methods() {
            methods = append(methods, m.Name())
        }
        agents = append(agents,
            a.Name()+": "+strings.Join(methods, ", "))
    }
    for _, t := range reflection.DiscoverTools() {
        tools = append(tools, t.Name())
    }
    return PlanResult{Facts: facts, Agents: agents, Tools: tools}
}))

type CheckoutID struct{ OrderID string }
type PayIn struct{ Amount int32 }

var Checkout = golem.DefineAgent[CheckoutID](golem.Spec{
    Name: "CheckoutAgent",
    // webhooks require this agent to have an HTTP mount:
    HTTP: &golem.Mount{Path: "/checkout/{orderId}"},
})
var Pay = Checkout.Method[PayIn, golem.Unit]("pay")
var _ = Checkout.Implement(func(id CheckoutID) *CheckoutID {
    return &id
}).Handle(Pay, golem.AdaptUnit(func(c *CheckoutID, in PayIn) {
    paid := golem.NewWebhook[PaymentEvent]()
    createPaymentLink(c.OrderID, in.Amount, paid.URL())
    // schedule a call on another agent for tomorrow:
    mailer := Mailer.Get(MailerID{OrderID: c.OrderID})
    reminder := Remind.MustSchedule(mailer, inDays(1), golem.Unit{})
    // it waits here for days if needed, using no CPU or memory:
    event := paid.MustAwait()
    reminder.Cancel()
    if event.Status != "succeeded" {
        return
    }
    // sleep for a week; its deadline survives restarts:
    time.Sleep(7 * 24 * time.Hour)
    sendSurvey(c.OrderID)
}))

type WriterID struct{ Doc string }
type DraftIn struct{ Brief string }

var Writer = golem.DefineAgent[WriterID](golem.Spec{
    Name: "WriterAgent", HTTP: &golem.Mount{Path: "/docs/{doc}"},
})
var Draft = Writer.Method[DraftIn, golem.AgentStream[string]](
    // clients resume this Durable Stream from an offset:
    "draft", golem.HTTP(golem.POST("/draft")))
var _ = Writer.Implement(func(id WriterID) *WriterID {
    return &id
}).Handle(Draft, golem.Adapt((*WriterID).draft))

func (*WriterID) draft(in DraftIn) golem.AgentStream[string] {
    return golem.ProduceStream(in.write)
}
func (in DraftIn) write(w *golem.AgentStreamWriter[string]) error {
    sections := []string{"Summary", "Details", "Actions"}
    for _, section := range sections {
        // completed model calls are not repeated on recovery:
        reply := golem.Must(ai.Responses.New(ctx,
            responses.ResponseNewParams{Model: "gpt-4.1",
                Input: responses.ResponseNewParamsInputUnion{
                    OfString: openai.String(in.Brief +
                        "\nWrite the " + section + " section.")}}))
        if err := w.Write(reply.OutputText()); err != nil {
            return err
        }
    }
    return nil
}

type StockID struct{ SKU string }
type RestockIn struct{ N int32 }
type stock struct{ units int32 }

var Stock = golem.DefineAgent[StockID](
    golem.Spec{Name: "StockAgent"})
var Restock = Stock.Method[RestockIn, golem.Unit]("restock")
var Level = Stock.Method[golem.Unit, int32]("level",
    // repeat calls come from a cache, without loading the agent:
    // the cache clears when a restock succeeds:
    // outgoing HTTP, agent calls and key-value writes fail:
    golem.ReadOnly())

var impl = Stock.Implement(func(StockID) *stock { return &stock{} })
var _ = impl.Handle(Restock, golem.AdaptUnit((*stock).restock))
var _ = impl.Handle(Level, golem.Adapt0((*stock).level))

func (s *stock) restock(in RestockIn) { s.units += in.N }
func (s *stock) level() int32         { return s.units }