Private inference, admin, audit feed, model policy, and security review packet.
CompletedPublic roadmap
Execution roadmap.
Built today, hardening now, and planned next. Srasta separates current capability from committed build direction, and every milestone is tied to a deployment/runtime profile we can actually validate.
Roadmap discipline
We do not pitch roadmap items as shipped capability.
The website and pitch deck now align on the same backbone: private inference, agent-registered install, admin operations, governance evidence, and hardware/runtime profiles. Code is complete on dev through the platform spine; L4 validation is the next proof gate before broader production claims.
Milestones
Where the platform evolves.
The public roadmap mirrors the current build: code-complete platform phases on dev, L4 hardware validation next, then customer-driven enterprise expansion.
Srasta-Agent registration, Deployment Charter, catalog/license gates, and receipts are implemented on dev.
Dev completePrompt-to-audit handover, pilot proof chain, and customer-success request capture are implemented on dev.
Dev completeSrasta-Agent convergence, support bundles, upgrade, rollback, backup, and restore paths are implemented on dev.
Dev completeKubernetes contract, registry trust, HA posture, and enterprise hardening cores are implemented on dev.
Dev completeRun the full spine on Apple Silicon, NVIDIA single-node, NVIDIA multi-host, and CPU/community cells.
Validation nextCustom tools, MCP server SDLC, and agentic harness support are coded; customer-specific packages remain governed and scoped.
Scoped laterBuild detail
What each phase includes.
Private AI foundation
The platform spine is implemented on dev: private inference, admin operations, governed gateway routing, audit visibility, and customer-controlled deployment profiles.
- Private inference path for open-weight models on customer-controlled hardware
- Gateway foundations for role-aware model access and auditable AI requests
- Admin foundations for users, roles, licenses, model access, and runtime visibility
- Governance foundations for prompt, model, memory, tool, policy, and admin events
- Deployment profile design for developer local, single-node Linux, multi-host Linux, and Kubernetes
- Host agent heartbeat, runtime-health, and controlled-action foundations
Apple Silicon developer path
The Apple Silicon path is implemented in code and now needs the real-cell L4 run: install, run, test, and inspect Srasta locally without manual serving.
- Apple Silicon local profile using host-native model runtime where practical
- Local install plane with agent registration, prechecks, verify, reset, and logs
- Developer proof gate: prompt enters Srasta and produces audit-visible evidence
- Clear limits on what is local-only versus enterprise-ready
- No SSH/SCP operating model after local agent registration
NVIDIA Linux enterprise pilot path
The NVIDIA Linux pilot path is implemented in code and now needs real-cell validation for private inference, admin onboarding, and hard prompt-to-audit proof gates.
- NVIDIA Linux single-node profile with vLLM-backed private inference
- Agent registration as the primary install backbone after bootstrap
- Hard gates for prompt-to-audit workflow proof before handover
- Operator-visible evidence for runtime health, gateway routing, role checks, and audit events
- Deployment Charter and Pilot Charter for design partners
- Sanitized support package flow for debugging without exposing customer data or PII
Multi-host Linux convergence
The multi-host convergence spine is implemented on dev: registered Srasta-Agents report truth and converge desired platform state through receipts.
- Converge desired platform state through registered agents
- Inventory, package, runtime, GPU, health, and policy posture reported to the install plane
- NVIDIA GPU nodes serve inference while CPU nodes absorb stateful, admin, and observability workloads
- Node-level action receipts and rollback evidence for operator review
- Stronger release verification and artifact provenance for customer-controlled installs
- Support workflow that scrubs customer data before optional diagnostic sharing
Kubernetes and HA operations
The Kubernetes contract, backup/restore, rolling upgrade, registry trust, support collection, and HA posture cores are implemented on dev. Formal five-nines SLA remains customer and validation dependent.
- Kubernetes operator and upgrade posture for enterprise deployment profiles
- HA-oriented topology guidance for gateway, inference, admin, governance, memory, and audit layers
- No-planned-downtime upgrade patterns where architecture and customer infrastructure allow it
- Disaster recovery, restore drills, rollback drills, and proof artifacts
- Formal SLA and five-nines commitments only after measured validation with paying customers
Bespoke intelligence layer
The governed intelligence layer is implemented on dev: custom tools, MCP servers, agentic harnesses, and approval SDLC tied back to audit and policy.
- Governed custom tool registry and approval lifecycle
- MCP server onboarding, review, approval, execution policy, and audit trail
- Agentic harness support for customer workflows that need planning, tool use, and operator guardrails
- Evaluation views for prompt quality, memory behavior, tool behavior, and compliance-rule outcomes
- Expansion from one governed workflow into a customer-specific private AI operating layer
Specialized enterprise requirements
These are not day-one promises. We will scope and price them when a paying customer has the requirement and the environment to validate it.
- Air-gapped environments and offline artifact logistics
- Windows node support
- Vast.ai or similar GPU-marketplace customer installs
- Formal five-nines SLA backed by measured production evidence
- Advanced workspace, role, and sector-specific compliance automation
- AMD, Intel, and specialized edge AI machines after demand and validation
Design partner fit
Have a workflow that should shape the roadmap?
The best roadmap input is a real environment, a real governance boundary, and a measurable workflow. We capture requests in the same CRM-backed funnel as pilot and product-update interest.