Utah (Inngest) — Summary

Utah (Universally Triggered Agent Harness) is a minimal TypeScript reference implementation of an Inngest-powered durable AI agent with Slack and Telegram messaging channels. Built by the Inngest team, it demonstrates how to build a production-grade personal AI agent where every LLM call and every tool execution is an Inngest step — gaining automatic retries, singleton concurrency, cancel-on-new-message, and WebSocket-based local development (no ngrok needed) for free. The agent uses pi-ai for multi-provider LLM abstraction (Anthropic/OpenAI/Google), pi-coding-agent for battle-tested coding tools (bash, read, write, edit, grep, find, ls), and a two-tier memory system (daily logs + long-term MEMORY.md via cron-triggered distillation). The workspace context (SOUL.md, USER.md, MEMORY.md) is injected into the system prompt. Context compaction, tool result pruning, and conversation summarization are all built in. Utah is explicitly positioned as a reference harness, not a framework.

differs_from_seeds: Utah is unique in this batch in that durability (crash recovery, step retries) is the primary architectural concern — not prompt engineering, not multi-model routing, not UI. Every LLM call and tool invocation is wrapped in step.run(), giving Inngest-level durability guarantees absent from all 11 seeds. Closest to claude-conductor (markdown scaffold, simple workspace files) but Utah is a full TypeScript runtime with durable execution rather than a template repository. The Inngest-powered execution mode — event-driven via WebSocket, no public endpoints — is architecturally novel versus all seeds.

Utah (Inngest) — Overview

Origin

Utah is authored by the Inngest team (GitHub: inngest/utah) as a showcase/reference for Inngest-powered AI agents. Inngest is a durable workflow platform. Utah's README subtitle: "An OpenClaw-like Inngest-powered personal agent."

Philosophy

From the README:

"A durable AI agent built with Inngest and pi-ai. No framework. Just a think/act/observe loop — Inngest provides durability, retries, and observability, while pi-ai provides a unified LLM interface across providers."

"Every LLM call and tool execution is an Inngest step — giving you durability, retries, and observability for free."

Key Inngest features:

• Singleton execution: One conversation at a time per chat, no race conditions
• Cancel on new message: User sends again? Current run cancels, new one starts
• Automatic retries: LLM API timeouts handled by Inngest, not your code
• WebSocket-based local dev: connect() — no public endpoint, no ngrok, no VPS

The "Always-On" Boundary

Utah's always-on boundary is the Inngest Cloud event bus + the local worker. The worker connects to Inngest Cloud via WebSocket (connect()). Messages flow through Inngest as events; the worker processes them locally. The local worker can be stopped and restarted without losing in-flight work — Inngest checkpoints every step.

Design Philosophy (Agent Architecture)

From agent-loop.ts docstring:

"Every LLM call and tool execution is an Inngest step — giving you durability, retries, and observability for free. pi-ai differences from raw Anthropic API: Unified Message/Tool types that work across providers; TypeBox schemas for tool parameters (validated at runtime); Content blocks use 'toolCall'/'toolResult' instead of 'tool_use'/'tool_result'"

Context Pruning Philosophy

From code comments:

"Two-tier pruning inspired by OpenClaw/pi-agent-core: Soft trim: keep head + tail of old tool results. Hard clear: replace entirely when total context is huge."

Utah (Inngest) — Architecture

Distribution

• Type: Clone-and-configure (TypeScript, Node.js 23+)
• License: Apache-2.0
• Runtime: Node.js 23+ (uses native TypeScript strip-types)
• Dependencies: Inngest Cloud account required

Architecture Overview

Channel (e.g. Telegram) → Inngest Cloud (webhook + transform) → WebSocket → Local Worker → LLM (Anthropic/OpenAI/Google) → Reply Event → Channel API

The worker connects to Inngest Cloud via WebSocket — no public endpoint needed.

Directory Structure

src/
├── worker.ts                  # Entry point — connect() or serve()
├── client.ts                  # Inngest client
├── config.ts                  # Configuration from env vars
├── agent-loop.ts              # Core think → act → observe cycle
├── setup.ts                   # Channel setup orchestration
├── lib/
│   ├── llm.ts                 # pi-ai wrapper (multi-provider)
│   ├── tools.ts               # Tool definitions (TypeBox schemas) + execution
│   ├── context.ts             # System prompt builder with workspace file injection
│   ├── session.ts             # JSONL session persistence
│   ├── memory.ts              # File-based memory (daily logs + distillation)
│   └── compaction.ts          # LLM-powered conversation summarization
├── functions/
│   ├── message.ts             # Main agent function (singleton + cancelOn)
│   ├── send-reply.ts          # Channel-agnostic reply dispatch
│   ├── acknowledge-message.ts # Message acknowledgment (typing indicator)
│   ├── heartbeat.ts           # Cron-based memory maintenance (every 30 min)
│   └── failure-handler.ts     # Global error handler with notifications
└── channels/
    ├── telegram/              # Telegram channel implementation
    └── slack/                 # Slack channel implementation
