The landscape, honestly

Every claim on this site is cheaper to evaluate against what already exists. This page compares Supernova to its four nearest neighborhoods — autonomous coding agents, agent orchestration and durable execution, requirements traceability, and self-hosted automation with its caching economics — and for each one states what the incumbents do better. Most individual Supernova ideas exist somewhere in this landscape; the argument of this page is narrower than “nobody does this,” and it ends by saying exactly what remains.

Autonomous dev agents

Devin, OpenHands, SWE-agent, Factory’s Droids, Google Jules, and GitHub’s Copilot coding agent all take an issue, write code, run tests, and open a PR. Running tests and linters before claiming done is universal; LLM critic agents reviewing LLM output are common (Jules ships two critics, Factory a dedicated Reviewer Droid, Devin reviews its own PRs). Copilot’s coding agent has the strongest mainstream closure discipline: it respects branch protection, and the person who assigned the issue cannot approve the resulting PR.

What they broadly lack is a deterministic closure gate above CI. Closure means “checks green plus a human merged it” — the checks are generic (tests, lint, security scans), not traceability to requirements. The nearest existing primitive — Claude Code and Codex hooks, deterministic gates that can block an agent from claiming done until tests pass — is per-user configuration, not a platform invariant. The research literature on reward hacking (agents commenting out failing tests, hardcoding outputs, claiming unimplemented changes) is the strongest external argument that this gap matters. Supernova’s answer is described on the requirements page: a requirement cannot close while it has planned-only evidence, open TODOs pointing at it, or uncovered changed lines — and the validator enforcing that already gates Supernova’s own development, its one daily-exercised component. The surrounding issue and delivery machinery is [built in-repo].

The reverse is stark. Devin and Factory are production systems with enterprise customers; OpenHands is MIT-licensed with over 75k stars, hundreds of contributors, and a public benchmark suite (53–77% on SWE-bench Verified, depending on model and evaluation setup). Supernova has no external users, no benchmark results, and no UI beyond a CLI. The spec-driven wave — AWS Kiro, GitHub Spec Kit — is the closest commercial cousin of Supernova’s requirements-first story, and it ships today; its traceability is generated and human-reviewed rather than validator-enforced — which is the entire difference, and the only one.

Orchestration and durable execution

Temporal defines the durable-execution category, and Supernova does not compete with it — it composes it. Restate, Inngest, Hatchet, and DBOS are credible self-hostable alternatives; DBOS in particular has the best “no new infrastructure, no metered billing” story in the category. On the framework side, LangGraph is the most production-deployed agent orchestrator, and Microsoft’s Agent Framework 1.0 (April 2026) is the closest big-vendor analog for durable multi-agent workflows with human-in-the-loop.

Two observations from this neighborhood. First, the industry default is retry-first: Temporal retries by policy, Restate auto-retries transient errors, Inngest and Hatchet retry into dead-letter queues. Temporal’s Activity Pause (public preview) adds operator intervention as an escape hatch. Supernova inverts the default: park-on-failure — a failed durable step stays alive at zero compute, awaiting an explicit resume, with the failure filed as work (ratified 2026-06-10) — is the platform posture, not an ops tool [engineered, not deployed]. Second, the pieces combine pairwise everywhere but not three ways:

flowchart TD
    K["Kafka event bus"] ---|"Confluent: agents on Kafka"| A["Agent runtime"]
    A ---|"Temporal + OpenAI Agents SDK, GA 2026"| T["Temporal durable workflows"]
    T ---|"enterprise integration pattern"| K

Each edge of that triangle is shipped and evangelized by someone. A single opinionated product shipping all three vertices — Kafka bus, Temporal workflows, and a multi-agent runtime — as one self-hosted platform did not surface in any search; enterprises assemble it bespoke. The closest single-vendor bundle is Inngest — events plus durable steps plus an agent framework (AgentKit) — but its event system is proprietary rather than Kafka, and it is TypeScript-centric and cloud-first. Supernova’s version is [built in-repo], and it inherits the cost: Temporal is heavy (four server services — frontend, history, matching, worker — plus persistence plus an application worker fleet), its Rust SDK is only in public preview, and Supernova runs this with a team of approximately one.

