Autonomous Software Engineering · Lights-Out Build Teams

Your engineers, an agent fleet, and a dark factory that ships enterprise software at lights-out speed.

We forward-deploy senior engineers and the Dark Factory, a thirteen-agent autonomous build fleet with a specify-first methodology and enforced quality gates, directly into your repositories, aligned to your SDLC and compliance standards. When the engagement closes, the capability remains yours.

Client owns the code · Model-agnostic orchestration · Sovereign Australian IP
15×
Peak Generation Velocity
Measured commit and iteration velocity across active build days.
3 to 5×
Enterprise Acceleration
Delivery acceleration across all SDLC stages with client human gates retained.
16.7×
Build-Cost Advantage
$1.35M portfolio build cost vs $22.6M conventional onshore rebuild baseline.
100%
Capability Ownership
Your edition of the kit, in your repositories, operated by your engineers.
The Engineering Dilemma

Two speeds of software, and an enterprise that needs both.

AI coding tools offer unprecedented raw speed and no governance. Traditional enterprise engineering enforces rigorous quality gates and moves slowly. Most organisations are being forced to choose. We built the kit to fuse them.

Vibe Coding

Fast · Inexpensive · Ungoverned

  • Prompt to working code in minutes: Extraordinary raw velocity during early greenfield iterations.
  • Accidental architecture: No upfront design documents, ADRs, or interface contracts.
  • Compounding drift: Context fragmentation, hallucinated imports, and brittle edge cases multiply every session.
  • Zero quality assurance: No regression suites, no design-token enforcement, no adversarial review gates.
Enterprise Engineering

Rigorous · Auditable · Slow & Expensive

  • Specification-first governance: Architecture, data models, and ADRs ratified before a line is written.
  • Enforced standards: Strict style guides, security scanning, and multi-tier approval gates on every PR.
  • Regression integrity: Traceability from requirements to code to progression and regression tests.
  • Recruitment lag: Quarters to hire, onboard, and season the onshore teams required to deliver.
The Premise
Every traditional software engineering standard has a direct counterpart in an agent's configuration. Agent velocity and enterprise rigour are enforced automatically by the workflow itself.
The Governed Loop

Engineering guardrails, wired into every agent session.

An autonomous agent session has four distinct stages. The kit injects your standards at each phase, through instruction files, procedural skills, hard rules and verification hooks, turning raw LLM output into auditable enterprise pull requests.

PHASE 01

Structured Prompt

A single story with explicit acceptance criteria and behaviour boundaries. One story, one branch, one pull request.

PHASE 02

Context Ingestion

Agents orient through deterministic codebase graph indexing (Graphify) and LSP symbol navigation (Serena), keeping context inside the model's accuracy window.

PHASE 03

Code Generation

Strict test-driven development: tracer bullet, prove red, implement minimal green, and commit each behaviour slice. Minimal implementation by design.

PHASE 04

Verify & Merge

Local CI gate execution, adversarial subagent review, and regression verification before any code touches the main integration branch.

Injects at Context
Standards Files

Architecture patterns, naming conventions, commit guidelines, and tech stack boundaries read before any generation starts.

Injects at Context
Skills (Playbooks)

Reusable organisational procedures, such as scaffolding routes, database migrations and security hardening, executed deterministically.

Injects at Generation
Rules (Hard Constraints)

Compile-time bounds: forbidden libraries, strict typing, no raw CSS values, and mandatory design token adherence.

Injects at Verify
Hooks & CI Gates

Automated triggers on save and commit: linting, unit test execution, token auditing, and complete session provenance logging.

The 13-Agent Fleet

A specialised autonomous build team.

Rather than relying on a single generalist prompt, the kit coordinates thirteen right-sized personas across a five-phase methodology: specify deeply, review adversarially, then build autonomously.

Implementer
Imp · Orchestrator
Orchestration
Loop Orchestration & Handovers

Orchestrates the entire autonomous build loop, delegating tasks between personas, tracking story status, and enforcing branch lifecycle hygiene.

Target: Autonomous Loop
Analyst
Mara · Domain Specialist
Specification
Requirements & Domain Modelling

Interviews stakeholders, uncovers edge cases, establishes canonical domain dictionaries, and extracts structured epics and user stories.

Target: docs/domain-context.md
Architect
Artemis · System Architect
Specification
System Design & ADR Governance

