Protected by JAK ShieldBeta 0.1.0-beta.0· Closed-loop company operating layer

Turn company contextinto approvedagent work.

JAK captures evidence from docs, tickets, code, meetings, and customer feedback; maps decisions, tasks, risks, owners, deadlines, and code changes; detects execution drift; generates specs; then routes work through specialist agents with permissions, approvals, sandboxing, risk scoring, defensive security review, and tamper-evident audit trails.

Company BrainHyperagentJAK ShieldApprovalsAudit Trail

Start 30-Day Free Trial

JAK Swarm Repo JAK Shield Repo

Open-source repos: JAK Swarm (control plane) + JAK Shield (trust layer)

Controlled beta · free for 30 days · daily caps to protect your budget · no credit card required

Engine 01

Company Brain

evidencesource-labeled artifacts + graph entities
driftdeterministic comparator flags the gap
specagent-executable, reviewer-approved

Cited evidence graph. Multi-signal lexical + graph retrieval — no vector/embedding component.

Explore Company Braincompany-operating-layer.service.ts

Engine 02

Hyperagent

repairclassify failure → counterfactual → symbolic re-plan
learnSHADOW → CANARY → PROMOTED, human-gated

Self-healing re-plan loop + governed self-learning. Integration-proven and default-off — not production-proven.

Explore Hyperagentspec-executor.ts (pure core)

Two engines — one closed loop. Explore each below.

Engine 01 · Company Brain

The cited evidence graph that grounds every agent action.

JAK’s first engine turns scattered company context into a tenant-scoped graph of artifacts, entities, and typed claims — then detects execution drift and generates reviewer-approved specs. Citation-first, not chatbot memory. Retrieval is multi-signal lexical + graph (alias, stable-identifier ILIKE, ts_rank FTS, 1-hop graph expansion); there is no vector/embedding component.

Open the Company Brain/company · /company/graph · brain_* MCP tools

Evidence graph

Evidence first, not chatbot memory.

JAK stores source-labeled artifacts from docs, tickets, code, meetings, customer calls, support, Slack, Notion, GitHub, Gmail, or manual notes. GitHub, Gmail, and Google Drive auto-sync on a 5-minute schedule; the other sources ingest on-demand or by manual upload. JAK then extracts decisions, tasks, risks, owners, deadlines, customer signals, and code changes with citations.

Artifacts are tenant-scoped and body-hashed
Entities cite the artifacts they came from
Connector sync is setup-dependent; manual evidence already works

Evidence: /company/artifacts + /company/entities

Execution drift

Compare what is happening with what should happen.

The alignment engine looks for customer pain without matching work, decisions that never became tasks, execution that has no supporting decision, and stale high-priority tasks. It is a deterministic comparator, not a vague LLM opinion.

Flags unaddressed customer signals
Finds decisions that were not operationalized
Marks ungrounded execution and stale work

Evidence: buildDriftCandidates()

Agent-executable specs

Turn drift into approved work.

When drift is found, JAK generates an agent-executable spec with objective, scope, acceptance criteria, test plan, agent task plan, approval gates, and cited evidence. A reviewer approves or rejects it before the team treats it as executable.

No template fallback for spec generation
Acceptance criteria and test plans are explicit
Reviewer approval is a real backend decision route

Evidence: /company/specs/generate + decide

Blunt beta truth: JAK has the Company Brain data model, API routes, dashboard surface, deterministic drift detector, agent spec generator, approval decision route, and audit foundation. It still needs deeper connector auto-sync before it should claim full company-wide OS coverage — today only GitHub, Gmail, and Google Drive auto-sync.

Engine 02 · Hyperagent

The self-healing layer that repairs failed work and learns — carefully.

JAK’s second engine sits on top of the 38-agent runtime. It does two things: repair execution that the Verifier rejected (beyond a bounded retry), and promote only measured, human-approved improvements to autonomy policy. It is integration-proven and default-off— not production-proven. We say that plainly because burying it would be the opposite of why it exists.

Open the Hyperagent Control Centrepackages/swarm/src/hyperagent/

