Managed SaaS platform

Bring your one-shot masterpiece here when it's time to ship

Built something remarkable in a weekend? Akashic is where you turn a vibe-coded spike or massive one-shot into an iterable, team-ready product. It indexes your repo, wires in LLMs and identity-provisioned AI agents, and gives engineers and product a collaborative portal to understand the code, approve work, and move toward deployment — not another PM tool sitting on top.

Open the web portal VS Code setup

Managed SaaS on Apollo — analysis outputs, run history, and manifests live in tenant-scoped cloud storage. Free with any Apollo subscription.

The platform

Onboard what you already built — solo or as an organization

Akashic is a full-scale, end-to-end SaaS platform for bringing existing projects into AI — not a ticket sync or a chat sidebar. Connect a repo, run a 19-phase analysis, and land in a shared cloud workspace where LLM chat, semantic search, ticket reconciliation, agent execution, and deployment pipelines all read from the same index. Individual builders, startups, and enterprise teams use the same portal to transition prototypes into something people can actually use.

Index & transition

Semantic indexing and a knowledge graph turn a sprawling one-shot or inherited monolith into a navigable map — so the next change is informed, not guessed.

Collaborative portal

Engineers review agent PRs and run analyses while product approves tickets behind the reconciliation gate. One run history, one chat, one deployment target.

Identity-provisioned AI

LLM-backed agents run under Auth0 machine identities with scoped OAuth to GitHub, Linear, Jira, and Slack — attributable, auditable, revocable per agent.

Iterate toward production

Incremental analysis, Tekton CI, and managed deployments close the gap between "it works on my machine" and a system your team can ship and scale.

How it works

One backend, two places to sit

The web portal

The full product in a browser: run analyses, watch Prefect run history, chat against your indexed code, review the ticket reconciliation matrix, approve agent work, trigger deployments. No install.

akashic-portal.colossalcapital.co →

The VS Code extension

The same managed SaaS backend in your editor sidebar: connect repositories, run analysis, semantic search, integration panels with live status, and jump to the portal without leaving VS Code.

VS Code Marketplace →

Knowledge graph + codemap

An entity-and-relationship graph of your org, rebuilt after every merge, next to a structural call graph with ripple-risk edges. Both ground every ticket with real dependency context. TypeScript, Go, Python, Rust, Java, C#, and more.

Reconciliation gate

Before tickets reach Linear, Jira, or GitHub, Akashic semantically dedupes them against what's already there and shows a per-ticket create / merge / skip matrix. Sync stays blocked until you've decided. No duplicate tickets, no overwrites.

Derived skillfiles

Akashic derives SKILL.md profiles from your repo's actual conventions, PR style, test patterns, and CI rules, stores them in your tenant workspace, and loads them into every agent run.

Chat and search that cite sources

Ask where auth lives or which middleware guards a route; answers come from your indexed code via Weaviate RAG, with file paths, not from general model memory.

Managed CI/CD

Cloud-hosted Tekton pipelines run Kaniko builds, Trivy scans, Cosign signing, Syft SBOMs, SonarQube coverage, and SLSA L3 attestation. CD routes to Argo CD, Juju, or Terraspace depending on your deployment target.

Human-in-the-loop queue

Ticket syncs, code mutations, deployments, and schema changes wait in an approval queue with per-action policies: auto-approve the low-risk, gate the destructive, require a named reviewer where it matters.

"Where is authentication handled, and what protects the API routes?"

Authentication lives in src/middleware/auth.*, a middleware layer validating API keys on every request. Exempt paths: /health, /docs, /api/auth/*. Keys are managed by api_key_manager with scoped validation.

"Which models run analysis versus chat?"

Analysis phases use DeepSeek-R1 for reasoning and Llama-3.3-70B for generation; chat runs on Mixtral-8x7B for latency. All routed through Together AI, overridable per request.

The analysis

Nineteen phases, persisted in the cloud as they finish

Trigger full_analysis or a focused flow (incremental_analysis, generate_tickets, kg_build, repo_agent_training) from either surface. Prefect orchestrates on managed Apollo infrastructure; every output is versioned in your tenant-scoped cloud workspace and visible in the portal.

IndexRAG indexing into Weaviate, tenant-scoped collections

Classifyproject type, architecture map, stack fingerprint

Duplicatescopy-paste blocks and redundant files

Cleanupdead code, unused imports, stale dependencies

Code analysissecurity, quality, and test-coverage signals per file

Scaffoldingmissing structure and boilerplate gaps

Documentationcoverage and quality scoring per module

Docs consolidationmerge scattered docs into a coherent layout

Script intelligencebuild scripts, CI configs, Makefiles

Folder intelligenceisolated modules and integration gaps

PM contextpull existing tickets from Linear / Jira / GitHub

Emit skillfilesderive SKILL.md from repo conventions

Knowledge graphentities, relationships, ripple-risk codemap

Generate ticketsper-file, deterministic IDs, gated before sync

DeploymentDocker, K8s, Terraform, Terraspace artifacts

Understand repopurpose, patterns, accumulated debt

Restructuring plansynthesized from everything above

Drift analysissemantic drift since the last snapshot

Docs archiveversioned archive of the run to cloud storage

Agents

Agents with names, keys, and audit trails

Every repo gets a dedicated agent, fine-tuned on its code, history, graph, and tickets, and exposed as an MCP tool through Apollo, so Claude, Cursor, Windsurf, or Cline can query it or hand it work. Apollo's persona pool (planner, editor, reviewer, tester, kb_curator, skill_curator) loads your derived skillfiles into every run.

Identity is the part most platforms skip: each coder agent is provisioned through Auth0 with its own machine identity and OAuth-scoped access to your GitHub, Linear, Jira, and Slack, never a shared service account. Outbound requests carry a Cloudflare Signed Agents profile (RFC 9421), so anyone can verify which agent did what, and you can revoke one without touching the rest.

Execution looks like this: the agent decomposes an approved ticket with graph context, writes the code, runs the tests, pushes akashic/id-slug, and opens a draft PR. After merge, Tekton rebuilds the graph and docs, marks tickets done, and files gap tickets if coverage dropped.

Get started

Four steps, none of them clever

Create an accountSign up at the CC keys portal. One API key works for the portal and the extension.
Activate your tenantYour Colossal Capital tier unlocks Akashic in the portal and VS Code extension. Everything runs on managed Apollo infrastructure — no stack to install or host.
Connect and analyzeLink GitHub, Bitbucket, or GitLab; add Linear or Jira, Slack, and a cloud account. Connect your repos and run a full or incremental analysis.
Approve and let it runReview tickets behind the reconciliation gate, approve what you like, and agents take it from there, with every merge rebuilding the graph and docs.