Durable execution with Temporal-Light
Temporal-Light is a lightweight, self-hosted workflow engine for Python programs that
need to outlive process failures: long-running agents, scheduled work, workflows that
wait for external signals, and work that fans out before joining again. Developers write
ordinary async Python functions and decorate workflows and activities; a small FastAPI
service starts runs, accepts signals, and streams their progress to a live dashboard.
Postgres is the durable source of truth. Instead of serialising a live coroutine, a
worker reconstructs the workflow and replays its append-only event history: completed
activities return their recorded result and execution resumes at the first unfinished
step. Lease-based worker coordination prevents concurrent execution and lets another
worker recover expired work. The implementation deliberately favours a compact,
inspectable control plane over feature parity with established workflow platforms.
Evidence-gated coding runtime
Built on Temporal-Light as a real stress test for durable orchestration, this runtime
turns a natural-language coding task into a reviewed repository change. It first creates
a task contract, prepares an isolated workspace, and gathers repository context. For a
bug fix or feature with a reproducible behaviour, it can create a failing anchor test and
establish the failure before planning the implementation.
The agent does not simply narrate progress. It proposes one concrete next step at a time,
runs implementation candidates in bounded tool loops, and refreshes the diff, command
output, exit codes, test results, and review verdict after each step. Those observed
artifacts determine whether work advances, is replanned, or is rejected. The repository
includes a live-worker smoke workflow and SWE-Bench Light support, but it is presented as
a durable coding-runtime prototype rather than a benchmark submission.
Independent voice-first story narrator
This is a separate, voice-first AI game master for tabletop-style roleplay, not a client
of Temporal-Light. A React client talks to a FastAPI application that routes each player
message to one of five independently deployable agents: character creation, campaign
design, game mastering, NPC dialogue, and memory. The agents communicate through the
Google Agent-to-Agent protocol, so responsibilities remain service boundaries rather
than one large prompt or process.
Four MCP servers expose campaign state, semantic memory, world knowledge, and media.
PostgreSQL stores relational state, Qdrant retrieves relevant past events, and Neo4j
maintains the campaign knowledge graph; campaign scoping is applied at the tool-service
boundary. Typed events stream text, speech, and images back to the browser through SSE,
while LLM, image, speech-recognition, and speech-synthesis providers sit behind
replaceable service adapters. The result is an interactive product built to make
multi-agent coordination, memory, and media delivery observable end to end.