Agent to Agent communication

See Agent communication for an overview of how agents call, wait for, and stream to each other.

Code-first approach

When defining an agent in code, this automatically defines a client interface for calling remote agents as well. This way an agent of an agent type can create other agents and invoke methods on them. The target agent can be of any agent type available for the caller agent in code.

The simplest way to achieve this is to keep all the agent types that need to call each other in the same component. For agents in different components, use a generated guest bridge instead of importing the target’s implementation.

Creating a client

The first step of calling a remote agent is creating a client for it by specifying which agent type it is and identifying the agent by providing values for its constructor parameters. If the agent identified by the parameters has not been existing yet, it is going to be created and its constructor is executed remotely. If it has been already created, the client just points to it and no action is taken until an agent method is called using it.

The examples below return illustrative weather data for the selected location. The caller returns the remote method’s result, rather than fetching a real weather service.

TypeScript

In the following example, we have two agents defined; a weather agent with a constructor parameter identifying a location, and another example agent creating and calling this weather agent.


import { z } from 'zod';
import { defineAgent, method } from '@golemcloud/golem-ts-sdk';
 
export const WeatherAgent = defineAgent({
    name: 'WeatherAgent',
    id: { location: z.string() },
    methods: {
        currentWeather: method({
            input: {},
            returns: z.string(),
            description: "Gets the current weather",
        }),
    },
});
 
export const WeatherAgentImpl = WeatherAgent.implement({
    init: ({ id }) => ({ location: id.location }),
    methods: {
        currentWeather() {
            return `${this.location}: sunny, 18°C`;
        },
    },
});
 
export const ExampleAgent = defineAgent({
    name: 'ExampleAgent',
    id: {},
    methods: {
        run: method({ input: {}, returns: z.string() }),
    },
});
 
export const ExampleAgentImpl = ExampleAgent.implement({
    init: () => ({}),
    methods: {
        async run() {
            const weatherInLondon = WeatherAgent.client.get({ location: "London" });
            return await weatherInLondon.currentWeather({});
        },
    },
});

Here weatherInLondon is the client for calling a remote WeatherAgent, obtained from WeatherAgent.client with the target agent’s id record - it exposes the agent methods, such as currentWeather as its own methods.

Effect TypeScript

In Effect TypeScript, the definition’s typed client returns scoped Effects:


import { Effect, Schema } from "effect"
import { defineAgent, method } from "@golemcloud/effect-golem"
 
export const WeatherAgent = defineAgent({
  name: "WeatherAgent",
  mode: "durable",
  id: { location: Schema.String },
  methods: {
    currentWeather: method({ input: {}, success: Schema.String }),
  },
})
 
export const WeatherAgentImpl = WeatherAgent.implement({
  init: ({ location }) => Effect.succeed(location),
  methods: (location) => ({
    currentWeather: () => Effect.succeed(`${location}: sunny, 18°C`),
  }),
})
 
export const ExampleAgent = defineAgent({
  name: "ExampleAgent",
  mode: "durable",
  id: {},
  methods: { run: method({ input: {}, success: Schema.String }) },
}).implement({
  init: () => Effect.void,
  methods: () => ({
    run: () => Effect.scoped(Effect.gen(function* () {
      const weatherInLondon = yield* WeatherAgent.client.get({ location: "London" })
      return yield* weatherInLondon.currentWeather({})
    })).pipe(Effect.orDie),
  }),
})

The scope releases the client after the call. The client exposes each agent method as an Effect-returning function. This example uses Effect.orDie to trap on RPC failures; alternatively, handle them or map them to an error declared by the calling method.

Rust

In the following example, we have two agents defined; a weather agent with a constructor parameter identifying a location, and another example agent creating and calling this weather agent.


use golem_rust::{agent_definition, agent_implementation};
 
#[agent_definition]
pub trait WeatherAgent {
    fn new(location: String) -> Self;
    async fn current_weather(&self) -> String;
}
 
struct WeatherAgentImpl {
    location: String,
}
 
#[agent_implementation]
impl WeatherAgent for WeatherAgentImpl {
    fn new(location: String) -> Self {
        Self { location }
    }
 
    async fn current_weather(&self) -> String {
        format!("{}: sunny, 18°C", self.location)
    }
}
 
#[agent_definition]
pub trait ExampleAgent {
    fn new() -> Self;
    async fn run(&self) -> String;
}
 
struct ExampleAgentImpl;
 