Self-healing re-plan loop

Repair failed execution, not just retry it.

When the Verifier rejects output and the bounded-retry budget is exhausted, the Hyperagent classifies the failure with a deterministic 20-class classifier, runs a counterfactual fault isolation, hands a symbolic replanner a proposed new plan (an LLM may propose, only the symbolic layer may apply), and selectively re-executes under an autonomy gate. Destructive, permission, and approval-timeout failures are never auto-retried.

Deterministic 20-class failure classifier
Symbolic replanner — LLM proposes, symbolic layer applies
Autonomy-gated selective re-execution

Evidence: spec-executor.ts (pure core)

Governed self-learning

Promote improvements only with evidence + a human.

A config-lifecycle gate (DRAFT → PROPOSED → SHADOW → CANARY ramp → PROMOTED, human-operated, no skip) wraps any autonomy-policy or repair-budget change. Promotion requires a measured mutual-information learning signal and a human TENANT_ADMIN approval. The agent may not self-promote; a safety-incident breach triggers automatic rollback.

SHADOW → CANARY → PROMOTED, no skip
Measured MI signal required before promotion
Human TENANT_ADMIN promotes; agent cannot

Evidence: ConfigLifecycleService (live caller)

Wired vs. pure-core — what is actually live today

Pure-core spec executor

Shipped

Harvests artifacts with provenance; classifies failures; replans. Integration-proven with a deterministic stub runPlan.

Live runtime seam

Open edge

spec-executor-runtime.ts returns artifacts: [] and failureClassByTask is not yet wired into FinishedRun. Integration-graph-proven, not production-proven.

executeApprovedSpec closed loop

Env-blocked

REVIEWER-gated API route + service exist; the live LangGraph + LLM round-trip is env-blocked.

ShieldMcpClient (Ed25519)

Observational canary

Live behind SHIELD_MCP_CANARY=1 — records signed decisions to the audit chain, does NOT gate execution.

Self-learning in live graph

Default-off

Wired behind hyperAgentEnabled (default false). Default workflows are byte-for-byte unchanged unless a tenant opts in.

Blunt beta truth: the Hyperagent self-healing core is integration-proven, but the live runtime seam still returns empty artifacts until it is wired, and the self-learning canary has not run against managed Postgres + a real LLM. Wiring that seam is the next code change that makes this engine honestly live. The full breakdown is in docs/hyperagent-current-state-audit.md and the canary runbook in docs/production-canary-plan.md.

How It Works

Seven steps from intent to delivered work.

Every JAK workflow runs the same pipeline. You see every step. You gate every risky one. You can replay every run.

1
Command
You type a task in plain English. No syntax, no flags, no special prompt format.
commander.parses(intent)
2
Plan
JAK breaks the task into ordered steps you can review before anything runs.
planner.decompose() → 4 steps
3
Route
Each step goes to the right specialist agent — research, content, code, ops, design.
router.assign(task → CMO / CTO / Research)
4
Execute
Specialists run with your connected tools — Gmail, Slack, GitHub, Notion, the browser.
worker.run() · live in cockpit
5
Approve
Anything risky pauses for you. Inline card shows tool, payload, files, expected result.
approval.gate(payload-bound)
6
Verify
JAK checks the work — citations, tone, safety, hallucination, payload integrity.
verifier.check() · 4-layer
7
Deliver
Final output, signed audit trail, replayable run. Ready to ship — or reuse next time.
output.deliver() · audit.signed

The Cockpit

Every workflow, one operating surface.

Your command on the left. The agent graph in the middle. The approval card and the result on the right. The audit on the bottom. One place to run, gate, and prove the work.

JAK Cockpit · /workspace

awaiting approval

Your command

Compare customer feedback with this sprint and generate the execution spec

sent 12s ago · workflow #847

Recent runs

Customer signal drift · 3 findings
Onboarding spec · approved
Evidence pack · exported

Agent graph · live

4/5 done · 1 running

Commander

Company Brain

Signals

Sprint

Drift

Verifier

done running queued

Approval required

