Night Owls reference

The engine core: define agents, skills, tools and swarms, then run them, the @mastra-backed brain behind every Night Owls host.

The @mastra-free decision-hook substrate: the plain types and dispatcher the platform's billing, approval, and mutation gates hang off.

The default engine as a named package, a mastraEngine() factory + MastraEngine re-export; installing it changes imports, not behavior.

The second native engine, a governed ai@^7 streamText loop. Single-agent v1 (no delegation/workflows/semantic recall yet), full HITL + governance, tier-3 events.

The A2A (Agent2Agent) protocol adapter engine, renders any A2A v0.3-wire endpoint (Bedrock AgentCore, Azure AI Foundry/Copilot Studio, Google ADK/Vertex Agent Engine) as a single Night Owls agent. Adapter tier: reduced governance, tier-1 events (opaque remote, no tool visibility).

The third native engine, a governed @openai/agents run() loop with full governance (fail-closed tool gate, cost caps, secrets), native handoffs/guardrails. Single-agent v1 (multi-agent handoffs planned v1.1).

An adapter for ONE specific case: you already run a Trigger.dev `chat.agent` Session on your own account and want to front it as a Night Owls agent. It's an adapter (reduced governance, tier-2 events), and experimental (Trigger's `chat.agent` surface only just GA'd — verify it's reachable in your account first). For the usual durable + governed run, use `@nightowlsdev/runner-background` with a native engine instead — that's the first-class durable path.

The Vercel Eve protocol adapter engine, renders a running Eve app's NDJSON session as a single Night Owls agent. Adapter tier: reduced governance, tier-2 events (tool calls + usage visible, no delegation); durable park/resume on Vercel Workflows.

Drop-in React + Tailwind chat UI for Night Owls swarms, plus a fully headless hooks layer that renders live run state.

Framework-agnostic design tokens and theme presets for the Night Owls chat/agent UI.

The shared app-chrome kit for Night Owls surfaces: full-page layout (Container/Section), site chrome (NavBar/Footer), primitives (Button/Card/Badge), and a light/dark ThemeProvider.

The React workbench for the knowledge-graph plane: search, a force-directed canvas, entity pages, the bi-temporal timeline, and the review queue, with no CSS build step and no d3.

The pluggable `owl` CLI: scaffold a Night Owls project, install adapters, and contribute their migrations, without ever running DDL.

Connect external MCP servers as Night Owls tools, approval-gated, output-fenced, and engine-wall-safe.

Declare an external service's actions once, materialize them into approval-gated, output-fenced tools, plus event triggers and out-of-band human-in-the-loop over Slack/email.

Browse, import, and refresh external skills (skills.sh, GitHub, https) into storage-backed, versioned, grantable instruction-only skills, third-party guidance, safely fenced.

The fully-open DEFAULT IntegrationProvider backend, self-run OAuth, an authed auto-refreshing proxy, provider-direct webhooks, and a minimal poller, with credentials on your own infrastructure (no vendor catalog, no Nango).

The Composio IntegrationProvider backend, the first catalog-owning connector backend: 1000+ apps' tools and triggers come from Composio, which also runs the tool and holds the credentials.

Expose a Night Owls swarm AS an MCP server, ask-only `ask_<agent>` tools, no workflow execution.

Anthropic Claude model provider for Night Owls swarms, backed by the native AI SDK.

OpenAI model provider for Night Owls swarms, backed by the native AI SDK.

Any model via OpenRouter for Night Owls swarms, using `provider/model` ids.

Any model via the Vercel AI Gateway for Night Owls swarms, one key, all providers.

Run Night Owls swarms on local models via Ollama, no API key, no per-token cost.

Run Night Owls swarms on Groq's fast OpenAI-compatible inference, one API key.

A local LibSQL-backed Mastra snapshot store for the CLI bootstrap runtime, run a swarm on just a model key, before Supabase.

