Agentic AI engineering studio
A chatbot answers. We build systems that complete the work.
SkysphereAI Labs is a small, senior team that designs governed agentic systems — they plan the steps, act through approved tools only, validate against rubrics, wait for a named human on anything high-impact, and log every action as evidence.
The idea
From answering questions to completing work
One distinction sits underneath everything we build.
A chatbot
- Answers in one shot — helpful, or confidently wrong
- No record of why it said what it said
- One vendor’s model, wired in permanently
- Memory is whatever the session happened to hold
- Mistakes are found afterward, by people
A structured agentic system
- Completes a workflow — plans the steps, then executes them
- Uses approved tools and data only — nothing else is callable
- Output validated against rubrics before anyone sees it
- High-impact steps wait for named human approval
- Every action logged with data lineage and cost
Models change, vendors change, pricing changes. The stable layer around the model — orchestration, permissions, memory, audit — is what actually matters. That layer is our craft.
“The model is not the moat.”
Anatomy
A governed agentic system, layer by layer
Five layers, designed in from day one — not added after an incident.
Governance
Control planeaudit · approvals · privacy · cost controls
Memory & wiki
per-user memory · official project wiki · expiry rules
Orchestration
planner · workers · validator · human reviewer
Tools
approved commands, APIs and data access — nothing else
Models
frontier · cloud · private · local — swappable
The control plane
Most AI demos are layer 01 with a user interface. Layers 02–05 are the unglamorous engineering that makes AI safe enough to run inside an institution — and they are where almost all of the work lives. When the models improve next year, layers 02–05 are what you keep.
The system
How one request moves through the system
Seven steps — identical for an enforcement case, an HR query, or a financial report.
Intake
request captured; sensitivity flagged
Understand
intent extracted; success criteria set
Plan
steps, agents, tools, checkpoints
Execute
approved tools only; scoped permissions
Validate
rubrics, policy and fact checks
Approve
named human signs off high impact
Deliver & learn
audit trail attached; memory updated
Loop engineering
We treat the plan → act → observe → refine cycle as the product. Errors get caught and corrected inside the loop, before delivery — which is where reliability, and speed, actually come from.
A continuous feedback loop — every outcome refines the plans, rubrics and memory the next request starts from.
Same control plane, many workflows
One foundation, pointed many ways
Not many products — one governed control plane, reused. Each workflow below reuses the same audit, memory and governance. These are illustrative use cases, not delivered engagements.
Government & public sector
Resident service triage
Intake is captured, duplicates collapse into one case, and requests route to the right department with context attached.
AI routes · staff decideEnforcement response
Closure communications drafted from approved templates, with the applicable rule auto-cited for a named officer to approve.
AI drafts · an officer approves & sendsPermits & licensing
Applications screened against current by-laws and service standards, with every step logged and reviewable.
AI screens · staff sign offAsset & defect detection
Defects flagged from monitoring data so maintenance is scheduled proactively, not reactively.
AI flags · operations schedulesEnterprise & operations
Financial forecasting
Records analysed to flag spending anomalies and sharpen budget accuracy — with every figure traced to its source.
AI surfaces · finance makes the callHR self-service & L&D
Policy, leave and benefits questions answered from approved sources — always with a citation, never a guess.
AI answers · cites the source policyReporting & reconciliation
Recurring reports assembled and reconciled across systems, so nothing slips between the seams.
AI assembles · a human approvesCommerce & ops intelligence
Cross-platform operational data unified into one governed view, replacing manual cross-system assembly.
AI unifies · the team actsPlug the control plane into one workflow, then the next — on a single foundation. Nothing is rebuilt.
What makes us different
Most vendors sell a model with an interface
We build governed systems you own.
A deliberately small, senior team. The discipline here is simply how we work every day — not a layer added for a bid. That is the real reason to believe a team will still be delivering in month six.
What we’re building
Ace — the agentic platform our team runs on
Ace is the governed control plane we build with every day: orchestration, permissions, memory, validation, audit and a model gateway, in one place. It is how a small team ships governed agentic systems at a pace usually reserved for much larger vendors.
Orchestration
Plans work into reviewable steps and coordinates planner, workers and validator.
Governance
Audit, approvals, privacy and cost controls wrap every layer.
Memory & wiki
Designed memory and a versioned, source-linked knowledge base (powered by BEE).
Model gateway
Routes each request by privacy, cost, latency and policy — no lock-in.
Evidence
Every run produces an inspectable record — triggered-by, tools, validation, approval.
Isolation
Agents run in isolated containers with scoped permissions — nothing reaches what it should not.
What we go deep on next
Scaling to hundreds of agents
Fleets orchestrated, queued and run in parallel — reliably, at production volume.
Fleet telemetry & observability
Tokens, cost, latency, loops and outcomes across hundreds of agents — one pane of glass.
Cloud or on-prem hosting
Your cloud or your own servers. Where it runs, residency, and failover.
Execution loops, in depth
The plan-act-observe-refine cycle up close — how errors are caught before delivery.
Privacy & data protection
Classification before model access, redaction at intake, role-based, least-privilege access.
Memory & knowledge base
How designed memory and a source-linked wiki become institutional memory.
The architecture conversation
The architecture conversation — bring your engineering, security and privacy teams, and we open the hood as far as they want.
Open source
Built in the open
We maintain open-source tooling so the systems we build run on components that can be inspected and independently evaluated — not black boxes.
Belief Extraction Engine · MIT License
BEE — Persistent, designed memory for AI agents.
BEE gives agents a structured, versioned, source-linked memory that survives across sessions — the difference between an agent that compounds context and one that contaminates itself. It is designed to be measured against public memory benchmarks and powers recall and the project wiki in every workflow we build.
- Structured beliefs, versioned and source-linked
- Scoped, expiring per-user memory
- Built to be measured against public benchmarks
- MIT licensed — no lock-in
[BEE recall — designed memory] > [wiki, official] SOP template v3 · approved · source-linked > [user, scoped] "prefers email follow-up" · expires in 30d > [pii, never-stored] name · phone · address — stripped at intake
Inspectable
If a component is load-bearing for trust, it should be open enough to inspect.
Benchmarked
Measured against shared, public benchmarks — not internal marketing numbers.
No lock-in
Permissive licensing. Use it with us, or entirely without us.
Working together
How a build actually runs
Four phases. Each one ends at a gate that you — not the vendor — control.
Discover
- →Map one workflow end-to-end with the owning team
- →Classify the data; set privacy guardrails
- →Agree success criteria before any build
You get: a written spec & governance plan
Pilot
- →Build on the governed control plane
- →Your team uses it on real work — approval gates on
- →Live audit and cost telemetry from day one
You get: a working governed workflow your team can try
Evaluate
- →Judge against the phase-1 criteria — nothing else
- →Review the system’s own audit evidence
- →Decide: go, fix, or stop
You get: an evidence pack & a decision you own
Scale
- →Add the next workflow on the same foundation
- →Same audit, memory and governance — nothing rebuilt
- →Each addition reuses the same proven foundation
You get: a reusable control plane
Exit at any gate. Your data, configurations, knowledge base and audit history remain yours. The decision to continue is always yours, made on the system’s own evidence.
The team
A deliberately small, senior team
We are engineers who build governed agentic systems for a living — not a sales org with an AI layer. The discipline on this page is simply how we work.
Kartik Vashisth
Founder & CEO
Sets the engineering bar and owns how every system is planned, governed and shipped. Builds the agentic platform our own team runs on.
Vikram Vashisth
Co-Founder & Head of Cybersecurity
Leads security architecture, access control and data protection — so every deployment meets the standard an institution has to hold.
Vishal
AI Business Solutions Lead
Maps real workflows to governed agentic solutions and keeps the work anchored to outcomes a team actually feels.
Working together
Bring us a workflow you want to govern
Tell us about one workflow that matters. We will map it end-to-end and show you what a governed agentic system does with your data — on your terms, with the evidence to prove it.