toolagent_spec_approvalpayloadspec + test planreplay-safepayload-bound ✓

Spec preview · acceptance criteria

“Objective: reduce onboarding drop-off. Evidence: customer calls and GitHub issues. Acceptance criteria: guided import, empty-state copy, Playwright regression, rollout approval…”

Audit timeline · run #847

HMAC-SHA256 · every step replayable

00:00Workflow #847 started
00:02Evidence artifacts loaded
00:05Customer signals extracted
00:08Sprint work compared
00:12Drift finding · high
—Spec approval · awaiting

What JAK actually ships

Evidence-backed artifacts, not chat output.

Every workflow should end in something concrete: a drift brief, an execution spec, a QA report, or an audit pack. Approval-gated where it matters, signed where it’s required, reversible where it’s risky.

Execution drift brief

Compares customer signals, decisions, tasks, specs, and code-change evidence, then explains where execution is drifting from intent.

customer_signal_unaddresseddecision_not_operationalizedungrounded_execution

·Onboarding pain lacks matching sprint work [evidence: call_6, issue_14]
·Founder decision has no task owner [evidence: note_3]
·Recent code change lacks a cited spec [evidence: commit_9]

Deterministic driftCited artifacts

Agent-executable product spec

Turns a drift finding or selected entities into a spec with objective, acceptance criteria, test plan, agent task plan, approval gates, and evidence citations.

“Fix onboarding activation gap with guided import, empty-state copy, and regression coverage.”

[1] Acceptance criteria: 4
[2] Playwright test plan: required
[3] Approval gates: product owner + rollout

Agent-generatedReviewer decision route

Browser QA + source-linked fixes

Uses browser automation to inspect pages, capture evidence, and report issues with source-file pointers or sandbox-only fixes when the repo is available.

[1]apps/web/.../page.tsx · hero CTA contrast
[2]components/Pricing.tsx · mobile tap target
[3]app/layout.tsx · meta description < 50 chars
+ screenshot evidence · sandbox-only until you approve

Source-file pointersSandbox-only edits

Audit-ready evidence pack

Every workflow step can land in a tamper-evident audit log. When an enterprise asks, JAK exports a HMAC-SHA256-signed evidence bundle that verifies byte-for-byte. Compliance controls are seeded; not all are automatically evidenced.

Bundle verified

runs847, 846, 845controls108 operational · 74 attestationsignaturehmac:7a4c…f0d2 ✓

HMAC-SHA256 signedReplay-safe approval

Why this matters

Scattered context creates drift. JAK closes the loop.

The goal is not another dashboard or another chatbot. The goal is an evidence-backed execution layer that knows what the company meant, what the team is doing, and what needs approval before agents act.

Company context is scattered

Meetings, tickets, GitHub, Slack, Notion, support, emails, and customer calls all hold different pieces of the truth. AI cannot reason well when the evidence is fragmented.

How JAK fixes it

JAK starts with source-labeled artifacts and graph entities, so agents work from cited company evidence instead of vibes.

Teams drift from customer intent

Roadmaps often say one thing, customer pain says another, and code activity can quietly move in a third direction. That gap is where teams waste sprints.

How JAK fixes it

JAK compares signals, decisions, tasks, specs, and code-change evidence, then flags drift before it becomes expensive.

Agents need a trust boundary

A system that can create specs, touch code, send messages, or operate tools must show evidence, ask approval, and leave a record.

How JAK fixes it

JAK Shield puts risky tool calls behind permissions, approvals, sandboxing, risk scoring, defensive review, and tamper-evident audit trails.

Trust Layer

Built for controlled autonomy.

Six guarantees — enforced, config-dependent, or observational — each backed by a code path reviewers can grep.

Human approval gates

Every approval-classified action — writes, sends, posts, deploys, charges — pauses for an inline approval card. Replays with a different payload are rejected.

approval-node.ts · payload-bound

Source-grounded outputs

Research-class agents must cite. The verifier flags any claim under the citation-density threshold before delivery.

verifier.agent.ts · density ≥ 0.7

Tool maturity labels