A Supabase/Postgres-backed StorageAdapter for Night Owls, agents, runs, events, messages, a Realtime event bus, a versioned agent repo, and a durable Mastra store.

An optional pgvector document knowledge base, RAG over arbitrary documents (guides, brand voice, reference docs), plus a ready tenant-scoped `search_knowledge` tool.

A bi-temporal, provenance-anchored knowledge graph plane, push any source in and get resolved entities and relations that remember when a fact was true, when you believed it, and who told you.

A dimensionless, org-scoped metric-series store, `(orgId, orgScope, metric, at, dims) → value` with calendar bucketing and a fully-pinned period-over-period `compare()`, the honest home for numbers that change over time.

A separate, opt-in task-manager plane — an org- and scope-scoped board of human- and agent-assigned WORK — plus the guardrails to run an agent against a task unattended: a resume-safe cumulative cost ceiling, a single-winner start, and a prompt-injection fence.

A separate, opt-in pipeline plane — a data-driven, fan-out-capable structured-extraction DAG whose stages can be executed by a NAMED, GOVERNED swarm agent (cost cap + tool gate + rules + metering), not just a raw LLM prompt.

The durable runner for Night Owls, runs a swarm turn in Trigger.dev v4 or Vercel Workflow so an ask-suspended run can park for days and resume across process death.

The interactive runner for Night Owls, Next.js App Router routes that authenticate server-side and stream a swarm run to the browser as an AI SDK v7 UI Message Stream.

Shared SwarmSpan-to-OpenTelemetry replay engine that the OTLP and Langfuse telemetry adapters are built on.

Langfuse v5 (OTel-native) telemetry exporter for @nightowlsdev/core swarm runs.

OTLP/HTTP telemetry exporter for @nightowlsdev/core that ships swarm traces to any OpenTelemetry-compatible backend.

Stateless Supabase AuthProvider that maps an already-verified Supabase session into a Night Owls AuthContext.

Stateless, offline-capable Auth0 AuthProvider that verifies access tokens against Auth0's public JWKS.

Dependency-free JWT primitives (HS256 sign/verify + ES256/RS256 JWKS verify) and signed-session helpers, on node:crypto only.

A small, pg-backed revocable session store, logout, log-out-everywhere, and admin kill without shortening JWT TTLs.

The scoring plane, run an agent over a fixture dataset, score each run's event trajectory, aggregate into a per-version EvalReport.

A reflective, metric-gated prompt optimizer, reflect on eval feedback to propose better persona fields, keep the best.

The shared foundation for the pre-built agent family: curated skills.sh manifests + governed batch import, fail-loud tool contracts, progressive-disclosure skill-library tools, and persisted-store lifecycle helpers.

The meta-agent that knows the nightowls agent anatomy end to end: researches external skills, drafts + validates agents/bundles, and, behind a rule-enforced human-approval floor, imports skills and publishes definitions.

Deep research with a fail-loud tool contract: plans sub-questions with stop criteria, searches broad-then-narrow, triages sources primary-first, gap-checks, and delivers a cited synthesis.

Product-in-market analysis, positioning + ICP, evidence-based competitor profiling, channels as prioritized bets, that asks for what it lacks instead of inventing it.

Design directions you choose from: proposes 2-3 named approaches via the ask tool, then applies the chosen one from an 18-skill curated design library read on demand, impeccable, ui-ux-pro-max, the taste-skill family.

Content + copy craft, tool-less by design: brief-first, on-voice, channel-native, and fabrication-free (a missing fact becomes a [placeholder: …] the human fills, never a plausible invention).

The pre-built SEO crew: a read-only, fail-closed `seo-analyst` and a competitor/SERP `seo-researcher` over the Google Search Console + GA4 connectors, with measurement honesty encoded, not just documented.

The pre-built diagnostics crew: a read-only run `inspector` and an approval-gated `bug-reporter`, so a stalled lane and a vague apology become which call failed, whether it recovered, and a report a developer can act on.