Requirements traceability

The requirement→test→coverage join is not novel; it is mandatory, standard practice in avionics and automotive. DO-178C requires structural coverage achieved by requirements-based tests, and toolchains from Parasoft, LDRA, and VectorCAST automate the join against DOORS, Jama, or Polarion. In open source, StrictDoc validates source markers in CI, OpenFastTrace fails builds on broken trace chains, and sphinx-needs runs in automotive projects with over a thousand engineers. The single closest comparable is tracey: a Rust-built spec-coverage tool with CI-gating queries, an MCP server, and bundled Claude Code skills that teach agents its annotation syntax — concrete, shipped proof that “LLM agents maintaining trace annotations” exists outside Supernova.

What no single found system spans is the integration: one validator covering the requirement DAG, per-file specs, line-level annotation coverage of changed code, typed evidence kinds, coverage-report joins, and a decisions ledger whose entries carry verbatim operator provenance and formal supersession — with agents forbidden to close requirements without satisfied evidence as a platform rule rather than a reporting convention. ADR practice has had supersession and immutability since 2011; what ADR tooling lacks is the verbatim-provenance discipline and any machine linkage into a validator. The combination appears to be new. The ingredients are not, and a determined engineer could compose tracey, StrictDoc, and ADR tools into a decent approximation.

The reverse: the incumbents are proven at scales Supernova has never seen, and the certified toolchains carry qualification evidence regulators accept. Supernova’s stricter per-line rule is unproven outside one project, and strictness alone is not a moat.

Self-hosted automation and caching economics

Huginn promised “agents that monitor and act on your behalf” in 2013, a decade before LLMs; Supernova shares that ethos exactly and its mechanism not at all. n8n is the mature center of the self-hosted automation category, with first-class AI agent nodes and a local-inference kit; Windmill is the closest architectural cousin — Rust engine, self-hosted, durable jobs, first-class approval steps. None of them has a traceability layer, a decisions ledger, or a tiered approval policy engine; Windmill’s approval steps are per-step workflow constructs, where Supernova’s approval engine evaluates a closed, ordered risk enum (read < low < medium < high < critical) against trust policies, failing closed to human review [built in-repo].

On caching: the mechanism behind Supernova’s zygote fork is documented vendor behavior, not an invention. Anthropic prices cache reads at 0.10x input and refreshes the TTL free on every read — the load-bearing fact for keeping a warm parent alive. Claude Code ships fork subagents (currently opt-in) that reuse the parent’s cached prefix; SGLang’s RadixAttention has a native fork() primitive; Anthropic themselves document deliberate pre-warming. What did not surface anywhere is a persistent, platform-managed, fleet-wide warm parent from which heterogeneous agents fork on demand, integrated with the approval and traceability machinery — an integration novelty, no more, and [built in-repo] with a cold-boot fallback for when the cache assumption fails. The irony is noted in Supernova’s own research: the cleanest version of the pattern on truly owned hardware is a local vLLM or SGLang stack with no TTL and no metered pricing at all.

Synthesis

The sober version: almost every piece exists somewhere. The uncommon thing is the specific combination — a machine-checked requirements-to-code-to-evidence spine, decision case-law with verbatim provenance, an owned-hardware event and workflow substrate, and cache-fork agent economics — held together in one self-consistent personal platform, with the traceability spine already governing the platform’s own construction. That combination is unproven at scale, and this page is the record of what it is being measured against.

What this costs

The comparison cuts both ways. The composability threat is real: tracey plus StrictDoc plus Temporal plus Claude Code hooks approximates a large fraction of Supernova’s story using maintained tools with communities behind them, and that fraction grows every quarter — spec-driven development went from niche to AWS-and-GitHub mainstream in about a year. The zygote economics rent a provider’s cache behavior: exact-prefix brittleness means a changed tool definition cold-starts the fleet, and TTL regressions have been observed in the wild. The three-layer substrate is enterprise kit operated at personal scale, which is either the point or the problem depending on the week. And every system named above has users finding its bugs; Supernova has one, finding them serially.