workspace/
├── SOUL.md                    # Agent personality and behavioral guidelines
├── USER.md                    # User information (name, timezone, preferences)
├── MEMORY.md                  # Long-term memory (agent-writable)
├── memory/                    # Daily logs (YYYY-MM-DD.md, auto-managed)
└── sessions/                  # JSONL conversation files

Inngest Functions

Utah (Inngest) — Components

Agent Loop (Core)

The think → act → observe cycle in agent-loop.ts:

1. Think: step.run("think") — LLM call via pi-ai
2. Act: if tools requested, each tool runs as step.run("tool-<name>")
3. Observe: tool results fed back into conversation
4. Repeat: until LLM responds with text (no tools) or max iterations hit

Each iteration automatically indexed by Inngest (think:0, think:1, etc.).

Tools (from pi-coding-agent + custom)

Memory System (Two-Tier)

• Daily logs (workspace/memory/YYYY-MM-DD.md): append-only notes via remember tool
• Long-term memory (workspace/MEMORY.md): curated summary distilled by heartbeat
• Heartbeat: cron every 30 min — checks if enough content accumulated, then distills

Context Injection

Workspace files injected into system prompt at every turn:

• workspace/SOUL.md — agent personality + behavioral guidelines
• workspace/USER.md — user info (name, timezone, preferences)
• workspace/MEMORY.md — curated long-term memory

Context Compaction

• Token estimation: chars/4 heuristic
• Threshold: 80% of configured max (150K default)
• LLM summarization: old messages summarized into checkpoint (goals, progress, decisions, next steps)
• Recent messages preserved: ~20K tokens verbatim
• Persisted: compacted session replaces JSONL file

Context Pruning (per-turn)

Two-tier:

• Soft trim: tool results over 4K chars → head+tail trim (first 1,500 + last 1,500 chars)
• Hard clear: total old tool content over 50K chars → replace entirely with placeholder

Channel Adapters

• Telegram: fully automated setup (bot token only)
• Slack: Slack app + Event Subscriptions configuration

Each channel implements ChannelHandler interface (sendReply, acknowledge, setup).

Utah (Inngest) — Uniqueness

differs_from_seeds

Utah has no close seed equivalent — it occupies a unique position as an event-driven, Inngest-durable personal agent with Slack/Telegram channels and no web UI. The closest seed is claude-conductor (markdown workspace files, simple behavioral configuration) but Utah is a full TypeScript runtime with durable execution guarantees. The decisive differentiator is Inngest durability: every step.run() is checkpointed, retried on failure, and idempotent — something no seed implements. The singleton concurrency pattern (cancelOn: newMessageEvent) elegantly solves the "user sends follow-up while previous response is still generating" race condition. The workspace files (SOUL.md, USER.md, MEMORY.md) are functionally similar to agent-os's standards/ markdown, but Utah's files are actively read/written by the agent and maintained by a cron heartbeat. Unlike all seeds, Utah requires a third-party cloud service (Inngest) as part of its core architecture — the "always-on" boundary is not Utah's process but Inngest's managed event infrastructure.

Positioning

Utah is positioned as a reference harness for Inngest — demonstrating how to build a personal AI agent where the hard problems (durability, retries, concurrency) are solved by a managed workflow platform rather than application code.

Observable Failure Modes

• Inngest Cloud dependency: Free tier has limits; cost scales with usage; no self-hosted Inngest option mentioned in Utah's docs
• Slack/Telegram only: No web chat UI, no email, no other channels without adding them
• No TDD, no spec workflow: Purely reactive conversational agent — not a coding workflow tool
• 116 stars: Minimal community; reference project more than production harness
• Node.js 23+ requirement: Native TypeScript strip-types requires Node 23; not compatible with older Node versions
• No approval gates: Fully autonomous — bash tool runs commands without confirmation
• pi-ai dependency: Relies on @mariozechner/pi-ai and @mariozechner/pi-coding-agent — third-party libraries with unclear maintenance guarantees