Dynamic AI Agent
Orchestration Platform.
Nova dynamically generates, executes, and coordinates AI agents. MicroVM-level isolation, stateful context, and multi-layer network security—built for modern, safe engineering.
Engineered for Absolute Security.
A resilient, stateful, and defense-in-depth foundation for running autonomous code agents in production.
Dynamic & MicroVM-Isolated Execution
On-demand agent creation via Kubernetes Jobs. Each AI agent runs inside a dedicated MicroVM powered by Kata Containers and Cloud Hypervisor (nested virtualization). This provides uncompromising hardware-level boundary protection, ensuring absolute workload isolation and security from the host OS and other running pods.
Stateful Checkpoints with Resume & Fork
Every agent turn creates a checkpoint persisted to GCS. From any checkpoint, you can Resume to continue where the agent left off, or Fork to branch into a parallel execution path—like git for agent state. All commits are signed and submitted via Pull Requests; agents never push directly to main.
3-Layer Network Defense
Defense-in-depth with three distinct security layers. Network Policy controls L3/L4 pod-to-pod traffic. FQDN Policy restricts external egress to allowlisted domains only. Authorization Policy enforces L7 request-level access control per service identity.
Separately, Istio's ExtProc (External Processing) filter dynamically injects short-lived credentials at the mesh layer—agents never hold long-lived tokens directly.
Fine-Grained Authorization
Powered by OpenFGA with Terraform-managed hierarchy. Permissions inherit through a folder tree (folder:root → folder:nova → folder:playground), so granting access at any level cascades down to all child resources.
resource "openfga_relationship_tuple" {
user = "user:yanolab@mercari.com"
relation = "owner"
object = "folder:playground"
}
resource "openfga_relationship_tuple" {
user = "service_account:claude-agent@..."
relation = "owner"
object = "permission:spawn-agent"
}
Multi-Agent Orchestration by Agent Chaining
An agent analyzes the task context—such as a new GitHub Issue—and autonomously decides which specialized agents to spawn through Agent Chaining. Each spawned agent completes its work, and its output (e.g., a PR) triggers the next agent via GitHub Webhooks. The result is an adaptive, branching workflow that scales from simple fixes to complex multi-agent engineering pipelines.
Knowledge Graph RAG
Agents query a LightRAG-powered Knowledge Graph built from GitHub Issues, Pull Requests, and documentation. Before writing code, agents understand past decisions, related implementations, and design rationale—enabling context-aware choices instead of starting from scratch every time.
Event-Driven Agent Workflows
External events from GitHub, Linear, and Agent lifecycle automatically trigger new agent jobs. Build sophisticated automation pipelines: a merged PR kicks off a documentation agent, a new Issue spawns a triage agent, or an agent's own completion triggers the next stage. Combine these primitives to create self-learning evolution workflows and Agent Experience Scoring—agents that improve themselves based on review feedback and outcome metrics.
Project Shared Memory
Every agent in a project reads from and writes to a shared memory layer persisted across sessions. Coding conventions, past mistakes, architectural decisions, and team preferences accumulate over time—so agents learn from each other. Teams collectively nurture and evolve their agents simply by working with them, building institutional knowledge that every future agent inherits.
Nova CLI — Universal Integration Interface
The nova CLI turns the platform into a composable building block. Call it from CI/CD pipelines, cron jobs, Slack bots, or any system that can run a shell command. And because agents themselves have access to the CLI, Nova can call Nova—agents autonomously spawn, coordinate, and communicate with each other through the same interface humans use.
nova run -p myproject \
"Tests failed: fix $ERROR"
# Slack bot: on-demand agents
nova run -p myproject \
"$SLACK_MESSAGE"
# Cron: scheduled audits
nova run --preset Auditor \
"Review open PRs for staleness"
nova run -p myproject \
"Implement the API from design.md"
# Agent A sends follow-up
nova prompt $CHILD_ID \
"Add rate limiting middleware"
# Agent A checks result
nova job get $CHILD_ID
Built-in Developer Tooling
Agents come pre-equipped with a full development environment for real-world engineering tasks.
Browser-based VS Code via per-instance HTTPRoute. Live debugging, terminal access, and file editing directly inside running agent pods.
Dependency repositories are automatically cloned alongside the target repo. Agents browse upstream source, trace APIs across repos, and understand cross-service contracts.
mise, gh CLI, jq, pytest, Playwright—ready out of the box. Agents run tests, capture screenshots, and interact with CI/CD without setup overhead.
Two-Layer Architecture.
Separation of concerns between infrastructure orchestration and secure multi-step LLM execution.