Every tool carries an honest CI-enforced label: real, heuristic, llm_passthrough, config_dependent, or experimental. No tool ships unlabeled.

check:truth · 122 / 0 unclassified

Tamper-evident audit trail

Every workflow run, every approval decision, every external action emits an audit log row. Final evidence packs are HMAC-SHA256 signed when an evidence signing key is configured.

audit-log plugin · bundle.service.ts

Self-hostable open-source core

JAK is MIT-licensed. Run it on your laptop, your VPS, or your cluster. Hosted ops are a convenience, not a lock-in.

github.com/inbharatai/jak-swarm · MIT

Agent-first runtime

JAK routes all work through specialist agents with structured orchestration, tier-based model routing, and strict output validation. No template fallbacks — every spec is generated from evidence.

agent-runtime.ts · provider-router.ts

JAK Shield

AI agents are powerful. JAK Shield makes them safe.

Before an agent touches your code, browser, files, email, GitHub, or business tools, JAK Shield checks permissions, scores risk, blocks unsafe actions, asks for approval where needed, and records every step in a tamper-evident evidence bundle.

Agent Firewall

Detects prompt-injection attacks and offensive-cyber requests (malware, exploits, credential theft, unauthorized scanning, phishing) BEFORE the LLM sees them. Defensive security work — audit my repo, harden auth, find CVEs — passes through.

packages/security/src/guardrails/offensive-cyber-detector.ts

Risk-Based Approvals

Every tool call is classified across 6 risk tiers — READ_ONLY through CRITICAL_MANUAL_ONLY. Risky calls pause the workflow. Approval is bound to the exact payload via a SHA-256 hash; replays with modified payloads are rejected with HTTP 409.

packages/tools/src/registry/approval-policy.ts

Secure Tool Permissions

Per-tenant tool registry + industry-pack restrictions + Standing Orders (allowed-tools whitelist + blocked-actions list + budget cap + expiry). REVIEWER+ role required to install or run anything destructive.

packages/tools/src/registry/tenant-tool-registry.ts

Sandboxed Execution

Browser sessions in per-tenant data dirs (500 MB quota), URL allowlist with cloud-metadata + RFC1918 + IPv6 link-local blocked, DNS-rebinding defense on every navigation, downloads disabled. Installer runs in a sandboxed subprocess with literal argv (never shell:true), 60s timeout, stripped env.

packages/tools/src/browser-operator/playwright-browser-operator.ts

Defensive Vulnerability Triage

JAK Shield supports defensive security work — repo audits, dependency scans, secret-leak detection, patch recommendations. Offensive work (writing exploits, generating malware, phishing kits) is blocked at the boundary.

docs/jak-shield-manifest.md

Audit Evidence Layer

Every workflow lifecycle event lands in AuditLog. AgentTrace fields are PII-redacted at write time. workflows.{goal,error,finalOutput,planJson,stateJson} are AES-256-GCM encrypted at rest. Final evidence bundles are HMAC-SHA256 signed and verify byte-for-byte.

apps/api/src/services/bundle.service.ts

Safety boundary

JAK Shield is built for defensive security, safe automation, permissioned workflows, and audit-ready agent execution. It does not support offensive hacking, malware generation, credential theft, phishing, unauthorized scanning, or exploit generation. Defensive work is allowed. Offensive work is refused.

When you need audit-grade

Enterprise-grade auditability when you need it.

You don’t need to think about SOC 2 on day one. Every workflow JAK runs is already tamper-evident, signed, and replayable — so when an enterprise customer asks, the evidence is already there.

63SOC 2 Type 237HIPAA Security Rule82ISO/IEC 27001:2022

182 controls seeded across three frameworks — 108 are operationally backed (evidence pulled from system activity) and 74 require reviewer attestation. LLM-driven control testing, reviewer-gated workpaper PDFs, HMAC-signed final evidence packs.

Open Audit Workspace

Reviewer-gated workpaper PDFs — download blocked until approved
Final-pack signing refuses if any workpaper is unapproved (FinalPackGateError)
External Auditor Portal — invite-token-only, engagement-scoped, fully audited
HMAC-SHA256 evidence bundles verify byte-for-byte