#[agent_implementation]
impl ExampleAgent for ExampleAgentImpl {
    fn new() -> Self {
        ExampleAgentImpl
    }
 
    async fn run(&self) -> String {
        let weather_in_london = WeatherAgentClient::get("London".to_string());
        weather_in_london.current_weather().await
    }
}

Given there is a WeatherAgent defined, we have an auto generated client with the name WeatherAgentClient, Here weather_in_london is the client for calling a remote WeatherAgent - it exposes the agent methods, such as current_weather as its own methods.

Scala

In the following example, we have two agents defined; a weather agent with a constructor parameter identifying a location, and another example agent creating and calling this weather agent.


import golem.BaseAgent
import golem.runtime.annotations.{agentDefinition, agentImplementation, description}
 
import scala.concurrent.Future
 
@agentDefinition()
trait WeatherAgent extends BaseAgent {
  class Id(val location: String)
 
  @description("Gets the current weather")
  def currentWeather(): Future[String]
}
 
@agentImplementation()
final class WeatherAgentImpl(private val location: String) extends WeatherAgent {
  override def currentWeather(): Future[String] = {
    Future.successful(s"$location: sunny, 18°C")
  }
}
 
@agentDefinition()
trait ExampleAgent extends BaseAgent {
  class Id()
 
  def run(): Future[String]
}
 
@agentImplementation()
final class ExampleAgentImpl() extends ExampleAgent {
  override def run(): Future[String] = {
    val weatherInLondon = WeatherAgentClient.get("London")
    weatherInLondon.currentWeather()
  }
}

Given there is a WeatherAgent defined, we have an auto generated client with the name WeatherAgentClient, Here weatherInLondon is the client for calling a remote WeatherAgent - it exposes the agent methods, such as currentWeather as its own methods.

MoonBit

In the following example, we have two agents defined; a weather agent with a constructor parameter identifying a location, and another example agent creating and calling this weather agent.


#derive.agent
struct WeatherAgent {
  location : String
}
 
fn WeatherAgent::new(location : String) -> WeatherAgent {
  { location, }
}
 
/// Gets the current weather
pub fn WeatherAgent::current_weather(self : Self) -> String {
  "\{self.location}: sunny, 18°C"
}
 
#derive.agent
struct ExampleAgent {
  mut last_weather : String
}
 
fn ExampleAgent::new() -> ExampleAgent {
  { last_weather: "" }
}
 
pub async fn ExampleAgent::run(self : Self) -> String {
  let weather_in_london = WeatherAgentClient::get("London")
  defer weather_in_london.drop()
  let weather = weather_in_london.current_weather()
  self.last_weather = weather
  weather
}

Go

In the following example, we have two agents defined; a weather agent with a constructor parameter identifying a location, and another example agent creating and calling this weather agent. Each agent has a definition package and an implementation package:

These generic methods use Golem’s Go toolchain, which the CLI installs for component builds.

agents/weather/weather.go


package weather
 
import "github.com/golemcloud/golem/sdks/go/golem"
 
type ID struct{ Location string }
 
var Agent = golem.DefineAgent[ID](golem.Spec{Name: "WeatherAgent"})
 
var CurrentWeather = Agent.Method[golem.Unit, string]("currentWeather", golem.Description("Gets the current weather"))

agents/weather/impl/impl.go


package impl
 
import (
	"myapp/agents/weather"
 
	"github.com/golemcloud/golem/sdks/go/golem"
)
 
type state struct{ location string }
 
var agent = weather.Agent.Implement(func(id weather.ID) *state { return &state{location: id.Location} })
 
func init() {
	agent.Handle(weather.CurrentWeather, func(ctx *golem.Context[state], _ golem.Unit) string {
		return ctx.State.location + ": sunny, 18°C"
	})
}

agents/example/example.go


package example
 
import "github.com/golemcloud/golem/sdks/go/golem"
 
type ID struct{}
 
var Agent = golem.DefineAgent[ID](golem.Spec{Name: "ExampleAgent"})
 
var Run = Agent.Method[golem.Unit, string]("run")

agents/example/impl/impl.go


package impl
 
import (
	"myapp/agents/example"
	"myapp/agents/weather"
 
	"github.com/golemcloud/golem/sdks/go/golem"
)
 
type state struct{}
 
var agent = example.Agent.Implement(func(example.ID) *state { return &state{} })
 