Designs system topography, authors Architecture Decision Records (ADRs), pins tech-stack versions, and specifies non-functional requirements.

Target: docs/architecture.md
Specification Reviewer
Sera · Scope Auditor
Specification
Scope Simplification & Validation

Conducts adversarial review passes on draft specifications, purging speculative abstractions and identifying technical debt before build.

Target: docs/spec-review.md
Platform Engineer
Plat · Foundation Lead
Infrastructure
CI/CD & Infrastructure as Code

Configures local and remote CI pipelines, Docker environments, IaC provisioning, and delivers Epic 0 repository scaffolding.

Target: scripts/local-ci-gate.cjs
Test Architect
Tess · Quality Strategist
Testing
Test Strategy & Slice Planning

Designs the test architecture for each story, plans progression and regression targets, and defines vertical behaviour slices before any code runs.

Target: docs/tests/E*-targets.txt
Planner
Plan · Design Lead
Planning
Per-Story Design Documentation

Drafts granular design documents for individual stories, detailing interface schemas, database alterations, and component hierarchies.

Target: docs/designs/E*-S*.md
Coder
Cody · TDD Specialist
Implementation
Red-Green Behaviour Slicing

Implements code strictly through test-driven development: writes failing behaviour tests, writes minimal green code, refactors, and commits slice-by-slice.

Target: PR Feature Commits
Reviewer
Rev · Adversarial Reviewer
Review
Automated PR Code Review

Performs adversarial pull request reviews, evaluating changes against architectural constraints, design token rules, and test coverage.

Target: PR Review Findings
Dark-Factory-Adviser
Sage · Diagnostics Lead
Diagnostics
Diagnostics & Autonomous Repair

Inspects execution logs when tests fail or agents stall, pinpoints root causes, and generates targeted remediations to restore the build loop.

Target: reports/dark-factory.log
Checker
Chex · Fast Executor
Execution
High-Efficiency Routine Operations

Haiku-tier lightweight executor handling routine file reads, symbol lookups, git status checks, and greps to conserve reasoning context tokens.

Target: Targeted File Operations
UX Engineer
Design Token Custodian
Frontend
Design Tokens & Accessibility

Audits frontend layouts, enforces design tokens, prevents arbitrary styling, and verifies semantic accessibility standards (WCAG AA).

Target: tokens/ & UI Components
Model Policy & Eval
Governor · Dynamic Routing
Governance
Model Routing & Eval Suite

Routes prompts to the optimal reasoning tier, benchmarks model updates, and runs evaluations so changing models is a test run.

Target: evals/ & Token Policy
Enterprise Architecture

Separation of Runner and Brain.

To deliver enterprise security and sovereign IP protection without risking client source code, the kit enforces a strict service boundary between local execution and agent intelligence.

Client Infrastructure

The Runner (Execution Plane)

A lightweight agent that lives where your code resides: on your developer workstations, within your GitHub/GitLab CI runners, or inside your private VPC.

  • Carries zero proprietary prompts, workflows, or governance IP.
  • Checks out repositories, runs compilers, executes test suites.
  • Commits slices and opens pull requests on your version control.
  • Streams build logs and test telemetry to the evaluation gate.
  • Source code never leaves your defined network boundary.
Ekim Sovereign Cloud

The Brain (Intelligence Plane)

The orchestrating service boundary hosting the 13 agents, multi-phase workflows, quality gates, and dynamic model policies.

  • Receives structured tasks and returns verified code slices.
  • Applies strict specification reviews and architectural boundaries.
  • Runs adversarial pull request evaluations and security scans.
  • Available as hosted SaaS, an MCP endpoint, or private VPC deployment.
  • Escrow-backed source agreements available for enterprise buyers.