Pricing

Transparent pricing. Open-source core.

Run JAK free on your own infrastructure, forever. Upgrade when you want hosted agent ops, higher limits, and SLA.

Free

$0forever

Run JAK on your own machine, forever.

200 credits / month
30 credits / day
5 core agents
1 vibe coding project
Bring-your-own API key
Community support

Start Free

Pro

$29/mo

Hosted agent runtime, managed execution, approvals built in.

3,000 credits / month
200 credits / day
All 38 specialist agents
5 vibe coding projects
Managed agent runtime (all models)
500 premium credits
Email support

Go Pro

Team

$99/mo

Higher limits and priority model access for teams.

15,000 credits / month
600 credits / day
All agents + custom skills
Unlimited projects
3,000 premium credits
Managed agent runtime
Priority support

Start Team

Enterprise

$249/mo

SSO, audit exports, and dedicated deployment.

50,000 credits / month
2,000 credits / day
15,000 premium credits
SSO + RBAC + audit logs
Custom integrations
Managed agent runtime
Dedicated support

Agents

122

Classified Tools

Connectors

MIT

Open Source

Turn scattered context
into controlled execution.

Start with the honest beta wedge: company evidence, drift detection, executable specs, approval gates, and audit trails. Open-source core. Self-hostable. Agent-first runtime.

Start 30-Day Trial

JAK Swarm Repo JAK Shield Repo

Free to start · No credit card · MIT licensed · Self-host or cloud

Turn company contextinto approvedagent work.

Company Brain

Hyperagent

The cited evidence graph that grounds every agent action.

Evidence first, not chatbot memory.

Compare what is happening with what should happen.

Turn drift into approved work.

The self-healing layer that repairs failed work and learns — carefully.

Repair failed execution, not just retry it.

Promote improvements only with evidence + a human.

Wired vs. pure-core — what is actually live today

Seven steps from intent to delivered work.

Every workflow, one operating surface.

Evidence-backed artifacts, not chat output.

Execution drift brief

Agent-executable product spec

Browser QA + source-linked fixes

Audit-ready evidence pack

Scattered context creates drift. JAK closes the loop.

Company context is scattered

Teams drift from customer intent

Agents need a trust boundary

Built for controlled autonomy.

Human approval gates

Source-grounded outputs

Tool maturity labels

Tamper-evident audit trail

Self-hostable open-source core

Agent-first runtime

AI agents are powerful. JAK Shield makes them safe.

Agent Firewall

Risk-Based Approvals

Secure Tool Permissions

Sandboxed Execution

Defensive Vulnerability Triage

Audit Evidence Layer

Enterprise-grade auditability when you need it.

Transparent pricing. Open-source core.

Free

Pro

Team

Enterprise

Turn scattered contextinto controlled execution.

The cited evidence graph that grounds every agent action.

Evidence first, not chatbot memory.

Compare what is happening with what should happen.

Turn drift into approved work.

The self-healing layer that repairs failed work and learns — carefully.

Repair failed execution, not just retry it.

Promote improvements only with evidence + a human.

Wired vs. pure-core — what is actually live today

Seven steps from intent to delivered work.

Every workflow, one operating surface.

Evidence-backed artifacts, not chat output.

Execution drift brief

Agent-executable product spec

Browser QA + source-linked fixes

Audit-ready evidence pack

Scattered context creates drift. JAK closes the loop.

Company context is scattered

Teams drift from customer intent

Agents need a trust boundary

Built for controlled autonomy.

Human approval gates

Source-grounded outputs

Tool maturity labels

Tamper-evident audit trail

Self-hostable open-source core

Agent-first runtime

AI agents are powerful. JAK Shield makes them safe.

Agent Firewall

Risk-Based Approvals

Secure Tool Permissions

Sandboxed Execution

Defensive Vulnerability Triage

Audit Evidence Layer

Turn scattered contextinto controlled execution.

Turn scattered context
into controlled execution.

Turn scattered context
into controlled execution.