func init() {
	agent.Handle(example.Run, func(ctx *golem.Context[state], _ golem.Unit) string {
		weatherInLondon := weather.Agent.Get(weather.ID{Location: "London"})
		return weather.CurrentWeather.MustCall(weatherInLondon, golem.Unit{})
	})
}

Here weatherInLondon is a golem.Client[weather.ID] for calling a remote WeatherAgent, obtained from the target’s definition with its ID. The caller imports only the definition package, never the target’s impl package. The method descriptors of the definition, such as weather.CurrentWeather, are called with this client.

Calling an agent in another component

Declare the target agent in the caller component’s dependencies.agents. During golem build, Golem builds the provider, discovers its agent schema, generates a typed guest client in the caller’s language, and then builds the caller. The provider and caller can use different SDKs. You do not need to share or duplicate the agent definition.

The dependency names the provider component and agent type. When creating a client, pass the constructor values that identify the target agent, not a component ID or server address.

The examples below assume that the application already contains a component named example:weather. It exports the durable WeatherAgent from the earlier example: its constructor takes a location, and its weather method returns a string. Merge the caller configuration into the existing golem.yaml, then add the generated client to the caller’s build as shown in your SDK’s tab. Paths assume the default golem-temp directory at the application root.

TypeScript

Declare the dependency on the TypeScript caller:

golem.yaml


components:
  example:caller:
    dir: caller
    templates: ts
    dependencies:
      agents:
        - example:weather/WeatherAgent

Add the generated source to the caller’s existing tsconfig.json. Merge these settings with the existing compiler options, path mappings, and included sources:

caller/tsconfig.json


{
  "compilerOptions": {
    "paths": {
      "weather-agent-guest-client": [
        "../golem-temp/bridge-sdk/ts/internal/weather-agent-guest-client/weather-agent-guest-client.ts"
      ]
    }
  },
  "include": [
    "src/**/*.ts",
    "../golem-temp/bridge-sdk/ts/internal/weather-agent-guest-client/*.ts"
  ]
}

Call the generated client from an agent method, without importing or registering the provider’s definition:

caller/src/weather.ts


import { WeatherAgent } from "weather-agent-guest-client"
 
export async function weatherInLondon(): Promise<string> {
  const weather = WeatherAgent.get("London")
  return await weather.currentWeather()
}

Unlike a definition client, the generated client’s get takes positional constructor arguments and its weather method takes no input object. Resolution and invocation failures throw.

Effect TypeScript

Declare the dependency on the Effect caller:

golem.yaml


components:
  example:caller:
    dir: caller
    templates: effect
    dependencies:
      agents:
        - example:weather/WeatherAgent

Merge the generated source mapping and include pattern into the caller’s existing tsconfig.json:

caller/tsconfig.json


{
  "compilerOptions": {
    "paths": {
      "weather-agent-guest-client": [
        "../golem-temp/bridge-sdk/effect/internal/weather-agent-guest-client/weather-agent-guest-client.ts"
      ]
    }
  },
  "include": [
    "src/**/*.ts",
    "../golem-temp/bridge-sdk/effect/internal/weather-agent-guest-client/*.ts"
  ]
}

Use the generated client inside an agent method’s effect:

caller/src/weather.ts


import { Effect } from "effect"
import { WeatherAgent } from "weather-agent-guest-client"
 
export const weatherInLondon = Effect.gen(function* () {
  const weather = yield* WeatherAgent.get("London")
  return yield* weather.currentWeather()
})

The generated get takes positional constructor arguments, not an ID record. Both client resolution and invocation return effects. Handle their failures or map them to an error declared by the calling agent method; use Effect.orDie only when the invocation should trap instead.

Rust

Declare the dependency on the Rust caller:

golem.yaml


components:
  example:caller:
    dir: caller
    templates: rust
    dependencies:
      agents:
        - example:weather/WeatherAgent

Add the generated crate to the caller’s existing dependencies:

caller/Cargo.toml


[dependencies.weather-agent-guest-client]
path = "../golem-temp/bridge-sdk/rust/internal/weather-agent-guest-client"

Call it from an async agent method. The generated type is WeatherAgent, not the same-component WeatherAgentClient:

caller/src/weather.rs


use weather_agent_guest_client::WeatherAgent;
 
pub async fn weather_in_london() -> Result<String, String> {
    let weather = WeatherAgent::get("London".to_string())
        .map_err(|error| format!("{error:?}"))?;
    weather.current_weather().await
        .map_err(|error| format!("{error:?}"))
}

Both client construction and the remote call return Result. This helper propagates their errors to its caller.