# 1. Developer checks out fresh feature branch git checkout main && git pull git checkout -b feature/E2-S3-user-auth # 2. Invoke the autonomous build loop via CLI or IDE codex "implement story E2-S3" # Imp (Implementer) orchestrates the 5-phase loop: [Imp] Spawning Tess (Test Architect) -> docs/tests/E2-S3-targets.txt [Imp] Spawning Plan (Planner) -> docs/designs/E2-S3.md [Imp] Spawning Cody (Coder) -> Executing vertical TDD slices (red-green) [Cody] Slice 1: Auth token validation (GREEN) [Cody] Slice 2: RBAC permission hierarchy (GREEN) [Imp] Story complete. Running local CI gate...
// Claude Code / Cursor configuration (.cursor/mcp.json) { "mcpServers": { "dark-factory-brain": { "command": "npx", "args": ["-y", "@ekim-ai/dark-factory-mcp"], "env": { "DARK_FACTORY_ENDPOINT": "https://brain.ekim.ai/v1", "DARK_FACTORY_LICENSE_KEY": "sk_live_enterprise_au_849204" } } } } // Exposed agentic tools: // - mcp__dark_factory__architect_review(spec_path) // - mcp__dark_factory__test_architecture(story_id) // - mcp__dark_factory__adversarial_pr_review(pr_number)
# Enforced local CI merge gate before pull request submission $ node scripts/local-ci-gate.cjs [GATE] Verifying clean git working tree... PASSED [GATE] Checking design token compliance in components/... PASSED (0 violations) [GATE] Running targeted progression tests (docs/tests/E2-S3-targets.txt)... PASSED (14/14) [GATE] Running full regression suite (tests/regression/)... PASSED (186/186) [GATE] Auditing story design documentation... PASSED [GATE] Checking session provenance summary... PASSED PASS: all gates green. Pull request #42 ready for squash merge.
Empirical Proof

We run our own company on it.

Every metric below is reproducible directly from git logs: active commit velocity, lines of test and production code, and delivered platforms. Nothing rounded up.

In-House Platform Asset Kit Build Cost Conventional Onshore Rebuild Measured Advantage
Advisory Intelligence Platform ~$471k ~$9.1M ~19×
Tommy & Spartan (Agentic Marketing Suite) ~$607k ~$8.75M ~14×
EKIM AI Evolution (Core Methodology Engine) ~$120k ~$4.9M ~41×
Dark Factory (The Framework Itself) ~$156k ~$560k ~4×
Portfolio Total ~$1.35M ~$22.6M ~16.7×

Read the 16.7× advantage correctly.

We achieved this ratio by operating as a small founding team building platforms end-to-end with the kit. An enterprise engagement does the opposite: it retains and accelerates your team, keeping your architecture review, compliance sign-offs, and security gates intact. The planning factor for enterprise deployment is 3× to 5× acceleration across all SDLC delivery once the kit is aligned to your stack.

Government & Audit

Built for Audit

Traceability from requirement to test case, written for Commonwealth and sovereign audit contexts.

Sovereign Enterprise

National Managed Services Provider

Twelve-month capability partnership: the methodology deployed on the client’s own harness to IRAP-grade production.

Regulated Scale-Up

Regulated Gaming Platform

Three evaluation missions in regulated multi-state gaming contexts, delivering an in-house tuned edition.

Deep Tech Infrastructure

Graphene & Ekim AI

Production-hardened from day one on the sovereign compute and inference platforms we run daily.

Engagement Shapes

Adapted to your stack, your tools, and your gates.

You keep your developer toolchain. We deploy senior engineers and the Dark Factory into your repositories, aligned to your branching models and compliance gates.

Engagement Shape B

Hosted Kit & MCP Server

Agentic access via Model Context Protocol (MCP) and hosted cloud workers for teams that live in Cursor, VS Code, or Claude Code.

  • Zero IP Footprint: Thin runner on client machines; brain stays behind our sovereign service boundary.
  • Native IDE Integration: Invoke planners, test architects, and reviewers as native MCP tools.
  • Continuous Updates: Benefit from kit tuning, new agent personas, and model policy updates automatically.
  • Metered Consumption: Scaled by active users and execution tokens.
Engagement Shape C

Private-Deployment (VPC) Licence

Dedicated, entitlement-gated brain deployed inside your AWS, Azure, or Google Cloud Virtual Private Cloud.

  • Absolute Data Containment: Zero external API traffic; all agent routing contained within your VPC perimeter.
  • Regulated & Sovereign Fit: Engineered for banking, defence, and IRAP-compliant environments.
  • Source Escrow: Entitlement-gated execution with full source held in legal escrow.
  • Annual Licence & Maintenance: Dedicated support, regular security patches, and eval suites.
Deployment Scoping

Bring us one thing that normally takes weeks.
We will do it live in the room.

A working session in your environment: your engineers bring a real piece of work, we run it through the Dark Factory, and your team judges the velocity and code quality directly.

Responses reviewed by senior engineering partners within one business day.
Deployment request received. A senior partner will contact you directly to schedule the live working session. Direct inquiries reach mike@ekim.ai.