Back
    Use Case

    AI Agents on live streams

    Real-time agentic systems that observe, decide and act on live event streams — mix rules, models and tools in one pipeline.

    The decide step

    Reasoning isn't only a model call.

    Mix four engines in one pipeline — use the cheapest one that can make each decision, and keep the model for the calls that actually need it.

    Shape the stream first

    Filter, window, join and aggregate raw events deterministically — so the model sees a clean, enriched signal instead of firehose noise.

    Decide the obvious, instantly

    Route, gate and triage with declarative rules. Most events never need a model — catch them here and save the token spend.

    Reason over the hard ones

    Hand the ambiguous events to a model with a system prompt. Bring your own provider — cloud or local, your keys stay yours.

    Reach into the world

    Call real tools over the Model Context Protocol — query a system, open a ticket, ask a human to approve. The agent acts, it doesn't just answer.

    The act step

    An agent that can't act is just a dashboard.

    Take action

    Tools & human-in-the-loop

    Through MCP, a stage can invoke tools, trigger a workflow, or block on a real approval before it proceeds — the human is a step in the pipeline, not an afterthought.

    call a toolopen a ticketrequest approvalrun a workflow
    Emit & compose

    Every output is a topic

    A stage publishes to app.stage.out. Point the next agent's input at it and you've composed a multi-agent system — no glue code, just topics.

    webhook sinkchat sinknext agentSSE / SDK

    Real-time & durable

    Fast when it's up. Correct when it comes back.

    Deterministic replay

    Re-run an agent over the exact events it saw and get byte-identical decisions — debug what it did, not what it might have done.

    Crash-resume

    Per-agent stream offsets are persisted. Restart mid-flight and it picks up exactly where it stopped — no gap, no double-act.

    Windowed-state recovery

    Checkpointed window state survives a kill and rebuilds on restart, so a long-running aggregate isn't lost to one bad node.

    From zero to a running agent

    One file. One deploy.

    The whole agent is a pulse.yaml — a source, a chain of engine stages, a sink. Scaffold it, fill it in, deploy it.

    yaml
    1# pulse.yaml — an agent on a log stream
2source:
3  kind: file-tail
4  path: /var/log/app/events.log
5
6stages:
7  - name: triage
8    engine: rule-based
9    rules: [ "severity == 'error'" ]
10
11  - name: reason
12    engine: llm
13    systemPrompt: |
14      Classify the incident and draft
15      a one-line on-call summary.
16
17  - name: act
18    engine: mcp
19    mcpTools: [ pagerduty.createIncident ]
20
21sink:
22  kind: webhook
23  url: ${secret:ALERT_WEBHOOK}
24
    1. 1

      Scaffold.

      pulse new oncall --source file-tail --stage rule-based:triage --stage llm:reason --stage mcp:act --sink webhook
    2. 2

      Fill it in.

      Edit the source path, the rules, the prompt, the tools. Secrets stay ${secret:…}, never inline.

    3. 3

      Deploy.

      pulse deploy .

      Stands up the source, the stage pipeline and the sink, plus a typed API + SDK.

    4. 4

      Feed & watch.

      pulse events tail --topic oncall.reason.out

      See the agent decide in real time.

    Build an agent that reacts to reality.

    See the observe → decide → act loop run on a live stream in a few minutes — no install, no signup.

    Try it live in the playgroundRead the agent guide

    Pulse is free and self-hosted. LLM stages use your own provider; MCP stages use the tools you install.