Skip to content
ROOT
BRAND

Abukix Studio Plan

The public-facing brand layer on top of basecamp. Portal Web UI + command palette AI assistant + platform-ctl CLI + 5 documented composition recipes. Launches publicly at studio.abukix.dev in Year 5 Phase 29.

Abukix Studio is the Group A platform layer that turns the rest of the platform into a product. Where basecamp is the substrate (9 tiers of services declared in YAML) and terralabs is the infrastructure beneath it, Studio is what a visitor actually sees — a Portal Web UI, a command palette AI assistant, the platform-ctl CLI, and 5 documented composition recipes that chain the platform’s services into outcomes.

Most of Studio is built incrementally across Years 2-5 — platform-ctl starts in Year 2, the agents that back the command palette ship in Year 5 Phases 26-28 — but the public launch is one phase: Year 5 Phase 29, where the Portal goes live at studio.abukix.dev, platform-ctl flips public, and the hosted demo opens to visitors. The Year 5 Phase 30 mlship v2 capstone deploys onto Studio’s surface — a recursive proof that the platform serves real users.

Studio’s audience is engineers (junior → mid-career) who want to understand the platform layer. Not end-users wanting AI; not complete beginners. That audience scope is what makes the 3-tier sharing model viable — OSS for self-hosters, hosted demo for visitors, managed deferred indefinitely.

What it is

Three artifacts that together form the experience visitors see:

  1. Portal: Backstage-extended Web UI surfacing services, models, agents, pipelines, alerts, composition recipes (Y5 P29 builds this; lives inside basecamp at basecamp/charts/portal/)
  2. command palette AI assistant: natural-language query bar; backed by query-helper agent (Y5 P26) using basecamp-mcp (Y5 P27)
  3. platform-ctl CLI: unified command front-door for everything basecamp + terralabs + Studio can do

Plus a hosted demo at studio.abukix.dev: read-mostly, rate-limited, CPU-only, free for visitors. Sample notebook + tiny RAG demo + small mlship deploy preview + command palette agent.

Why it exists

basecamp ships every layer of the platform — but a visitor who clones it gets ~30 services and a 4-hour bootstrap. Abukix Studio is the product layer that makes the platform feel like one thing.

Three concrete reasons:

  1. Public proof of synthesis: the artifact that demonstrates Staff/Principal-level engineering: “I built and shipped a full AI/data platform that other engineers can use.” More credible than 9 disjoint OSS projects.
  2. The brand: Abukix Studio is the public name engineers Google. The cinematic content series + ambassador applications + future career moves all reference Studio, not “the homelab project.”
  3. The funnel: visitor lands at studio.abukix.dev, plays with the demo, finds basecamp on GitHub, clones it, runs their own. The hosted demo’s job is to make the OSS feel real.

Audience

Engineers (junior → mid-career) who want to understand the platform layer. Not end-users wanting AI. Not complete beginners.

This audience:

  • Is your peer group (you’re building for people like you, 1-3 years behind)
  • Is exactly who AWS Community Builder / CNCF Ambassador programs serve
  • Will star the repo, contribute PRs, give podcast invites + talk slots
  • Doesn’t need you to host their compute — they want the architecture + patterns

What you’re NOT promising:

  • Free hosted compute at scale
  • SLA / 24/7 support
  • “AI for everyone” end-user experience
  • Production-grade managed offering

Pattern it teaches

platform-as-product: the discipline of treating internal tools as products with users, UX expectations, and time-to-first-deploy as the diagnostic metric. Studio IS the proof that this discipline matters.

Plus reinforced patterns:

Scope (timeline)

Most of Studio is built incrementally across Y2-Y5, even though the public launch is Y5 P29.

PhaseWhat gets built
Y2 P12platform-ctl v0 starts (private): first 4 commands
Y3platform-ctl adds cluster + pipeline subcommands; basecamp goes public
Y4 P21platform-ctl model deploy wires to mlship v0
Y4 P23platform-ctl pipeline run train-deploy triggers KFP
Y5 P26query-helper agent built (becomes command palette backend)
Y5 P27basecamp-mcp exposes platform to MCP-aware agents
Y5 P28services/aiops/ ships (uses Studio’s underlying tooling)
Y5 P29Abukix Studio LAUNCHES: Portal + command palette + hosted demo + platform-ctl public
Y5 P30mlship v2 capstone deploys onto Studio’s surface

The 3-tier sharing model

  1. OSS, self-host (free for everyone, free for you): github.com/abukix/basecamp + platform-ctl. Clone, run on homelab/cloud, follow README, get an equivalent platform. The moat. 99% of users land here.

  2. Hosted demo: studio.abukix.dev. Read-mostly, rate-limited. Pre-loaded notebook + RAG demo + tiny mlship deploy + command palette. CPU-only models (no GPU; Phi-3-mini quantized via llama.cpp). 10-min session timeout. Cost ceiling: $30-50/month if capped properly. The brand multiplier.

  3. Managed offering: DEFERRED. Maybe never. Open-core companies do this years post-launch with VC funding. ROOT defaults to “OSS + small demo,” with managed only if Y5 launch shows real demand.

The 5 composition recipes

The proof that Studio is one product and not a collection of services. See composition.md.

  1. Personal RAG over your weekly logs (Y4 P24)
  2. Auto-incident triage loop (Y5 P28)
  3. Train → register → deploy in one flow (Y4 P23)
  4. Homelab life API (Y3 P15-18)
  5. AI-assisted on-call (Y5 P28-29)

Each is runnable end-to-end via platform-ctl recipe run <name> (post Y5 P29) or via the Portal UI.

Stack

Studio’s frontend (Portal):

  • Next.js + Tailwind CSS
  • Cloudflare Pages hosting
  • Backstage embed (catalog + scaffolder)
  • command palette via custom React component → query-helper agent endpoint

Studio’s backend:

  • basecamp-mcp Go service (Y5 P27)
  • query-helper agent in Python LangGraph (Y5 P26)
  • llm-gateway v1.5 (Y4 P25)
  • All running inside basecamp’s K3s

Hosted demo backend:

  • Cloud Run / Fargate for the API tier
  • Cloud Run jobs for demo compute (capped, ephemeral)
  • Cloudflare Pages for the static frontend
  • llama.cpp + Phi-3-mini on CPU

Public vs private

  • Public from launch (Y5 P29): Portal at studio.abukix.dev, platform-ctl repo, hosted demo
  • Private always: your real basecamp instance (the homelab one), your real personal services data, your weekly logs, your aiops audit logs

The public Studio uses seed data for demos, not your real data.

Success criteria (Y5 P29 launch)

[ ] studio.abukix.dev live + functional + cost-capped
[ ] platform-ctl public on GitHub with README + 5 example workflows
[ ] All 5 composition recipes runnable from the Portal
[ ] command palette returns useful answers for "show me services" / "deploy a model" / "tail logs for X"
[ ] Hosted demo 10-min session works end-to-end without errors
[ ] Blog post + LinkedIn announcement + Show HN
[ ] AI security verified: 5 attempted prompt injections blocked

Year 5 Final Exam Part 1 (live system review) tests this directly.

Anti-patterns

Anti-patternWhy
Hosting GPU on the demoBills explode; $30-50 cap dies
Studio with no demo (just OSS)Lost cinematic surface; visitors don’t see it live
Studio with no OSS (just demo)Dependent on you forever; bus factor 1
Custom design without UX budgetWorse UX than Backstage default
Demo with persistent stateVisitors leave artifacts; cleanup nightmare

Cross-references