Taksha CodeSpace

A cloud IDE where an AI agent plans, writes, builds and fixes code inside your own Kubernetes sandbox.

Features · Architecture · Services · Quick start · Docs

What it is

• Every project gets its own sandbox. A Kubernetes pod with a live Vite preview, a terminal and files saved to S3.
• Orion, the coding agent, turns a prompt into a plan, waits for your approval, then edits, builds and fixes the code in that sandbox.
• Clio, the copilot, explains code and makes small edits to the file you have open.
• Results are checked, not guessed. A step passes only when the tool results and the build exit code say so.

Features

Area	What you get
Editor	Monaco editor, file tree, xterm.js terminal, live preview at <id>.preview.localhost
AI agents	Orion graph with plan review, tester, reviewer and up to 3 debug rounds. Streams over SSE and re-attaches after a reload.
Sandboxes	One pod per project, idle pods stop on their own, files restored from S3 on start
Auth	Google OAuth, RS256 access tokens with JWKS, rotating refresh tokens with reuse detection
Billing	Razorpay checkout, verified webhooks, subscription slots, credit windows, referrals
Emails	Welcome and payment emails through RabbitMQ and Nodemailer

Architecture

%%{init: {"theme": "base", "themeVariables": {"background": "transparent", "primaryColor": "transparent", "secondaryColor": "transparent", "tertiaryColor": "transparent", "mainBkg": "transparent", "clusterBkg": "transparent", "clusterBorder": "#768390", "edgeLabelBackground": "transparent", "primaryBorderColor": "#FF6A2B", "lineColor": "#768390", "primaryTextColor": "#768390", "textColor": "#768390", "titleColor": "#768390"}}}%%
flowchart LR
    FE["Frontend IDE<br/>:5173"] --> ING
    PF["Checkout app<br/>:5174"] --> ING
    ING{{"NGINX<br/>Ingress"}}

    subgraph Core["Core services"]
        AUTH["Auth<br/><small>/api/auth</small>"]
        PAY["Payments<br/><small>/api/payments</small>"]
        AI["AI Orchestration<br/><small>/api/ai</small>"]
        SBX["Sandbox server<br/><small>/api/sandbox</small>"]
        RT["Router<br/><small>*.preview, *.agent</small>"]
    end

    ING --> AUTH & PAY & AI & SBX & RT

    MQ[("RabbitMQ")] --> NOTI["Notification<br/><small>emails</small>"]
    AUTH -.-> MQ
    PAY -.-> MQ

    AI --> LLM(["NVIDIA LLM API"])

    subgraph Pod["Sandbox pod (per project)"]
        AGENT["Sidecar :3000"]
        VITE["Vite app"]
        SYNC["sync-agent"]
    end

    AI --> AGENT
    SBX --> Pod
    RT --> AGENT
    RT --> VITE
    SYNC --> S3[("AWS S3")]

    classDef default fill:transparent,stroke:#FF6A2B,stroke-width:1.5px,color:#768390
    style Core fill:transparent,stroke:#768390,stroke-dasharray:4 4,color:#768390
    style Pod fill:transparent,stroke:#768390,stroke-dasharray:4 4,color:#768390

Loading

Link	What happens
Sandbox server to pod	Creates one pod and one Service per running project, deletes them when idle
AI Orchestration to sidecar	Agent tools read and write files and run commands inside the pod
AI Orchestration to Payments	Checks credits before a run, reports token usage after it (not drawn)
Router to pod	*.preview goes to the Vite app, *.agent goes to the sidecar
Auth, Payments to RabbitMQ	Dotted lines: email events, sent to users by Notification

Each backend owns its own MongoDB database. Redis handles the token blacklist, rate limits, cron locks and sandbox TTLs.

Full flows (login, sandbox lifecycle, agent run, payments): docs/ARCHITECTURE.md

Services

