NKAI-SOLO // Control Plane

Dispatcher &
Architect.

### Automating Production-Grade Software Engineering
NKAI-Solo is an autonomous AI agent designed for engineering teams. Unlike basic coding assistants, it acts as a full-fledged Tech Lead and Developer pair. Give it a bug report or a feature request, and NKAI-Solo will independently research the codebase, design a system architecture, break down the work into JSON-structured micro-tasks, and execute the code changes. By handling the end-to-end lifecycle—from GitHub issues to Linear tickets to final Pull Requests—NKAI-Solo allows engineering teams to ship faster, reduce manual code reviews, and scale their development operations autonomously.

> The Routing & Cognitive Architecture layer behind Webhook Gateway.

Two core AI agents that analyze, plan, and execute your tasks — transparent, observable, no more soulless loading spinners.

GitHub
Coming soon
control-plane:~ONLINE
nk-dispatcher
STANDBY
nk-architect
STANDBY
SDE Agent
STANDBY
Linter
STANDBY
# Run demo below to activate agentsv1.0.0
// Platform

NGUYEN KHAI TECH COMPANY LIMITED is building an AI Agent Platform for engineering teams — autonomous agents that eliminate toil by connecting monitoring systems, AI diagnostics, and issue trackers into a single, self-operating loop. Webhook Gateway is our first open-source product.

Control Plane in Action

Select a task type and press Run to watch the agents process it in real time.

Gateway
Dispatch
Architect
SDE
Lint
Task:
Agent_01

nk-dispatcher

The cognitive gatekeeper. Ultra-fast analysis (<2s) to classify task complexity and decide the routing path: straight to SDE or up to Architect.

Case A

Fast-Track

Task is Context-Complete: the user has attached a specific file path — no Architect analysis needed.

# Decision flags
bypass_architect = true
→ Direct to SDE Agent
E.g. "src/Button.tsx — change primary color to #FF0000"
Case B

Deep Analysis

Task is Context-Missing: a problem is described but without specific file context. Architect must survey the codebase first.

# Decision flags
require_planning = true
→ Forward to nk-architect
E.g. "Fix broken payment checkout"
Agent_02

nk-architect

The architect brain. Writes no code. Uses RAG to survey the project, reason about root causes, produce a detailed sub-task plan, then delegates to SDE Agent for execution.

// Reasoning Terminal
nk-architect:~STANDBY
# Waiting for task from nk-dispatcher…
# Run demo above to see live reasoning stream.
// Sub-task Plan
Generated Sub-tasksempty
# Sub-tasks will appear here after Architect planning phase.
Approval Gate

nk-architect will pause after planning and wait for your approval before handing off to SDE.

// Knowledge Plane

Analyzer & Indexer.

Unlike Dispatcher and Architect (which run per-task), these two components run as background jobs — triggered on project onboarding or on a Git push to the main branch. Their UI lives in the Knowledge Base / Repository Settings area, not in the task pipeline.

Triggers:Project onboarding (first connect)Webhook / Git push to mainManual [Force Re-Index]
Agent_03
Background Job // Onboarding & Major Updates

nk-analyzer

The translation engine. Reads raw source code and distills it into structured Business Logic Markdown — call graphs, entry-point docs, flow summaries — stored in .nk-docs/business_logic/.

Step_01

Repository Scan

Traverses the directory tree. Identifies API routes, controllers, and service entry points. Builds a dependency graph.

Step_02

Context Distillation

Groups related code clusters. Sends each cluster to LLM to summarize business flow in plain English. Strips implementation noise.

Step_03

Doc Generation

Persists structured .md files per module. Output feeds directly into nk-indexer for embedding.

// Logic Distillation Split-View
LIVE PREVIEW
nk-analyzer:~ distill CheckoutService.ts
Raw Sourcesrc/checkout/CheckoutService.ts
export class CheckoutService {
  constructor(
    private stripe: StripeClient,
    private db: DatabaseService,
    private events: EventBus,
  ) {}

  async processPayment(
    cartId: string,
    paymentMethodId: string,
  ) {
    const cart = await this.db
      .carts.findById(cartId);
    const intent = await
      this.stripe.confirmPayment({
        amount: cart.total,
        currency: 'usd',
        payment_method: paymentMethodId,
      });
    await this.events.emit(
      'payment.completed', intent);
    return intent;
  }
}
Business Logic.nk-docs/business_logic/checkout.md
# CheckoutService
Purpose: Orchestrates the end-to-end payment flow — from cart retrieval to Stripe charge confirmation.
Entry point: processPayment(cartId, paymentMethodId)
Dependencies: StripeClient, DatabaseService, EventBus
Side effects: Emits payment.completed event on success.
⚠ No error handling for Stripe failures detected.
Agent_04
Background Job // Git Push Webhook

nk-indexer

The warehouse. Receives raw code and .md docs from nk-analyzer, splits them via AST chunking, vectorizes via Vertex AI text-embedding, and pumps everything into AlloyDB/pgvector for nk-architect to search at millisecond speed.

// Ingestion Dashboard
nk-indexer:~ statsSYNCED
Total Files Scanned1,847
Vector Chunks Generated24,391
Embedding Token Usage3.2M tokens
Last Sync2 min ago
Vector DBAlloyDB / pgvector
// Real-time Sync Activity
Git Push detected — branch: main● INDEXING
src/payment/stripe.ts100%
src/checkout/CheckoutService.ts75%
src/api/webhook.ts30%
nk-indexer:~#
// Sync Health Status
🟢
In Sync
Up to date
🟡
Indexing
Background job running
🔴
Sync Failed
Fix required
⚠ Dispatcher Warning

When nk-indexer is running (🟡 Indexing), any new Task sent through the Gateway will trigger a Dispatcher notice: "Knowledge Base is currently syncing. Architect's reasoning might not reflect the latest changes."