Scala

Declare the dependency on the Scala caller:

golem.yaml


components:
  example:caller:
    dir: caller
    templates: scala
    dependencies:
      agents:
        - example:weather/WeatherAgent

Add the generated source directory to the caller’s sbt project settings, not to the provider’s project. For example, append this setting to the caller’s existing .settings(...) block:

caller.sbt


Compile / unmanagedSourceDirectories +=
  (LocalRootProject / baseDirectory).value /
    "golem-temp/bridge-sdk/scala/internal" /
    "weather-agent-guest-client/src/main/scala"

Import the generated client from its agent-specific package and call it from an agent method:


import golem.bridge.client.weather_agent.WeatherAgentClient
import scala.concurrent.Future
 
def weatherInLondon(): Future[String] = {
  val weather = WeatherAgentClient.get("London")
  weather.currentWeather()
}

Client resolution can throw; the awaited method returns a Future that fails when the remote call fails. No shared agent-definition module is needed.

MoonBit

Declare the dependency on the MoonBit caller:

golem.yaml


components:
  example:caller:
    dir: caller
    templates: moonbit
    dependencies:
      agents:
        - example:weather/WeatherAgent

The generated module is golem-temp/bridge-sdk/moonbit/internal/weather-agent-guest-client. Add it to the application’s moon.work and import weather-agent-guest-client@0.0.1 in moon.mod. Keep the generated module unchanged.

Build integration is required: a multi-module MoonBit workspace changes the WASM output paths. The stock template does not handle this layout automatically. Configure workspace-aware debug and release build/embed commands before building the caller; see Calling Another Agent (MoonBit). The provider must also be independently buildable, without importing the caller’s package.

Add the generated client package to the caller’s existing moon.pkg. Preserve the template’s existing SDK imports, link configuration, and WASM exports:

caller/moon.pkg


import {
  "weather-agent-guest-client/client" @weather,
  // ...existing imports
}

The caller can now use the generated typed client without importing the provider component or duplicating its agent definition:

caller/example_agent.mbt


#derive.agent
struct ExampleAgent {}
 
fn ExampleAgent::new() -> ExampleAgent {
  {}
}
 
pub async fn ExampleAgent::weather_in_london(self : Self) -> String {
  let _ = self
  @weather.WeatherAgentClient::scoped(
    "London",
    async fn(remote) { remote.current_weather() },
  )
}

scoped releases the generated client when the async callback finishes. MoonBit uses no await keyword.

Go

Declare the dependency on the Go caller:

golem.yaml


components:
  example:caller:
    dir: caller
    templates: go
    dependencies:
      agents:
        - example:weather/WeatherAgent

The client is generated as the Go module golem.local/bridge/weather-agent-guest-client under golem-temp/bridge-sdk/go/internal/. Point the caller’s go.mod at it:

caller/go.mod


require golem.local/bridge/weather-agent-guest-client v0.0.0

replace golem.local/bridge/weather-agent-guest-client => ../golem-temp/bridge-sdk/go/internal/weather-agent-guest-client

The caller can then use the typed client without depending on the provider’s definition package:

caller/weather.go


package caller
 
import weather "golem.local/bridge/weather-agent-guest-client"
 
func weatherInLondon() (string, error) {
    london, err := weather.GetWeatherAgent(
        weather.WeatherAgentID{Location: "London"},
    )
    if err != nil {
        return "", err
    }
    return london.CurrentWeather()
}

Call this helper from an agent handler. GetWeatherAgent and the remote method both return errors. Their Must variants panic on failure instead.

After adding the dependency and build integration, run golem build from the application root. Rebuild whenever the provider’s API changes; do not edit generated client files. The caller uses Golem’s agent-to-agent RPC, not the external REST bridge, so it needs no API server URL or access token. Deploy both components to the same environment before invoking the caller.

Phantom agents

Calling get gets or creates a durable agent identified by its constructor parameters. Durable agent types have a default instance and can have arbitrary phantom instances distinguished by an additional phantom ID UUID. Ephemeral clients expose only phantom factories.

When using agent IDs (for example in APIs or the CLI), phantom IDs are appended to the agent ID in square brackets:

Primary instance of WeatherAgent with parameter London:
- WeatherAgent("London")
A phantom instance of the same agent:
- WeatherAgent("London")[43d9d7ab-e1d7-47e2-a213-d635eaa317a2]

Phantom agents are created through Agent-to-Agent communication or forking. To create a new phantom agent via RPC, use the alternative client constructor method:

TypeScript


const { client: phantomAgent, agentId, phantomId } = WeatherAgent.client.newPhantom({ location: "London" });

Effect TypeScript


const phantomAgent = yield* WeatherAgent.client.newPhantom({ location: "London" })
const phantomId = phantomAgent.phantomId

Rust


let phantom_agent = WeatherAgentClient::new_phantom("London".to_string());

Scala


val phantomAgent = WeatherAgentClient.newPhantom("London")

MoonBit


let phantom_agent = WeatherAgentClient::new_phantom("London")
defer phantom_agent.drop()

Go


phantomAgent := weather.Agent.NewPhantom(weather.ID{Location: "London"})

If we know the phantom ID of an agent, we can create a client targeting an existing phantom agent:

TypeScript


const { client: phantomAgent, agentId, phantomId } = WeatherAgent.client.newPhantom({ location: "London" });
const samePhantomAgent = WeatherAgent.client.getPhantom({ location: "London" }, phantomId);

Effect TypeScript


const { phantomId } = yield* WeatherAgent.client.newPhantom({ location: "London" })
const samePhantomAgent = yield* WeatherAgent.client.getPhantom(
  { location: "London" },
  phantomId,
)

Rust


let phantom_agent = WeatherAgentClient::new_phantom("London".to_string());
let phantom_id = phantom_agent.phantom_id().unwrap(); // It's an Option<Uuid>, but always Some for phantom agents
let same_phantom_agent = WeatherAgentClient::get_phantom(phantom_id, "London".to_string());

Scala


import golem.Uuid
 
val phantomId = Uuid(BigInt(42), BigInt(99))
val samePhantomAgent = WeatherAgentClient.getPhantom("London", phantomId)

MoonBit


let phantom_agent = WeatherAgentClient::new_phantom("London")
defer phantom_agent.drop()
let phantom_id = phantom_agent.phantom_id().unwrap()
let same_phantom_agent = WeatherAgentClient::get_phantom("London", phantom_id)
defer same_phantom_agent.drop()

Go


phantomAgent := weather.Agent.NewPhantom(weather.ID{Location: "London"})
phantomID := phantomAgent.PhantomID().Unwrap() // It's an Option[golem.UUID], but always set for phantom agents
samePhantomAgent := weather.Agent.Get(weather.ID{Location: "London"}, golem.WithPhantomID(phantomID))

Dynamic RPC

When the target agent type or method is selected at runtime, use Agent reflection. It supports discovering agent schemas, addressing phantom agents, and invoking methods dynamically without importing the target’s definition or generating a guest bridge.

Calling a remote agent method

Once we have a client for a remote agent, it is possible to call its methods just as if it would be a local instance.

TypeScript


const currentWeather = await weatherInLondon.currentWeather();

Effect TypeScript


 const currentWeather = yield* weatherInLondon.currentWeather({})

Rust


 let current_weather = weather_in_london.current_weather().await;

Scala


 val currentWeather = weatherInLondon.currentWeather()

MoonBit

Inside an async MoonBit agent method:


 let current_weather = weather_in_london.current_weather()

Go


 currentWeather, err := weather.CurrentWeather.Call(weatherInLondon, golem.Unit{})

Call returns a remote failure as a *golem.RemoteCallError, whose Kind classifies it. MustCall returns only the value and panics on a failure instead; the panic traps the component, as in Rust:


 currentWeather := weather.CurrentWeather.MustCall(weatherInLondon, golem.Unit{})

Triggering execution of an agent method

It is possible to trigger the remote execution of an agent method without awaiting it. This is useful for spawning background tasks, for example.

TypeScript

To trigger an agent method and return immediately, use the trigger method exposed on each remote method in the client:


const remoteAgent = BackgroundTaskAgent.client.get({ jobId: backgroundJobId });
remoteAgent.runTask.trigger({ message: "hello", count: 1234 });

Effect TypeScript

Each remote method exposes a typed trigger Effect:


const remoteAgent = yield* BackgroundTaskAgent.client.get({ jobId: backgroundJobId })
yield* remoteAgent.runTask.trigger({ message: "hello", count: 1234 })

Rust

To trigger an agent method and return immediately, use the trigger_ variant exposed on the generated client. Example: If there is a run_task, its trigger variant is trigger_run_task:


let remote_agent = BackgroundTaskAgentClient::get(background_job_id);
remote_agent.trigger_run_task("hello".to_string(), 1234);