Service	Role	Stack	README
Auth/	Google login, JWT issuer, JWKS, refresh rotation	Express, Passport, Redis	Read
Ai_orchestration/	Orion and Clio agents, SSE streaming, rate limit	LangGraph, LangChain, Tavily	Read
Payments/	Orders, webhooks, subscriptions, credits, cron jobs	Razorpay, node-cron, FaultKit	Read
Notification/	Email worker	RabbitMQ, Nodemailer	Read
Sandbox/server/	Projects and pod lifecycle	@kubernetes/client-node	Read
Sandbox/router/	Subdomain proxy into pods	http-proxy-middleware	Read
Sandbox/Agent/	In-pod sidecar: file API, commands, PTY terminal	node-pty, Socket.IO	Read
Sandbox/sync-agent/	Restores and backs up workspace files	AWS SDK, chokidar	Read
Sandbox/template/	Seed Vite + React app for new projects	Vite, React	Read
Frontend/	The cloud IDE	React 19, Redux Toolkit, Monaco, Dexie	Read
payments_frontend/	Pricing and checkout app	React 19, react-razorpay	Read
Admin/	Planned, no code yet	n/a	Read

Quick start

Prerequisites

• Node.js 20+ and npm
• Docker Desktop with Kubernetes enabled (or Minikube)
• Skaffold and the NGINX Ingress controller
• Accounts or local instances for MongoDB, Redis, RabbitMQ, AWS S3, Google OAuth, Razorpay (test mode) and an NVIDIA API key

1. Configure

Every service has a .env.example. Copy it to .env and fill in your values.

cp Auth/.env.example Auth/.env
# repeat for Payments, Ai_orchestration, Notification, Sandbox/server, Sandbox/router,
# Sandbox/sync-agent and payments_frontend

For the cluster, build k8s/secrets.yml from the keys the manifests in k8s/ read.

2. Run the whole cluster

skaffold dev

This builds every image, applies k8s/*.yml and hot-syncs src/ changes into running pods.

3. Run the frontends

cd Frontend && npm install && npm run dev            # http://localhost:5173
cd payments_frontend && npm install && npm run dev   # http://localhost:5174/payments/

Both proxy /api to the ingress at http://localhost.

Handy commands

Task	Command
Run one backend outside the cluster	cd <service> && npm run dev
AI offline tests	cd Ai_orchestration && npm test
Check the NVIDIA key and model	cd Ai_orchestration && npm run check:model
Auth load test	k6 run Auth/src/k6/load-test.js
Health checks	GET /healthz and /readyz on Auth, Payments, Notification

Warning

cd Payments && npm test truncates every table. It runs only against the local Postgres from docker compose up -d and refuses non-localhost.

Project layout

Capstone/
├── Auth/                 identity and tokens
├── Ai_orchestration/     Orion + Clio agents
├── Payments/             billing and credits
├── Notification/         email worker
├── Sandbox/
│   ├── server/           pod lifecycle API
│   ├── router/           subdomain proxy
│   ├── Agent/            in-pod sidecar
│   ├── sync-agent/       S3 backup and restore
│   └── template/         seed project
├── Frontend/             cloud IDE
├── payments_frontend/    checkout app
├── Admin/                admin platform plan, no code yet
├── k8s/                  manifests and ingress
├── docs/                 architecture, API and design docs
├── launch-video/         Remotion launch video
└── skaffold.yml          dev loop for the cluster

Documentation

Doc	Topic
docs/ARCHITECTURE.md	How the services work together, start here
docs/README.md	Index of all design docs
docs/openapi.yaml	OpenAPI contract
docs/prd/	Product requirements
docs/infrastructure/	Kubernetes and Skaffold guide
docs/frontend/	Frontend architecture and design tokens
docs/plans/kafka-whatsapp-architecture.md	Plan, not built: Kafka, WhatsApp, admin observability
Admin/PLAN.md	Plan, not built: admin platform

Note

Some pages in docs/ describe planned work (gRPC, the Chrome extension, Loki, Admin). When a doc and the code disagree, the code is right. Current gaps are listed in docs/ARCHITECTURE.md.

Built by Sahil Sharma · @Sahil-coder-30