# Golem Fire And Forget TS

> Triggering an agent invocation without waiting for the result in a TypeScript Golem project. Use when the user asks about fire-and-forget calls, async triggers, or enqueuing agent work.

- Skill: `golemcloud/golem-fire-and-forget-ts` (Agent Skill)
- Install (CLI): `npx skillmds@latest add golemcloud/golem-fire-and-forget-ts`
- Raw SKILL.md: https://api.skillmd.com/api/skills/golemcloud/golem-fire-and-forget-ts/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: golemcloud (https://skillmd.com/u/golemcloud)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/golemcloud/golem-fire-and-forget-ts

---


# Fire-and-Forget Agent Invocation (TypeScript)

## Overview

A **fire-and-forget** call enqueues a method invocation on the target agent and
returns immediately without waiting for the result. The target agent processes
the invocation asynchronously.

## Usage

Every method on a definition RPC client has a `.trigger()` variant. It takes
the same input record as the awaited call but returns `void` immediately:

```typescript
import { Counter } from './counter-agent.js';

const counter = Counter.client.get({ name: 'my-counter' });

// Fire-and-forget — returns immediately
counter.increment.trigger();          // input: {}

// With arguments
const processor = DataProcessor.client.get({ name: 'pipeline-1' });
processor.processBatch.trigger({ batch: batchData });
```

For an agent in another component, the generated guest client exposes the same
`.trigger()` method, but its constructor uses flattened id parameters:

```typescript
import { CounterAgent } from 'counter-agent-guest-client';

CounterAgent.get('my-counter').increment.trigger();
```

See the `golem-call-another-agent-ts` skill for the required `golem.yaml` and
`tsconfig.json` setup. Use the definition's `.client` for same-component calls.

## When to Use

- **Breaking RPC cycles**: If agent A calls agent B and B needs to call back to A, use `.trigger()` for the callback to avoid deadlocks
- **Background work**: Enqueue work on another agent without blocking the current agent
- **Fan-out**: Trigger work on many agents in parallel without waiting for all results
- **Event-driven patterns**: Notify other agents about events without coupling to their processing time

## Example: Breaking a Deadlock

```typescript
import { AgentA } from './agent-a.js';
import { AgentB } from './agent-b.js';

// In AgentA — calls AgentB and waits
const b = AgentB.client.get({ name: 'b1' });
const result = await b.doWork({ data }); // OK: awaited call

// In AgentB — notifies AgentA without waiting (would deadlock if awaited)
const a = AgentA.client.get({ name: 'a1' });
a.onWorkDone.trigger({ result }); // OK: fire-and-forget
```

## CLI Equivalent

From the command line, use `--trigger` (or `-t`) to enqueue an invocation without
waiting:

```shell
golem agent invoke --trigger 'Counter("my-counter")' increment
```