Scala

To trigger an agent method and return immediately, use the trigger method exposed on each remote method in the generated client:


val remoteAgent = BackgroundTaskAgentClient.get(backgroundJobId)
remoteAgent.runTask.trigger("hello", 1234)

MoonBit

To trigger an agent method and return immediately, use the trigger_ variant exposed on the generated client. Example: If there is a run_task, its trigger variant is trigger_run_task:


let remote_agent = BackgroundTaskAgentClient::get(background_job_id)
defer remote_agent.drop()
remote_agent.trigger_run_task("hello", 1234)

Go

To trigger an agent method and return immediately, use the Trigger method of the method descriptor. It returns the golem.InvocationID of the enqueued invocation, and an error if the invocation could not be enqueued (MustTrigger panics instead):


remoteAgent := backgroundtask.Agent.Get(backgroundtask.ID{JobID: backgroundJobID})
backgroundtask.RunTask.MustTrigger(remoteAgent, backgroundtask.RunTaskIn{Message: "hello", Count: 1234})

Scheduling an agent method

An advanced case of triggering the execution of an agent method is to schedule it to be executed at a later time.

TypeScript

Similar to .trigger, there is a .schedule method as well on each remote agent method in the client:


const remoteAgent = BackgroundTaskAgent.client.get({ jobId: backgroundJobId });
remoteAgent.runTask.schedule({ seconds: 60n, nanoseconds: 0 }, { message: "hello", count: 1234 });

Here the first parameter is a Datetime object, with seconds and nanoseconds fields representing the UNIX Epoch time when the method should be executed. In TypeScript, seconds is a bigint. The rest of the parameters are the same as for the original method.

Effect TypeScript

Pass an absolute time as a Datetime, JavaScript Date, Effect DateTime, or numeric Unix-epoch milliseconds:


const remoteAgent = yield* BackgroundTaskAgent.client.get({ jobId: backgroundJobId })
yield* remoteAgent.runTask.schedule(new Date(Date.now() + 10 * 60 * 1000), {
  message: "hello",
  count: 1234,
})

Rust

Similar to trigger, there is a schedule variant for each remote agent method in the client. Example: If run_task is a method, its schedule variant is schedule_run_task:


use golem_rust::ScheduledTime;
 
let mut remote_agent = BackgroundTaskAgentClient::get(background_job_id);
 
remote_agent.schedule_run_task(
  "hello".to_string(),
  1234,
  ScheduledTime {
    seconds: 60,
    nanoseconds: 0,
  },
).expect("failed to schedule background task");

Here the last parameter is a ScheduledTime, with seconds and nanoseconds fields representing the UNIX Epoch time when the method should be executed. The rest of the parameters are the same as for the original method.

Scala

Similar to trigger, there is a scheduleAt method as well on each remote agent method in the generated client:


val remoteAgent = BackgroundTaskAgentClient.get(backgroundJobId)
remoteAgent.runTask.scheduleAt("hello", 1234, golem.Datetime.afterSeconds(60))

Here the last parameter is a Datetime object representing when the method should be executed. The rest of the parameters are the same as for the original method.

MoonBit

Similar to trigger, there is a schedule_ variant for each remote agent method in the generated client. Example: If run_task is a method, its schedule variant is schedule_run_task:


// In moon.pkg:
// import { "golemcloud/golem_sdk/interface/wasi/clocks/system-clock" @systemClock }
 
let remote_agent = BackgroundTaskAgentClient::get(background_job_id)
defer remote_agent.drop()
remote_agent.schedule_run_task(
  @systemClock.Instant::{ seconds: 60, nanoseconds: 0 },
  "hello",
  1234,
)

Here the first parameter is a system-clock Instant, with seconds and nanoseconds fields representing the UNIX Epoch time when the method should be executed. The rest of the parameters are the same as for the original method.

Go

Similar to Trigger, there is a Schedule method on each method descriptor:


remoteAgent := backgroundtask.Agent.Get(backgroundtask.ID{JobID: backgroundJobID})
scheduled := backgroundtask.RunTask.MustSchedule(
  remoteAgent,
  time.Now().Add(60*time.Second),
  backgroundtask.RunTaskIn{Message: "hello", Count: 1234},
)

Here the second parameter is a time.Time representing when the method should be executed, and the last one is the method’s input. The returned *golem.ScheduledInvocation can be canceled with scheduled.Cancel() until the invocation starts. Schedule returns the same value with an error instead of panicking.