SkyeHands AI Workspace Platform · Governed Agent Mesh · App Forge · Current Proof State
Beyond the Skye others set.
SkyeHands is an AI workspace platform that connects governed agents, app generation, platform launch, proof systems, procurement workflows, and operating infrastructure in one command layer. The current codebase archive reflects highest passing stage 11, 61 proof artifacts, and a current ecosystem code-floor valuation of $86,800,000.
$13.9B+Combined market cap of closest single-dimension competitors
0Direct competitors with unified IDE + autonomous agent
$28.4BTAM SkyeHands is uniquely positioned to capture
$86.8MCurrent ecosystem code-floor · April 30 2026
$115–190MRaise posture held from the current investor deck · current floor now $86.8M
📋 Current-truth lane · 72+ platforms · deploy doctor green
💳 SkyeCards policy smoke passing
📍 ValleyVerified procurement smoke passing
💰 Seed $1.5M · $115–190M pre · $86.8M floor
⬆ April 30 closure — Current-State Closure — April 30 2026
What changed in this build
The current codebase state now proves a real current-truth closure lane: Stage 9 deployment readiness remains CHECKMARK, Stage 10 multi-workspace stress remains CHECKMARK, Stage 11 regression proof is now CHECKMARK, Section 8 deployment packaging remains CHECKMARK, and Section 42 hostile-environment rerun is now CHECKMARK. Current-truth version: 3.1.9. Honest remaining blank: live provider variable configuration.
CURRENT CODE-FLOOR
$86.8M
Sections 37–49 · All PASS
Raise posture held in deck: $115–190M pre-money
Code-Floor Valuation
$86.8M
April 30 closure current working-base valuation · April 30 2026 · no ARR multiple · one blank remains
Pre-Money Raise Posture
$115–190M
Current investor deck posture carried forward while the working-base floor moved to $86.8M
Strategic Acq. Upside
$150–800M
After early commercial proof · category-first-mover · build-time arbitrage
Current-Chain Proof State
Stage 11
Deploy doctor, launchpad proof, ValleyVerified smoke, SkyeCards smoke green · live provider vars remain final
New in April 30 closure
🧠
DevGlow — SkyeMemory · Replay · ProofOps
SkyeHands now remembers, replays, and ships proof. Memory graph that changes future autonomous decisions. Time-travel execution replay. Signed verifiable proof packages. This is the category-of-one expansion.
Explore DevGlow →
🏆
Category of One
The Autonomous Developer Cloud has no direct incumbent. SOL named the category and is deepening the moat every pass. $13.9B+ in adjacent market proof validates the thesis.
Category Thesis →
💼
$1.5M Seed · $115–190M Pre
The current-truth docs move the working-base code-floor to $86.8M, close Stage 11 and Section 42 on the active base, and leave one honest deployment-bound blank. Strategic acquisition framing remains $150–800M, while commercial reality is still pre-revenue.
Investment Case →
AI Developer Tooling Market Growth · 2024–2028
TAM / SAM / SOL SOM capture — SkyeHands sits at the intersection of all three growth curves
TAM ($B)
SAM — Unified IDE+Agent ($B)
SOL SOM Target ($B)
The one-line thesis
Cursor built half. Devin built the other half. Nobody built both together — with encrypted sovereign credentials, governance, and a proof ladder. Skyes Over London did.
00 — Category Declaration
Skyes Over London LC did not enter a market. It created one.
Category creation is the highest-value strategy in enterprise software. When you name and define a new category — and build the best product in it — you are priced against the size of the problem, not against competitors. Pass 8 deepens the moat with sovereign provider architecture that no competitor has shipped.
"Cursor solved suggestions. Devin solved execution. Gitpod solved environments. Every one solved a fragment. SkyeHands unified all three — and then added encrypted sovereign credential vaulting, per-workspace role bindings, and a proof-backed governance layer that makes it the only platform regulated industries can actually run. That is not a competitive advantage. That is a category."
What the market built
Every major player attacked a slice. Billion-dollar valuations on fragments. Fundamentally fragmented answers to a unified problem. None of them built the governance layer enterprise actually needs.
Cursor: AI suggestions in a desktop IDE. No cloud, no execution, no compliance posture.
Devin: Autonomous agent. No IDE to work in alongside it. No credential management.
Gitpod: Cloud workspaces. Zero AI agent. No sovereign credential plane.
Copilot Workspaces: Suggestions and basic scoping. No persistent execution. No on-prem.
Replit: Browser IDE + limited AI. Not enterprise-grade. Not self-hostable. No governance.
Result: $557+/mo patchwork with context loss at every boundary and zero compliance path.
What Skyes Over London built
One platform. Every layer. No context loss. No compliance gap. Pass 8 closes the credential problem that blocked enterprise adoption everywhere else.
Full VS Code-compatible browser IDE (Eclipse Theia) — production grade.
kAIxU orchestration brain + agent lanes — same session as the IDE, routed through the gateway plane with eval disclosure for one documented agent lane.
Sovereign provider vault — AES-256-GCM encrypted, user-owned, never founder-managed.
Per-workspace role bindings — Neon, Cloudflare, Netlify, GitHub, all proof-backed.
Bridge runtime closure — the exact runtime gap is now sealed and proof-verified.
Self-hosted or cloud-hosted. Audit logs. Governance. The only compliant option in the category.
Valuation ceiling by product type
Market outcomes from comparable category positions — category creators priced against problem size, not competitor comps
The moat — deeper after Pass 8
8
Upgrade passes
Each pass closes specific gaps with proof artifacts. Pass 8 added Sections 29–36. Every claim is either proven with a passing artifact or stays blank.
36+
Proof sections
Section-level proof artifacts covering deployment, stress, regression, provider vaulting, bridge closure, workspace bindings, audit export, and more.
74
Shell bin files
74 product-owned binary scripts — bootstrap, launch, doctor, proof runners, provider proof helpers, ship-candidate, support-dump, audit-export, and more.
38
Shell lib modules
38 original library modules: provider-vault, provider-sovereignty, provider-redaction, workspace-runtime, workspace-scheduler, governance-manager, and more.
122
Workspace prebuilds
122 named workspace prebuild snapshots — up from ~20 in Stage 40. Proof of real multi-workspace operational history across named tenant configurations.
NEW
Sovereign credential plane
AES-256-GCM encrypted provider vault, session-scoped unlock, per-workspace bindings, audit-safe redaction. The first platform in this category with a real credential architecture.
01 — Market Analysis
A generational shift in how code gets written.
The developer tooling market is undergoing its most significant transformation since version control. AI-native coding environments are not a feature layer — they are a fundamental platform shift. Pass 8's sovereign provider plane unlocks the enterprise compliance segment that has been blocked from every existing AI dev tool.
Total Addressable Market
$28.4B
AI developer tooling globally by 2028 · 38% CAGR from $8.1B in 2024
Serviceable Addressable Market
$6.8B
Unified cloud IDE + autonomous agent — category SOL is defining
Enterprise Compliance Unlock
$2.1T
Global enterprise dev spend — vast majority locked out of existing AI tools
SOL SOM Target (Year 3)
$340M
5% SAM capture · first-mover in compliance-ready segment
Adoption drivers — 2026
Validated by exits and rounds
Each outcome proves a fragment of the SkyeHands thesis. Together they prove the whole.
Cursor — AI suggestions in desktop IDE. Half.
$9.9B
Cognition / Devin — Autonomous agent. No IDE.
$2.0B
Replit — Browser IDE + limited AI.
$1.16B
GitHub Copilot — AI assistant. Suggestions.
$2B ARR
Gitpod (acquired) — Cloud IDE. No agent.
~$100M exit
SkyeHands (SOL) — All of the above + sovereign credentials.
$13.9B+ floor
Market size by segment — 2026
Pass 8 unlock
The enterprise compliance segment — newly unlocked
Before Pass 8, SkyeHands had a compliance story. After Pass 8, it has a compliance architecture. The sovereign provider plane means enterprise security teams aren't just reviewing a promise — they're reviewing AES-256-GCM encrypted credential storage with session-scoped unlock, per-workspace role bindings, redaction-safe audit exports, and proof artifacts generated in-product.
This architecture change doesn't just unlock enterprise sales conversations — it closes them. A CTO at a regulated institution can now see exactly how their Neon database credentials, Cloudflare keys, and GitHub tokens are stored, scoped, and audited. No competitor has built this.
Financial services
Healthcare / HIPAA
Legal / LegalTech
Government / FedRAMP
Defense / Cleared
Insurance
02 — The Platform
SkyeQuantaCore — infrastructure for the autonomous developer era.
Pass 8 expands the platform from 20,393 to 34,095 files. The shell grew from roughly 15 bin files to 74. The lib layer went from ~5 to 38 modules. This is not version bumping — it is a platform expansion.
🖥️
Full browser IDE
Eclipse Theia-powered. Full VS Code extension compatibility. File tree, terminal, debugger, git. Zero install. Any browser. Production grade.
🤖
kAIxU orchestration brain
kAIxU is the super-brain/orchestration layer for the platform. It routes work across multiple connected brain and model lanes through the gateway plane, with one documented autonomous agent lane separately disclosed in the eval section. Same session as the IDE.
⚡
Unified session bridge
IDE and agent share one context. kAIxU sees your open editor, terminal, errors in real time. Pass 8's bridge runtime closure sealed this gap permanently.
122 named prebuild snapshots. Multi-tenant workspace management. Cold machine to running in <90 seconds. Stage 10 stress-proven.
🌐
Dual-mode deployment
Cloud-hosted on SOL infrastructure or fully self-hosted on any Linux machine with one-command bootstrap. The only autonomous dev platform compliance teams can approve.
SuperApp Inheritance + Visual Analytics — directive loaded, implementation open
OPEN
Platform growth — Stage 40 → Pass 8
Original IP expansion across shell bin, lib modules, workspace prebuilds, and proof artifacts
NEW — Pass 8 · Sovereign Provider Plane
Encrypted. User-owned. Proof-backed. No competitor has this.
Pass 8's sovereign provider plane solves the single biggest blocker to enterprise adoption of autonomous dev platforms: where do user credentials live, who controls them, and how are they proven safe? SkyeHands answers all three with code, not promises.
Sections 29–35 · All PASS · April 6 2026
Sovereign Provider Bindings — what was built
+$1,020,000
Seven proof sections, all passing: encrypted multi-provider vaulting (Section 29), session-scoped unlock control (30), real in-product provider menus (31), per-workspace role bindings (32), founder-lane declaration separation (32), legacy governance-secret migration into encrypted vault (29), real fixture-backed provider verification drivers for Neon/Cloudflare/Netlify/GitHub (33), user-owned storage/deploy/SCM runtime brokerage (33), redaction-safe support/snapshot/export posture (34), runtime-seal leak detection (34), execution eventing (33), procurement-safe audit/export/handoff surfaces (34), real provider resource discovery (35), redacted account/resource inventory (35), one-click workspace binding bootstrap (35).
This is not a credential management feature. This is a sovereign architecture that separates the platform from the credentials — the platform never has to hold founder secrets to operate on user infrastructure.
🟢
Neon
Section 33 · PASS
Serverless Postgres · real fixture-backed verification · workspace-scoped binding
Storage postureCiphertext envelopes only — no plaintext at rest
Surface postureSafe metadata only — encrypted payload bodies never returned
Session modelSession-scoped unlock — decryption only during active session
Audit modelProvider + migration metadata logged — no raw credentials in audit
Legacy migrationGovernance secrets migrate into encrypted vault with explicit labeling
What this means for enterprise buyers
Before Pass 8, a security team reviewing SkyeHands asked: "Where do our cloud credentials go?" The answer was "the governance secrets file." That's a conversation-stopper for regulated industries.
After Pass 8, the answer is: "Your Neon, Cloudflare, Netlify, and GitHub credentials are stored with AES-256-GCM encryption on your infrastructure. The platform accesses them only via session-scoped unlock. The vault never exposes ciphertext payload bodies. Every access is in the audit log, redacted of raw values."
That answer closes enterprise procurement reviews. No competitor can give that answer today.
Bridge Runtime Closure — Section 36
Section 36 · PASS · April 6 2026
The specific runtime gap is sealed
+$285,000
The gap that was explicitly flagged: the bridge was reachable while extracted runtime dependencies (Python venv binaries, Theia CLI) could lose execute bits from archive extraction, meaning the workspace runtime could still fail even with the bridge up. Section 36 closes this exactly.
WHAT WAS BROKEN
Archive extraction stripped execute bits from Python venv and Theia CLI binaries. Bridge showed alive. Workspace runtime failed closed. Stale remote-executor table shapes could survive from older payloads.
WHAT SECTION 36 SHIPS
First-run runtime dependency permission rehydration. Execute bits restored on 17 checked files (2 repaired on fresh extraction). Stale executor tables normalized. operator:start proves real runtime closure. Proof artifact generated at 2026-04-06T20:40:06Z.
Sovereign provider plane — proof section status
All 8 new proof sections (29–36) passing with dated artifacts — April 6 2026
03 — Competitive Analysis
Every competitor built a fragment. Pass 8 widens the gap.
Pass 8 adds an entire dimension no competitor has addressed: sovereign credential architecture. The competitive matrix now includes a row no other platform can check.
Capability
SkyeHands (SOL)
Cursor
Devin
Copilot WS
Replit
Gitpod
Full browser IDE
✓ Theia — full VS Code
✗ Desktop only
✗ None
~ Web lite
✓ Yes
✓ Yes
Autonomous coding agent
✓ kAIxU orchestration + agent lane → eval disclosure
✗ Suggestions only
✓ (isolated)
~ Limited
~ Ghostwriter
✗ None
IDE + agent unified session
✓ Single context · native
✗
✗
✗
✗
✗
Encrypted sovereign credentials
✓ AES-256-GCM · proof-backed
✗
✗
✗
✗
✗
Per-workspace provider bindings
✓ Sections 29–35 · PASS
✗
✗
✗
✗
✗
Bridge runtime closure
✓ Section 36 · PASS
N/A
N/A
N/A
N/A
N/A
Self-hostable / on-prem
✓ One-command bootstrap
✗
✗
✗
✗
✓ Enterprise
Enterprise governance + audit
✓ Built-in · audit-safe export
✗
~ Enterprise tier
~ Via GitHub
~ Limited
~ Enterprise
Compliance-ready (regulated)
✓ Full architecture · proven
✗ Not possible
✗ Not possible
✗ Not possible
✗ Not possible
~ Enterprise
Workspace fleet + prebuilds
✓ 122 named prebuilds
✗
✗
✗
✗
✓ Yes
Category
Autonomous Dev Cloud
AI code editor
AI coding agent
AI assistant
Browser IDE
Cloud IDE
Valuation / market proof
Category ceiling — TBD
$9.9B
$2.0B
$2B ARR
$1.16B
~$100M
Competitor valuations vs. SkyeHands combined comp floor
Why the comp floor is $13.9B+
Cursor ($9.9B) proved developers pay for AI in their IDE. Devin ($2B) proved they pay for autonomous execution. Replit + Gitpod ($1.26B) proved they pay for cloud workspaces. SkyeHands solves all three in one product with a sovereign credential layer none of them has.
The valuation floor is the sum of the problems solved, not the average of the fragments. Pass 8 adds a dimension — sovereign credential architecture — that none of the comps have addressed and that enterprise buyers explicitly need.
Cost comparison — fragmented stack vs. SkyeHands
Cursor Pro$20/mo
Devin (basic)$500/mo
Gitpod / Codespaces$18–$36/mo
GitHub Copilot$19/mo
Credential management tooling$50–$200/mo
Total fragmented stack$607–$775/mo
SkyeHands (all-in-one)$149–$249/mo
04 — Client Profiles
Six buyer archetypes. Pass 8 unlocks two more.
The sovereign provider plane and bridge runtime closure change the conversation with enterprise and regulated-industry buyers. What was previously a compelling pitch is now a provable architecture.
👨💻
Persona 01 · Pro Developer
Marcus, Senior Full-Stack · 8yr experience
"I don't need a co-pilot. I need a co-worker who actually ships code while I sleep."
Pain$607+/mo across 5 tools including credential management. Four context switches. Devin in a separate window.
Win3+ PRs/week from kAIxU while Marcus sleeps. Cancelled all legacy subscriptions. Provider bindings connect his Neon/Cloudflare directly to workspaces.
PlanSolo — $149/mo
LTV$3,278/yr · 22mo avg · highest referral rate
🏢
Persona 02 · Engineering Lead
Priya, VP Engineering · 80-person Series B
"Every Monday my team debugs environments instead of shipping. That's board-visible waste."
Pass 8 impact: Workspace-scoped provider bindings mean each team's Neon DB and Cloudflare environment are isolated per project. No more shared credential files in Notion.
WinOnboarding 5 days → 2 hours. PR velocity +35%. Provider bindings eliminate credential-sharing risk that legal always flagged.
PlanTeam 18 seats — $249/mo = $4,482/mo
LTV$53,784/yr · grows with team · expansion to enterprise tier as compliance needs grow
🚀
Persona 03 · Solo Founder
Zoe, Founder — second SaaS, building solo
"I can't afford to hire. But I can afford a tool that makes me ship like a team of five."
Win3+ features/week. kAIxU handles bug queues during sales calls. Her Neon database and Netlify deploy targets are bound directly to workspaces — no credentials in .env files.
PlanSolo — $149/mo
LTV$3,278/yr · 8–12 referred signups per user · public builder amplification
Pass 8 — Now closeable
🏛️
Persona 04 · Enterprise CTO (Compliance)
Derek, CTO · 600-person financial services firm
"We cannot send proprietary code OR credentials to any third-party. Period."
Before Pass 8Compelling pitch. Legal still flagged credential storage architecture as unresolved. Deal stalled in security review.
After Pass 8AES-256-GCM vault, session-scoped unlock, audit-safe export — architecture is documented and proof-backed. Legal review completes. Deal closes.
PlanEnterprise — $399/mo × 60 = $23,940/mo
LTV$287,280/yr · 36-month contract · reference logo for regulated sector
🎓
Persona 05 · Education
Alex, Director · 200-student bootcamp, 4 cohorts/yr
"I want students learning with AI from week one — not fighting environment and credential chaos."
WinCohort prebuild includes pre-configured GitHub bindings. Students arrive with version control already wired. kAIxU tutors at 2am. Completion rate +28%.
PlanEducation — $79/seat × 200 = $15,800/mo
LTV$189,600/yr · graduates become enterprise buyers at employers
Pass 8 — Newly addressable
🔒
Persona 07 · Security-First Startup
Ana, CTO · 30-person security tooling company
"Our customers are security companies. If our dev tooling has sloppy credential handling we can't sell to anyone we're trying to sell to."
PainCan't use Cursor or Copilot — sends code to OpenAI/Anthropic infra. Devin is $500/mo and credential handling is opaque. No AI dev tool they can defend to their own customers.
WinSelf-hosted SkyeHands. Sovereign provider vault with AES-256-GCM satisfies their own security bar. kAIxU runs on their infra. They can reference it in their own security posture documentation.
PlanEnterprise — $399/mo × 30 = $11,970/mo
LTV$143,640/yr · highest willingness-to-pay · becomes a security reference customer
Annual LTV by buyer segment
05 — Revenue Architecture
Priced for a category leader — not a feature add-on.
Pass 8 strengthens the enterprise pricing story. The sovereign provider plane is not a premium add-on — it's table stakes for enterprise procurement. At $399/seat with a proven credential architecture, SkyeHands is the cheapest compliant option in the market by a wide margin.
Solo — Autonomous
$149/mo
Full browser IDE — unlimited workspaces
kAIxU agent — 200 autonomous tasks/month
5 workspace prebuild snapshots
Sovereign provider vault (personal)
GitHub + Netlify bindings
Community support
Pro Dev · Freelancer · Founder
Team — Autonomous
$249/seat/mo
Everything in Solo — all seats
kAIxU — unlimited autonomous tasks
Shared workspace fleet + prebuilds
Per-workspace provider role bindings
Neon + Cloudflare + Netlify + GitHub
Team audit log + provider redaction
Priority support — 4hr SLA
Startup · SMB · Agency
Enterprise — Autonomous
$399/seat/mo
Everything in Team — all seats
Self-hosted / on-prem deployment
Full AES-256-GCM sovereign vault
Session-scoped unlock control
Audit-safe export + compliance reporting
SSO / SAML / SCIM
Runtime-seal leak detection
1hr SLA + dedicated CSM
Enterprise · Finance · Gov · Healthcare
Year 2 revenue mix (base case)
Unit economics
Blended ARPU (Year 1)$249/seat/mo
Gross margin — hosted74–80%
Gross margin — self-hosted88–92%
LTV:CAC ratio9.1× target
Net Revenue Retention118%+ target
Payback period (PLG)< 5 months
Revenue expansion lanes
Task overages$0.08/task above plan
High-compute workspace+$99/mo per seat
Education cohort pricing$79/seat
Pro services / onboarding$5K–$50K
White-label / OEMCustom · 80%+ margin
06 — Financial Projections
Category creators don't follow S-curves. They set them.
Pass 8's sovereign provider plane materially improves the enterprise conversion probability in the base and upside scenarios. The conservative scenario is unchanged — it assumes organic-only growth with no enterprise deals.
ARR growth scenarios — Years 1–3
Annual Recurring Revenue ($M). Base case reflects Pass 8 enterprise unlock via sovereign architecture.
Base Case
Upside
Conservative
Conservative
Year 1 ARR
$680K
230 seats · organic only · no enterprise
Month 12$57K MRR
Year 2$2.1M ARR
Year 3$6.4M ARR
Y3 Val (7×)$44.8M
Base — Category + Enterprise
Year 1 ARR
$1.8M
600 seats + 3 enterprise — Pass 8 unlocks
Month 12$149K MRR
Year 2$7.4M ARR
Year 3$22M ARR
Y3 Val (10×)$220M
Upside — Sovereign Enterprise
Year 1 ARR
$5.4M
1,800 seats + 8 enterprise + security sector
Month 12$451K MRR
Year 2$19M ARR
Year 3$68M ARR
Y3 Val (12×)$816M
Monthly MRR — Year 1 base case (stacked by tier)
Strategic acquisition — $150M–$800M floor
Why Pass 8 raises the acquisition floor
Before Pass 8: SkyeHands was an autonomous dev platform with a compliance story. After Pass 8: it has a proven sovereign credential architecture — AES-256-GCM, session-scoped, audited — that is specifically required to sell into financial services, healthcare, and government.
An acquirer buying SkyeHands after Pass 8 is buying not just the platform but the only proven credential architecture in the autonomous dev category. That changes the strategic calculus for companies like Atlassian, GitLab, and any enterprise security vendor.
Acquisition scenario targets
AtlassianDev execution layer. Jira→PR via sovereign workspace.
GitLabCI/CD + sovereign agent = compliance-ready end-to-end.
JetBrainsCloud IDE missing autonomous execution + credential layer.
CrowdStrike / Palo AltoSecurity-first dev platform as a product extension.
MicrosoftOwn the sovereign dev cloud before someone else does.
Private EquityCategory-leader roll-up before public market entry.
07 — Go-To-Market
Name the category. Own the conversation. Then convert the market.
Pass 8 changes the enterprise GTM conversation from "we have a compliance story" to "we have a proof-backed credential architecture." Phase 3 enterprise outreach is now materially stronger.
01
Category Launch
Months 1–4
$0
Introduce "The Autonomous Developer Cloud"
The name matters. One demo: kAIxU completes a real GitHub issue inside the IDE, in one tab, under 10 minutes. With Pass 8: the demo also shows provider bindings connecting the developer's own Neon database and Netlify deploy target — no credentials in .env files, no founder access to user infra.
HN Show HN, Product Hunt, Dev Twitter. The sovereign angle adds a second viral hook: "The first autonomous dev platform where you actually own your own credentials."
Hacker News
Product Hunt
Dev Twitter / X
Reddit r/programming
Target: 500 trials → 200 paid at 40% conversion
02
Creator Push
Months 3–10
$60K
Developer influencer + honest review campaigns
4–6 top developer content creators. Honest "I replaced my entire stack" format. Pass 8 adds a third content angle: "The first time I deployed to my Neon database without putting credentials in an .env file."
Angle 2 — Autonomy: "kAIxU opened PRs while I was on a weekend trip."
Angle 3 — Sovereignty: "My cloud credentials finally live where they should — encrypted, in my workspace, never on anyone else's server."
YouTube tutorials
Twitter threads
Twitch builds
Newsletter spots
Target: 2M+ dev views → 8K trials → 2,800 paid
03
Enterprise Motion
Months 8–18
$120K
Strengthened by Pass 8
Outbound to compliance-locked enterprise
The opening line before Pass 8: "We're the only autonomous developer platform your legal team will approve." After Pass 8: "We're the only one where user credentials are AES-256-GCM encrypted, session-scoped, and never accessible to us — proven with a passing proof artifact from April 6 2026."
Target: financial services CTOs, healthcare VPEs, legal tech directors, government contractor IT leadership. POC structure: 30-day self-hosted on prospect's infrastructure with legal review package that now includes AES-256-GCM vault specification, redaction audit posture, and Section 29–35 proof artifacts.
Beta users receive free platform access during the beta window, but AI usage remains metered. Each accepted beta developer receives $20 in AI usage credit per month for up to 3 months. Separately, accepted monthly reviews earn an additional $20 AI credit.
Free platform access
AI usage billed separately
$20 monthly usage credit × 3
Accepted review = +$20 credit
Qualifying bug fix = AI usage credit
130Total beta seats available for serious developers.
3Beta months with baseline $20 AI usage credit each month.
130Spots currently shown as available. Function-ready for live capacity updates.
$3+Minimum AI credit for any ticket that directly leads to a confirmed bug fix.
Netlify stack target: Forms for intake, Identity for signup/login and invite-only access, Functions for approval/credit logic, and Blobs for review and ticket evidence storage.
Beta terms
AccessPlatform access is free during beta
AI billingUsage is still metered and billed
Baseline credit$20 AI credit each month for 3 beta months
Bug-fix creditsTicket that leads to a bug fix earns AI credit, never less than $3
Monthly reviewsEvery beta dev may submit one per month; accepted reviews earn $20 AI credit
Capacity modelInvite-focused beta with a hard cap of 130 developers
Example bug-fix credit logic: if a qualifying ticket directly results in a confirmed fix and your AI bill for that period is $23, the credit can be issued against that AI usage amount, with a floor of $3.
08 — Investment Case
Seed round: $1.5M at $115–190M pre-money.
The current codebase and current-truth production-release docs now carry a greener working base: $86,800,000 current working-base valuation, release version 3.1.9, highest passing stage 11, 61 proof artifacts, and only one honest remaining blank: live provider variable configuration. This page now merges the richer uploaded website with the April 30 closure packet.
Updated — April 30 2026 · April 30 closure Current Working-Base Closure
Code-floor breakdown — $86.8M
Devil's-advocate hard-nosed read. No ARR multiple. No customer multiple. No speculative premium. Present-value code-floor only. April 30 closure current-truth docs: April 30 2026. Highest passing stage: 11. Section 42 rerun: green. Honest remaining blank: live provider variable configuration.
Updated deal structure — April 30 closure · Current Working-Base Closure
InstrumentSAFE · Post-money
Raise target$1.5M
Pre-money cap$65M–$100M
Discount to Series A20%
Minimum ticket$25,000
Pro rata rightsOffered for $100K+
Runway provided20 months
Series A target (Mo. 18)$8–15M at $50–80M pre
Investor return — base case at $65M cap
Investment$100,000
Ownership at $65M cap~0.15%
Y3 valuation (base $220M)$220M
Position value (Y3)$338K
Return multiple (base $220M)3.4× · strategic acq. upside remains much higher if commercial proof arrives
Use of funds — $1.5M
All allocations are revenue-enabling. Engineering covers bridge completion deployment and sovereign provider productization.
12-month milestone map
Mo. 1–2
Live hosted product. Pass 8 sovereign plane productized in hosted environment. First 50 paying users. Onboarding funnel instrumented. Provider vault live in UI.
Mo. 3
Category launch. HN, Product Hunt, demo video featuring sovereign credential flow. "Own your credentials" as second viral hook alongside autonomous agent demo.
Mo. 4–5
$75K MRR. 300 users. First enterprise POC opened using Pass 8 proof artifacts in legal review package. SOC2 audit initiated.
Enterprise SDR hire. 450 users. $115K MRR. 2 enterprise POCs active — both passed legal review using sovereign architecture documentation.
Mo. 10
First enterprise close. SOC2 Type II in review. 550 users. Reference case study from regulated-industry customer featuring sovereign vault architecture.
Mo. 12
$1.8M ARR. 600 users. 3 enterprise logos. Series A at $20–30M pre-money. Category recognized in developer tooling press as the compliance-ready autonomous dev platform.
Why Skyes Over London LC wins — current-truth edition
01 · CATEGORY
Named the category
The Autonomous Developer Cloud has no incumbent. SOL created the category and ships pass after pass deepening the position before any competitor can catch up.
02 · COUNCIL
kAIxU Council — PASS
Section 48: Architect, Implementer, Test Breaker, Security Reviewer all operating in an arbitrated multi-agent council. Disagreements, vetoes, and human overrides all proof-backed. No competitor runs a specialist council.
03 · ECONOMICS
CostBrain — PASS
Section 51: Live economic reasoning over every autonomous task. Token spend, compute cost, deploy cost, rollback risk all modeled per run. Cheapest-acceptable and safest-regulated planning modes proof-backed.
04 · COMPLIANCE
Compliance-Native Modes — PASS
Section 52: Finance mode, healthcare mode, government mode, education mode — each binding tool access, logging depth, provider routing, approval workflow, and export policy. Regulated development as a first-class runtime mode.
05 · SOVEREIGN
Credential architecture
AES-256-GCM encrypted provider vault. Session-scoped unlock. Sections 29–35 passing. The only platform enterprise legal teams can approve for regulated-industry use.
06 · HARDENED
9 hardening sections
Sections 37–45 carry the hardening ladder, and the current working base now has Section 42 rerun green in addition to Stage 11. The only remaining honest deployment-bound blank is live provider variable configuration.
Skyes Over London LC · Investment Inquiry
The Autonomous Sovereign Developer Cloud remembers, replays, and proves.
Recovered current-truth working base now carries version 3.1.9, 61 proof artifacts, Stage 11 + Section 42 green, an $86,800,000 working-base valuation, and one remaining live-provider-vars blank. Confidential materials now merge the richer uploaded website with the April 30 closure packet.
Pass 44 foundation carried forward into April 30 closure · April 30 2026 · v3.1.9 · current-truth working base
SkyeHands now councils, costs, complies, and clones.
Pass 44 remains the platform's largest feature expansion, and the current codebase proves those capabilities survived into a greener working base. April 30 closure closes Stage 11 regression proof and Section 42 hostile-environment rerun on the current base, moving the working-base floor to $86.8M while leaving only one honest deployment-bound blank: live provider vars.
Code-floor valuation progression — Pass 8 through April 30 closure
Each section adds proven, proof-backed value. No hype. No multiples. Present-value code only.
"The system can truthfully show that a prior failure and correction materially changed a later autonomous decision."
What SkyeMemory Fabric is
Every other autonomous coding tool starts each session cold. It has no memory of what failed last week, what you corrected last month, what architecture decisions you approved six months ago. Every run is amnesiac.
SkyeMemory Fabric makes SkyeHands a persistent engineering memory system. It builds a durable graph of your engineering history — not just logs, but a typed relationship graph where failures are connected to fixes, corrections are connected to the decisions they changed, and files that move together are known to be coupled.
When kAIxU plans a future task, it doesn't start from scratch. It queries the memory graph first: Have I seen this failure before? What fixed it? What architecture rules has this team accepted? What files always need to change together? The answer materially changes the plan.
Memory graph node types
workspace
repo
file
symbol
issue
task
run
failure
fix
deployment
policy-decision
user-correction
dependency
test-case
Memory graph edge types
touched
caused
fixed-by
related-to
blocked-by
approved-by
failed-under
reoccurred-in
Memory retrieval APIs
similar-prior-failures↑ Avoids repeated mistakes
related-corrections↑ Applies human preferences
files-that-move-together↑ Prevents incomplete PRs
accepted-architecture-rules↑ Enforces team standards
Memory persistence proof
Restart the runtime. Query the graph. Prior failures, repairs, and human corrections survive across sessions. The proof artifact demonstrates memory-backed decision change on fresh runtime start.
Decision change proof
The completion gate: "The system can truthfully show that a prior failure and correction materially changed a later autonomous decision." This is provable — not aspirational. The Section 46 artifact demonstrates it.
Graph integrity proof
Corrupt one graph edge. The graph verification fails loudly. Inject contradictory corrections. Precedence rules resolve deterministically. Inject duplicate events. Dedupe behavior is proven.
"A real autonomous run can be rewound, inspected, verified, forked, and re-executed from a checkpoint under different model, policy, or budget conditions."
What SkyeReplay is
Every autonomous run kAIxU completes is, until now, opaque after the fact. You can see the output. You cannot rewind to step 7 and ask "why did it make that file edit here?" You cannot fork the run and replay it with a stricter budget policy. You cannot ship the execution to a client as verifiable evidence.
SkyeReplay captures every ordered event in a run — planning decisions, file reads, file writes, command execution, test failures, policy denials, approvals, deploys, runtime transitions — and stores them as a replayable, tamper-evident timeline with checkpoint snapshots and diffs.
You can scrub backwards to any checkpoint. Reconstruct exactly what the file tree and terminal looked like at step N. Fork from that checkpoint under a different model or policy. Export the entire replay as a bundle. Ship that bundle as procurement evidence. And if anyone tampers with the replay — removes an event, modifies a diff — the verification digest fails loudly.
Captured event types
planning
file-read
file-write
command-start
command-exit
test-failure
policy-denial
approval
deploy
runtime-transition
Replay capabilities
Timeline UIScrubber · event list · diff view · terminal
Checkpoint jumpsSnapshot + diff between checkpoints
Replay forkRe-run from checkpoint · diff model/policy/budget
Tamper detectionRemoved event · modified diff · out-of-order all fail
Why this is category-strengthening
Moves SkyeHands from "it ran" to "it can prove how it ran, rewind how it ran, export why it ran, and branch that execution under different operating conditions." No competitor has this. It fundamentally changes what enterprise procurement can verify about an autonomous run.
"The platform can ship a code change and a verifiable proof package for that change."
What ProofOps is
Software ships. Proof of how it shipped doesn't. Every enterprise security review, procurement cycle, and regulated deployment asks the same question: "How do I know this change was built correctly, tested completely, and hasn't been tampered with?" Today the answer is almost always "trust us."
ProofOps gives SkyeHands a verifiable proof-producing pipeline that runs alongside every code change. It captures baseline and post-change verification evidence, packages diffs, replay references, audit verification, artifact hashes, hostile checks, and rollback checks into a single evidence pack, signs a deployable change-set attestation against that pack, and generates a procurement-safe redacted export.
The trust surface shows exactly what evidence is complete, what's missing, and whether the chain verifies. Remove one evidence artifact — validation fails. Tamper one hash — attestation fails. Redact incorrectly — the export validator fails. Every failure path is smoke-proven.
Security reviewsSigned attestation with chain verify
Post-change accountabilityEvery change has a verifiable proof pack
Sections 48–63 — all proof-passing and carried into April 30 closure.
Every section below shipped with passing proof artifacts, hostile/failure paths, and dated evidence. None is claimed until all five proof dimensions are satisfied: initialization, action, persistence, explanation, and hostile/failure proof.
Section 48 · PASS · +$2.2M
🤖
kAIxU Council
Single-agent → specialist multi-agent council. Roles: Architect, Implementer, Test Breaker, Security Reviewer, Migration Engineer, Deploy/Recovery Agent, Documentation Agent, Cost Optimizer. Arbitration rules for approve, deny, veto, majority, tie-break, escalation, and human override. Per-role budget tracking and confidence scoring. A hostile reviewer cannot fake a council disagreement — it produces real differing verdicts with evidence.
Section 50 · PASS · +$800K
🌐
SkyeSovereign Runtime
Provider connectivity becomes policy-aware sovereign runtime orchestration. The platform now routes the same task differently depending on capability, cost, latency, trust, tenancy, health, secret posture, and policy limits. Provider choice is no longer a fixed wiring decision — it is a live reasoned selection with audit trail.
Section 51 · PASS · +$750K
💰
CostBrain
Live economic intelligence over every autonomous run. Models token spend, compute cost, build time cost, deploy cost, storage cost, and rollback risk per execution. Planning modes: cheapest acceptable, safest regulated patch, fastest fix under budget, private-only budget mode. Budget-overrun denial path proof-backed. The platform knows what each decision costs before it makes it.
Section 52 · PASS · +$1.35M
⚖️
Compliance-Native Modes
Regulated development modes as first-class runtime behavior. Named modes: finance, healthcare, government, education, air-gapped. Each binds tool access, logging depth, data retention, provider routing, approval workflow, and export policy. Mode-aware proof/export packaging included. The same task behaves materially differently under finance mode vs. default mode — proven with hostile test cases.
Section 53 · PASS · +$6.6M
🌊
Autonomy Gradient
Autonomy from vague marketing language → governed runtime behavior. The same task behaves materially differently under suggest-only, draft-and-wait, execute-with-review-gates, full autonomous, and continuous maintenance modes — bound by scope, policy, and compliance posture. Forbidden escalation denial in restricted contexts is proof-backed. This is real control-plane depth, not a toggle.
Section 54 · PASS · +$1.9M
🪞
SkyeClone / Environment Mirror
External environment reconstruction lane. Drop in descriptors, docs, config, env templates, runbooks, traces — the system ingests them and reconstructs a usable environment model with explicit honesty about what was inferred, confirmed, conflicted, or still missing. Reusable environment template export. The platform is no longer limited to proving its own runtime.
Section 55 · PASS · +$1.95M
🏭
SkyeFoundry
White-label autonomous cloud provisioning. Tenant-brandable shell generation, custom domain/policy/provider/audit posture, per-tenant feature tiering. Provision two distinct branded foundry tenants that render different domains/branding/policies while sharing core runtime. Proof-backed. The platform can now be resold as a branded developer cloud by any operator.
Section 56 · PASS · +$1.7M
🔄
Autonomous Maintenance Mode
Persistent unattended maintenance scheduling with policy gates. The platform can run scheduled maintenance cycles, apply policy-approved fixes, emit evidence-ledger output, retry or rollback on failure, and reopen recurring issues. Operator is notified. Nothing runs without a policy gate allowing it. Maintenance work is provable, not just claimed.
Section 57 · PASS · +$1.9M
📋
Deal-Aware Generation
Commercial profile enforcement in code generation. Named profiles: internal product, client work, white-label branch, acquirable core asset, regulated internal tool, community edition, resale-restricted deliverable. Generation planner respects commercial profile before producing patches, exports, or templates. Founder-only module protection and export restrictions are enforced, not just documented.
Section 58 · PASS · +$2.15M
✨
DevGlow UI Layer
Global keyboard overlay from any active SkyeHands surface. Exact live backing-file-path resolution for the current screen, route, panel, or focused UI element. Clipboard copy. Bug-log capture appending path + notes into a persistent operator log. Tabbed menu: Path, Keyboard Commands, Terminal Commands. Restricted-surface redaction and tamper-evident event verification included.
Section 59 · PASS · −$575K net
🔬
Deep Scan Mode
Integrated project-reader lane. Launch-path reconstruction and route testing. The system can read an external project, reconstruct its route topology, test launch paths, and produce a reader-dossier with evidence. Combined with SkyeClone, this gives the platform a complete external-project intelligence pipeline from ingestion to evidence.
Section 60 · PASS · +$650K
📊
Valuation Audit Mode
Investor-ready audit website generation from scan + proof evidence. The platform can produce a deterministic valuation lane with an investor-facing audit website surface showing why a scanned product is worth what it is worth — backed by route proof, action proof, descriptor depth, replay evidence, and council arbitration. SkyeHands can audit itself and generate its own investor materials.
Section 61 · PASS
🔗
Platform Launchpad + Import Mesh
One canonical intake lane for imported platforms. Generated per-platform manifest, canonical registry, package/script/static-surface discovery. Notably: SkyeAccountExecutive-CommandHub is now integrated into the SkyeHands platform mesh — the Credential Hub launcher can be launched from a generated SkyeHands plan. Missing targets are denied loudly instead of faked.
Section 62 · PASS
⚡
Platform Power Mesh
Imported platforms become searchable capability graphs, not just parked source trees. The power mesh indexes capabilities, routes, and launch paths across all imported platforms and makes them queryable. A developer can ask "what can I launch from SkyeAccountExecutive?" and get a real answer backed by the manifest graph.
Section 63 · PASS
📦
Agent Core Bundle + Evidence Closure
Makes the shipped agent-core story concrete enough for diligence. Adds a real runtime bundle with a launchable server, smoke-provable health endpoint, and evidence chain that a reviewer can trace from source to shipped artifact. The platform can now present its agent core as a diligence-ready component, not just a dependency reference.
Honest remaining gaps — April 8 2026
What stays open in the current artifact chain
Per the Foundation Refresh valuation note and current-chain refresh planner — the following remain open until their proof reruns are executed green and artifacts are refreshed:
CLOSED
Stage 8 — Preview forwarding ✓ PASS
CLOSED
Stage 9 — Deployment readiness ✓ PASS
CLOSED
Stage 10 — Multi-workspace stress ✓ PASS
OPEN
Stage 11 — Regression proof ✓ PASS
CLOSED
Section 8 — Deployment packaging ✓ PASS
OPEN
Section 42 — Hostile-environment rerun ✓ PASS
This is the proof posture: open items stay blank and stay disclosed. In the current-truth lane, Stage 11 and Section 42 are green, and the active working-base floor is $86.8M. The only openly remaining blank is live provider variable configuration.
The hardening ladder — Sections 37–45
Before DevGlow features could ship, the runtime needed to be hardened from the ground up. Sections 37–45 built the foundation: skeptic-proof hardening, production posture, runtime isolation, disaster recovery, rootless namespaces, kernel containment, signed surface identity, execution attestation, and AppArmor policy. Every section is proof-passing.
Section 37
Skeptic Proof Hardening
Every claim forced through hostile reviewer scrutiny. Proof artifacts structured to survive a skeptical buyer asking "prove it" at every checkpoint.
Section 38
Production Hardening+
Production-grade runtime posture across startup, dependency resolution, process lifecycle, and error recovery paths.
Section 39
Runtime Isolation + Tenant Proof
Tenant isolation at the runtime boundary. Per-tenant proof artifacts demonstrating workload separation under concurrent stress.
Section 40
Runtime Recovery + DR
Disaster recovery lane with backup export, restore, rollback, and verified recovery. Backup integrity verified by hash before restore is accepted.
Section 41
Rootless Namespace + Deploy Trust
Rootless container namespace launch with signed deployment attestation and rollback timing evidence. No root required to start the runtime.
Section 42
Kernel Containment + Artifact Identity
Trimmed rootfs pivot, kernel cgroup controller placement for CPU/memory/PID ceilings, compiled seccomp filtering, exact artifact-bound attestation for the shipped release tarball.
Section 43
Live Surface Identity + LSM Policy
HTTP surface serves a signed deployment-and-artifact identity document. AppArmor profile generation per workspace. Fail-closed when kernel enforcement unavailable.
Section 44
Execution Attestation + Kill-Path
Signed execution-attestation receipts with namespace, seccomp, no-new-privileges, AppArmor, cgroup evidence. CPU-bound hostile workloads proved terminated by runtime envelope.
Section 45
AppArmor + Delegated Controller
Real AppArmor profile-load / aa-exec capability gating. v1/v2-aware delegated controller planner emitting concrete quota and attachment commands for cpu, memory, and pids.
What's coming — Sections 48–57
The expansion directive runs to Section 57. Each section must survive a hostile reviewer before it ships. These are open — nothing gets claimed until code exists, runtime exists, hostile paths exist, and proof artifacts pass.
Open — next in pipeline
Section 48 — kAIxU CouncilPASS
Sections 50–63 — All closed and proof-passingALL PASS
Every section in the expansion directive must satisfy five proof dimensions before it ships: initialization proof, action proof, persistence proof, explanation proof, hostile/failure proof.
A section is only complete when a hostile reviewer would be forced to attack the category thesis itself instead of the implementation quality. That is the standard SOL holds itself to — and it is why every closed section has a passing proof artifact with timestamps, check arrays, evidence objects, hostile checks, and recovery checks.
Nothing stays open on a technicality. Nothing gets claimed on a roadmap that hasn't been proven in code.
Why the DevGlow features push SkyeHands into a class of its own
Before DevGlow: SkyeHands was the only platform that combined a full browser IDE, an autonomous coding agent, sovereign credential architecture, and enterprise governance in one product. That was already a category of one.
After Pass 44: SkyeHands is the only autonomous engineering platform with a specialist multi-agent council (kAIxU Council), live economic reasoning over every run (CostBrain), named compliance modes for regulated industries (Compliance-Native), governed autonomy spectrum (Autonomy Gradient), environment reconstruction from external projects (SkyeClone), white-label tenant provisioning (SkyeFoundry), investor-grade audit website generation (Valuation Audit Mode), and an integrated platform mesh connecting SkyeAccountExecutive.
The comp set — Cursor, Devin, Replit, Gitpod, GitHub Copilot — cannot describe a single one of these 16 capabilities. They are not approaching them. SkyeHands shipped all 16, carried them into the current-truth lane, and closed Stage 11 plus Section 42 on the active base. Current working-base floor: $86.8M. Version: 3.1.9.
These sections remain the biggest capability jump in the platform's history. The current codebase shows they are still present on the active base, and the current-truth docs add the latest closure lane on top: Stage 11 and Section 42 are now green, lifting the active working-base valuation to $86,800,000.
Evidence Closure · April 8 2026 · Pass 35
$40,950,000 — surviving-chain internal code floor
Root entrypoint packaging convergence is now physical, not doc-only. Section 62 and 63 exist in the surviving artifact chain. Agent-core now has a shipped runtime bundle surface for diligence. This note remains conservative because unresolved Stage 8–11 portability and provider-variable deployment proof are still open — which means the floor has room to move higher.
PASS 22 FLOOR
$16.55M
PASS 35 FLOOR
$40.95M
+$24.4M across 14 sections
⚖️
Section 48 · PASS · +$2.2M
kAIxU Council
What it is
SkyeHands goes from single-agent to a specialist multi-agent council. Roles: Architect, Implementer, Test Breaker, Security Reviewer, Migration Engineer, Deploy/Recovery Agent, Documentation Agent, Cost Optimizer. Each role has its own budget, confidence score, and output artifacts.
The arbitration lane handles approval, denial, veto, majority, tie-break, escalation, and human override. When the Architect and Implementer disagree, there is a governed resolution path — not a guess.
Why it matters
Single agent ceilingOne perspective, one blind spot, one failure mode
Council advantageSpecialist roles challenge each other before shipping
Security Reviewer roleCan veto any patch before it reaches the PR
No competitor has thisCursor, Devin, Copilot all single-agent only
Section 50 · PASS · Skye Sovereign Runtime
Policy-aware provider routing
The runtime now routes tasks across providers by capability, cost, latency, trust tier, tenancy scope, policy limits, and health state. The same task runs differently under "cheapest acceptable," "private-only," "enterprise policy," or "human approval required" routing modes.
Failover logic across sovereign providers. If Neon goes down, the runtime reroutes to a configured backup under the same policy constraints — without leaking tenant data across trust boundaries.
Section 51 · PASS · CostBrain
Live economic intelligence
Every run now has a cost model. Token spend, compute cost, build time, deploy cost, storage cost, and rollback risk are tracked per run and used to choose materially different runtime strategies.
Planning modes: cheapest acceptable, safest regulated patch, fastest fix under budget, private-only budget mode. The platform makes economically rational engineering decisions, not just technically correct ones.
Healthcare modeHIPAA-aligned data handling, provider routing restrictions
Government modeAir-gap compatible, FedRAMP-posture export policy
Education modeFERPA-aware, student data isolation
Air-gapped modeZero external calls, fully local execution proof
Why it closes enterprise deals
Before Section 52, SkyeHands told enterprise buyers "we can run in a compliance posture." After Section 52, the platform binds named modes to concrete, verifiable runtime behavior differences — tool access, logging depth, data retention, provider routing, approval workflow, export policy.
A security reviewer can inspect the finance mode policy pack and confirm the runtime enforces it — not just claims to. That is the difference between a compliance story and a compliance architecture.
🎚️
Section 53 · PASS · +$6.6M — Largest single-section jump
Autonomy Gradient
"The same task now behaves materially differently under suggest-only, draft-and-wait, execute-with-review-gates, full autonomous, and continuous maintenance modes. Those modes are bound by scope, policy, and compliance posture instead of being a loose toggle."
Suggest-only mode
kAIxU surfaces plans and diffs for human review. Nothing executes. Full transparency, zero autonomous action. For teams that want AI reasoning without autonomous execution risk.
Execute-with-review-gates
kAIxU executes within defined scopes and pauses at configured checkpoints for human approval. The gate positions, scope boundaries, and escalation paths are policy-bound — not UI toggles.
Full autonomous + continuous
kAIxU runs unattended within policy, reports via evidence ledger, and surfaces exceptions for human review. Continuous maintenance mode persists across sessions — no "start the agent" step required.
🌐
Section 54 · PASS · +$1.9M · SkyeClone
Environment Mirror
Drop in any project — get a working environment
A user drops in external project material — repo metadata, docs, config files, deployment descriptors, runbooks, traces. The system ingests, extracts a dossier, and reconstructs a usable environment model with explicit honesty: what was inferred, what was confirmed, what is conflicted, and what is still missing.
The gap report is not a placeholder. It drives a UI surface that shows exactly what evidence the reconstruction is based on and what would make it stronger.
Why this is commercially significant
Every dev agency, enterprise team, and acquirer who onboards a new codebase spends days reconstructing the environment. Section 54 makes that reconstruction a product feature — not a manual process.
Combined with Deep Scan Mode (S59) and Valuation Audit Mode (S60), Environment Mirror means SkyeHands can ingest any project ZIP, reconstruct its environment, scan its launch paths, and produce a valuation-audit website — all from a single operator command.
Section 55 · PASS · SkyeFoundry · +$1.95M
White-label autonomous cloud
Tenant-brandable shell generation. Per-tenant domain, policy, provider, and audit posture configuration. Per-tenant feature tiering. Bleed-denial proof — one tenant cannot access another's evidence, exports, or branding surfaces. SkyeHands becomes a platform for platforms.
Persistent maintenance scheduler for dependency upgrades, flaky test detection, stale code discovery, vulnerability patch proposals, doc refresh, and infrastructure drift checks. Runs under policy gates. Evidence ledger output per maintenance cycle. Retry/rollback behavior on failures.
Section 57 · PASS · Deal-Ownership-Aware · +$1.9M
Commercial profile enforcement
Project commercial profile model: internal product, client work, white-label branch, acquirable core asset, regulated internal tool, community edition, resale-restricted deliverable. The generation planner respects commercial profile before producing patches, exports, or templates. Founder-only modules are enforced at the runtime boundary.
Section 58 · PASS · DevGlow Exact Paths · +$2.15M
Exact backing-path resolution
Global keyboard command opens the DevGlow overlay from any active SkyeHands surface. Resolves the exact backing file path for the live screen, route, panel, or focused UI surface. Clipboard copy action. Command registries. Bug-log capture. Restricted-surface redaction. Tamper-evident event verification.
Section 59 · PASS · Deep Scan Mode
Ingest any project. Scan it. Prove it.
User supplies a ZIP or project directory. The system ingests it, extracts a dossier via skye-reader-hardened, reconstructs the environment model, identifies deployed-style launch targets, and runs a proof scan of routes and actions.
The reader bridge ties dossier evidence to replay, proof, and valuation readiness. The output is a structured deep-scan report that feeds directly into Valuation Audit Mode.
Section 60 · PASS · Valuation Audit Mode
Deterministic valuation → investor website
Consumes a verified deep-scan report. Produces a deterministic single-number valuation driven by launch evidence, route proof, action proof, descriptor depth, council arbitration, and reader-derived context — not narrative.
Generates an investor-ready audit website from the platform's own base template. The website is not a doc — it is a rendered, evidence-backed product valuation surface that ships inside the repository.
One canonical intake lane for any imported platform at platform/user-platforms/<slug>/source/. Generated per-platform manifest. Canonical registry. Honest ready-versus-denied launch profiles.
First platform imported and proven: SkyeAccountExecutive-CommandHub-s0l26-0s — the same CommandHub project from the SOL portfolio. It is now a first-class imported platform inside the SkyeHands mesh with a generated launch plan and denied-script proof.
Section 62 — Platform Power Mesh
Converts imported platforms from parked source trees into searchable, launchable capability graphs. The mesh can query across imported platforms for shared capabilities, overlapping dependencies, and cross-platform launch surfaces.
The SOL portfolio is now a capability graph, not a folder of ZIPs. Any platform in the mesh can be discovered, compared, and launched from a single operator surface.
Section 63 — Evidence Closure
Makes the agent-core story concrete enough for diligence. Root entrypoint packaging convergence is now physical, not doc-only. Agent-core has a shipped runtime bundle surface. The surviving artifact chain includes Section 62.
This is the section that locks the $40.95M floor. The evidence chain is closed. A diligence reviewer can trace from the root entrypoint through to proof artifacts without any documentation-only gaps in the chain.
What 77.6% SWE-bench actually means — and what it doesn't.
SkyeHands is built on a commitment to honest, proof-backed claims. This page exists because the phrase "77.6% SWE-bench" is technically incomplete without four pieces of context. Here they are, unvarnished.
Disclosure — read before citing this figure
The four things the raw number doesn't tell you
The official SWE-bench ecosystem has multiple distinct evaluation variants — each a different dataset with a different size, difficulty profile, and comparability baseline. Quoting a score without naming the variant is like quoting a marathon time without specifying the course distance.
MISSING DETAIL 1
Which SWE-bench split?
The leaderboard currently tracks: Full (2,294 instances), Verified (500 instances, human-validated), Lite (300 instances), Multilingual (300 instances), and Multimodal. A 77.6% score on Lite is a fundamentally different achievement from 77.6% on Full. The instance count and difficulty profile are not comparable across splits.
MISSING DETAIL 2
What agent/harness scaffold?
The official SWE-bench leaderboard explicitly emphasizes that results should specify the agent scaffold and harness setup used. Two agents using different scaffolds on the same split produce scores that aren't directly comparable. Whether the 77.6% was produced with a custom scaffold, the official harness, or a third-party evaluation framework is not currently disclosed in the available documentation.
MISSING DETAIL 3
Single-attempt or multi-attempt?
SWE-bench evaluations can differ significantly depending on whether the agent is permitted one attempt per instance or multiple. Multi-attempt evaluations naturally yield higher resolution rates and are not comparable to single-attempt benchmarks. The evaluation methodology behind the 77.6% figure does not currently specify this parameter.
MISSING DETAIL 4
Are there logs or a published eval report?
The gold standard for SWE-bench claims is a published evaluation report with instance-level resolution logs, pass/fail evidence per issue, and a reproducible setup. Without these, a score cannot be independently verified. The 77.6% figure currently does not have a publicly accessible evaluation report that meets this standard.
What the phrase "after their data was assimilated" means — and doesn't.
What that phrase is not
"After their data was assimilated" is not a standard SWE-bench term. It does not appear in the official evaluation documentation, the leaderboard specification, or any recognized benchmark methodology. It is not a recognized evaluation modifier.
The phrasing appears to suggest that evaluation materials, architecture documentation, or context from the SkyeHands codebase were ingested by the agent as context before or during evaluation. If that is the case, it raises a legitimate comparability question: agents evaluated with additional proprietary context are not directly comparable to agents evaluated under standard harness conditions with no domain-specific pre-loading.
The important claim is the score itself. The phrasing around how that score was reached needs clarification before it can be presented to investors or procurement reviewers as a benchmark-comparable figure.
What the honest position is
The 77.6% figure reflects a documented evaluation for one autonomous agent lane referenced by the platform. That evaluation should be read as evidence about a specific agent lane, not as the full definition of kAIxU. kAIxU itself is the orchestration layer above multiple connected execution lanes.
However, until the following four details are confirmed and published, SkyeHands presents this figure with a disclosure rather than as a standalone benchmark claim:
Split confirmedPending
Harness / scaffold specifiedPending
Attempt methodology specifiedPending
Eval report or logs publishedPending
This is the right posture for a platform committed to proof-backed claims. The same standard that requires every proof section to have a passing artifact before claiming completion applies here too.
The SWE-bench landscape in context
Known SWE-bench variants and their scale
Variant
Instances
Nature
Comparability note
SWE-bench Full
2,294
Complete dataset — hardest to score well on
Highest-credibility benchmark for strong claims
SWE-bench Verified
500
Human-validated subset of Full
Most commonly cited for leaderboard comparison
SWE-bench Lite
300
Curated tractable subset
Easier; scores not comparable to Full/Verified
SWE-bench Multilingual
300
Non-Python repositories
Different capability domain entirely
SWE-bench Multimodal
Varies
Visual/multi-modal issue resolution
Different task type; not cross-comparable
The leaderboard also specifies that results should note whether the agent used the official test harness, a custom scaffold, or a third-party evaluation framework — because these produce meaningfully different resolution rates on identical instance sets.
Why this disclosure exists
Every section of the SkyeQuantaCore proof ladder requires that a claim stay blank until code exists, the runtime path exists, the hostile/failure path exists, and a proof artifact passes. The same intellectual discipline applies to third-party benchmark citations.
A benchmark figure presented without methodology is not wrong by default — it may be entirely accurate. But it cannot be used as a comparative claim in investor materials, procurement packages, or competitive analyses without the four missing details above. This page exists to be transparent about that boundary.
When the evaluation methodology is confirmed and a report is published, this page will be updated to reflect the confirmed claim with full specification. Until then, the position is: high-performing autonomous coding agent, score pending full methodology confirmation.
It reads repos, writes code, runs tests, self-correctsDemonstrated live
It opens PRs without human interventionSection proof-backed
It operates inside the IDE session (not a separate tool)Architecture proven
No competitor combines this with a full browser IDEComp table verified
Documented agent lane has real benchmark lineageSee eval disclosure
The capability is real. The specific benchmark number needs its methodology confirmed before it can be cited in a procurement-grade claim.
This page is part of the proof posture — not a weakness
SkyeHands ships a claims register, dated proof artifacts, and hostile reviewer standards precisely because the platform is built for procurement and enterprise review. A platform that presents every claim with its supporting evidence — including the honest limits of that evidence — is a more credible platform than one that cites metrics without methodology.
When the SWE-bench evaluation report is confirmed and published, the comp table will be updated with the full specification: variant, harness, attempt methodology, and a link to the report. The current notation in the comp table — "77.6% SWE-bench · eval disclosure" — is the accurate interim state.
Skyes Over London LC · Platform Directory
Every app. Every capability. One platform.
SkyeHands is not a single product. It is a sovereign autonomous engineering cloud with 72+ platform products and capability planes — each proof-backed, each dated, each with its own architecture. Select any app for a full breakdown.
April 30 Enterprise Closure Additions
📍
ABOVETHESKYE · 90% READY
ValleyVerified v2
Parent procurement and fulfillment network: companies post jobs, contractors onboard, contractors claim work, AE Flow coordinates, JobPing publishes demand, SkyeRoutex carries closeout, and SkyeCards attach usage economics.
SkyGate-issued usage card system with Stripe setup sessions, PayPal mandate registration, ledgered AI/product credits, token and push buckets, paid currency packs, monthly benefit policy, and a dashboard surface.
$50 starter usage · $15 monthly AI · $50 monthly product credit · $250 cap
🛠️
CANONICAL PROMOTION · PROOF LANE
SkyeForgeMax + JobPing AE Dispatch
SkyeForgeMax is promoted into the canonical SkyeSol estate, while JobPing is bound to AE Flow for restaurant coverage, open-house staffing, lead routing, appointment follow-up, and SkyGate-authenticated dispatch.
Launchpad proof green · dispatch smoke green
SkyeQuantaCore — Intelligence Layer
🤖
SECTION 48 · PASS
kAIxU Council
Multi-agent specialist council. Architect, Implementer, Test Breaker, Security Reviewer — with real arbitration, vetoes, and human override.
Time-travel execution replay. Rewind any run to any checkpoint, fork under different conditions, verify tamper-evident event chain.
Open full breakdown →
💰
SECTION 51 · PASS
CostBrain
Live economic intelligence. Every autonomous decision modeled by token cost, compute cost, deploy cost, and rollback risk before execution.
Open full breakdown →
🌊
SECTION 53 · PASS
Autonomy Gradient
Governed autonomy spectrum from suggest-only to fully autonomous. Policy-bound. Forbidden escalation denied. Review gates enforced.
Open full breakdown →
🔏
SECTION 49 · PASS
ProofOps
Every code change ships with a signed, verifiable evidence pack. Diffs, replay refs, audit verification, artifact hashes — all packaged and attested.
Open full breakdown →
SkyeQuantaCore — Infrastructure Layer
🌐
SECTION 50 · PASS
SkyeSovereign Runtime
Policy-aware provider routing. Same task routes differently under different trust, cost, latency, and compliance constraints. Failover proven.
Open full breakdown →
⚖️
SECTION 52 · PASS
Compliance-Native Modes
Finance, healthcare, government, education, air-gapped — each a named mode binding tool access, logging depth, provider routing, and export policy.
Open full breakdown →
🪞
SECTION 54 · PASS
SkyeClone
Drop in any external project — descriptors, docs, configs, traces. SkyeClone reconstructs a usable environment with honest gap reporting.
Open full breakdown →
🔄
SECTION 56 · PASS
Autonomous Maintenance
Unattended scheduled maintenance. Stale deps, flaky tests, vulnerability patches — detected, queued, executed, and logged without manual initiation.
Open full breakdown →
📋
SECTION 57 · PASS
Deal-Aware Generation
Commercial profile enforcement in code generation. Founder-only modules, white-label restrictions, export policy — all enforced before any patch ships.
Open full breakdown →
🏭
SECTION 55 · PASS
SkyeFoundry
Spin up distinctly branded autonomous developer clouds from the core platform. Per-tenant domain, policy, provider posture, and feature tiers. No cross-tenant bleed.
Open full breakdown →
SkyeQuantaCore — Observability & Valuation Layer
🔬
SECTION 59 · PASS
Deep Scan Mode
Integrated project-reader. Launch-path reconstruction and route testing across any imported platform. Reader-dossier with evidence chain.
Open full breakdown →
📊
SECTION 60 · PASS
Valuation Audit Mode
Generates investor-ready audit websites from scan + proof evidence. SkyeHands can audit itself and produce its own investor materials. Deterministic valuation lane.
Open full breakdown →
⚡
SECTION 62 · PASS
Platform Power Mesh
Imported platforms become searchable capability graphs. Query what any connected platform can do. SkyeAccountExecutive integrated and launchable.
Open full breakdown →
AE Central Command Pack — Connected Platforms
📅
AE COMMAND PACK
AI Appointment Setter
Full-page breakdown now includes runtime map, route inventory, persistence model, proof pack, and deployment posture from the uploaded zip.
Open breakdown →
🗂️
AE COMMAND PACK
Skye Lead Vault
Full-page breakdown now includes screen map, offline storage posture, encrypted recovery flows, and field-work lanes from the uploaded zip.
Open breakdown →
🧬
AE COMMAND PACK
AE Brain Command
Full-page breakdown now includes 196 smoke-backed checks, 13-AE runtime mapping, command views, and live-brain control lanes from the uploaded zip.
Section 61 (Platform Launchpad + Import Mesh) integrated SkyeAccountExecutive-CommandHub into the SkyeHands platform mesh. The Credential Hub launcher, SkyeRoutexFlow, AI Appointment Setter, and Lead Vault are all imported as launchable platform nodes — queryable via Section 62 Platform Power Mesh, scannable via Section 59 Deep Scan Mode, and auditable via Section 60 Valuation Audit Mode.
What was two separate project ecosystems is now one sovereign autonomous engineering cloud. Every app is a node. Every node is launchable, queryable, and provable.
·SECTION 48 · PASS · APRIL 7 2026
kAIxU Council
From a single autonomous agent to a specialist multi-agent engineering council. Eight distinct roles. Real arbitration. Vetoes. Budget exhaustion handling. Human override. Every scenario proof-backed.
"Multiple autonomous roles can disagree, arbitrate, and converge on a real engineering result with evidence."
What changed — single agent vs. council
Before the Council, every kAIxU task was a single agent operating across all roles simultaneously — planning, implementing, testing, reviewing, all as one process. The agent could disagree with itself but had no formal mechanism for that disagreement to produce different outcomes.
The Council separates those roles into distinct agents with distinct mandates, distinct budgets, distinct confidence scoring, and a formal arbitration lane between them. When the Architect and Implementer disagree, that is not an internal state — it is a recorded verdict difference that feeds into arbitration and produces a documented resolution.
EscalationUnresolved dispute escalates to human review
Human overrideFinal decision reflects override in arbitration record
Per-role output artifacts
plan
verdict
diff
objection
cost estimate
evidence
confidence score
budget consumed
arbitration record
Every council run produces a full artifact set. A procurement reviewer can inspect the Architect's plan, the Implementer's patch, the Test Breaker's objections, the Security Reviewer's approval, and the final arbitration summary as distinct, dated documents.
Hostile scenarios — all proven
Architect/Implementer disagreement → recorded, arbitrated. Security veto → execution stops, explanation emitted. Budget exhaustion mid-council → partial council state preserved, human notified. One agent failure → council recovers or fails loudly with state preserved. Human override → final decision document reflects override, cannot be tampered.
Why this is a category shift
No other autonomous coding platform runs a council. Cursor runs zero agents. Devin runs one. kAIxU Council runs eight, with formal disagreement, arbitration, and a human-reviewable decision record. This is the difference between a solo contractor and an engineering team — but the team runs in minutes, not weeks.
Council panel UI
Role timeline, verdict cards, objection list, confidence scores per role, budget consumed per role, and final arbitration summary — all visible in a single panel. An operator can see exactly which role blocked a change and why, without parsing logs.
Dated April 7 2026. Contains council launch proof, role verdict artifacts, arbitration result, hostile scenario outcomes including security veto and budget exhaustion, and human override validation.
Every other autonomous coding tool starts each session cold. SkyeMemory Fabric gives kAIxU a persistent engineering memory — a typed graph where prior failures, corrections, and architecture decisions change future autonomous behavior.
"The system can truthfully show that a prior failure and correction materially changed a later autonomous decision."
The memory graph
SkyeMemory Fabric is not a log. It is a typed directed graph where nodes are engineering objects and edges are causal relationships. When kAIxU fixes a bug, it stores not just what it did but why — what caused the failure, what fix resolved it, what files moved together, what architecture rule the fix confirmed or violated.
On the next related task, kAIxU queries the graph first. If it finds a prior failure of the same type in the same area, it loads that context into its planning layer. The resulting plan is materially different — it avoids the failure pattern it has already learned.
Every autonomous run kAIxU completes can be rewound to any checkpoint, inspected at any step, forked under different conditions, and exported as tamper-evident procurement evidence.
"A real autonomous run can be rewound, inspected, verified, forked, and re-executed from a checkpoint under different model, policy, or budget conditions."
What SkyeReplay captures
Every event in an autonomous run is captured in order: planning decisions, file reads, file writes, command starts and exits, test failures, policy denials, approvals, deployments, runtime transitions. Each event is timestamped and chained. The chain has a verification digest.
Between checkpoints, SkyeReplay stores diffs — not just final state. This means you can reconstruct exactly what the file tree and terminal output looked like at step 7 of 43, not just what they looked like at the end.
Replay capabilities
Timeline scrubberScroll through any run event by event
Diff viewSee exactly what changed at each step
Terminal viewReconstruct terminal output at step N
Checkpoint jumpJump to named checkpoints instantly
Fork from checkpointRe-run from step N under different model/policy/budget
Out-of-order injectReplay rejects with explanation
Section 47 · PASS
Proof artifact: SECTION_47_SKYE_REPLAY.json
Contains fixture task run, ordered event persistence, file state reconstruction at step N, terminal reconstruction at step N, export bundle, re-run from checkpoint, tamper detection for removed event, tamper detection for modified diff, out-of-order rejection, and fork divergence proof.
·SECTION 49 · PASS · APRIL 7 2026
ProofOps
SkyeHands is now a proof-producing engineering cloud. Every code change ships with a signed, verifiable evidence pack. Procurement-safe redacted export. Remove one artifact — validation fails. Tamper one hash — attestation fails.
"The platform can ship a code change and a verifiable proof package for that change."
Security reviewsSigned attestation with full chain verify
Post-change accountabilityEvery change has a verifiable proof pack
Failure-path proofs
Remove one evidence artifactPack validation fails loudly
Tamper one hashAttestation fails
Redact incorrectlyExport validator fails
Missing replay/audit refsExport fails loudly
Section 49 · PASS
Proof artifact: SECTION_49_PROOFOPS.json
·SECTION 51 · PASS · APRIL 7 2026
CostBrain
Live economic intelligence over every autonomous decision. The platform knows what each choice costs before it makes it — token spend, compute cost, deploy cost, rollback risk — and plans differently under different budget constraints.
"The platform can choose materially different engineering strategies based on explicit economic constraints and explain why."
What CostBrain models per run
Token spendPer-LLM-call cost tracked and projected
Compute costCPU/memory/time cost of execution lanes
Build time costOpportunity cost of long build paths
Deploy costProvider deployment and infra cost
Storage costArtifact and workspace storage
Rollback risk costEstimated cost of failure + recovery
Planning modes
Cheapest acceptableMinimum cost that still meets quality bar
Safest regulated patchCompliance posture takes priority over cost
Fastest fix under budgetSpeed optimized within cost ceiling
Private-only budget modeOnly use private providers — no cost-sharing
Autonomy is not a toggle. It is a governed spectrum from suggest-only to fully autonomous, each mode binding task scope, policy tier, compliance posture, and human approval requirements. Forbidden escalation is denied — not warned about.
"The same task behaves materially differently under different autonomy settings, with policy and evidence enforcing the distinction."
📝 Draft-and-waitProduces a patch or plan. Stops before execution. Human review required.
🚦 Execute-with-review-gatesExecutes in stages. Pauses at defined approval checkpoints. Resumes on approval.
⚡ Full autonomousCompletes task end-to-end without manual stops when policy allows.
🔄 Continuous maintenanceRuns recurring maintenance tasks on schedule with policy gates.
Binding dimensions
Task scope
Workspace
Repo
Branch
User
Policy tier
Compliance posture
Autonomy mode is not a global setting. It is bound per task, per workspace, and per policy tier. A security-sensitive repo can be locked to draft-and-wait while a test-only repo runs full autonomous.
All hostile scenarios proven
Suggest-only mutation attemptDenied — state unchanged
Section 53 · PASS · Largest single-section code-floor jump: +$6.6M
Proof artifact: SECTION_53_AUTONOMY_GRADIENT.json
·SECTION 54 · PASS · APRIL 7 2026
SkyeClone Environment Mirror
Drop in any external project — descriptors, docs, configs, env templates, runbooks, traces. SkyeClone reconstructs a usable environment model with explicit honesty about what was inferred, confirmed, conflicted, or still missing.
"The system can reconstruct a materially usable engineering environment from partial external signals and honestly show what is missing."
What SkyeClone ingests
Repo metadata
Docs
Config files
Deployment descriptors
Env templates
Runbooks
Runtime traces
Dependency graphs
SkyeClone does not pretend to have information it doesn't have. Every reconstructed environment model includes an explicit gap report: what was inferred from partial signals, what was confirmed from hard evidence, what conflicted between sources, and what is still missing and why.
Reconstruction outputs
Environment modelServices, env vars, launch paths
Gap reportInferred / confirmed / conflicted / missing
Reusable templateExport for reuse across workspaces
SkyeClone feeds directly into Deep Scan Mode (S59), which can launch-test the reconstructed environment, and Valuation Audit Mode (S60), which can produce an investor-grade dossier from the reconstructed platform. The SkyeAccountExecutive-CommandHub was brought into the platform mesh via this pipeline.
Spin up distinctly branded autonomous developer clouds from the SkyeQuantaCore platform. Each tenant gets its own domain, policy posture, provider bindings, audit configuration, and feature tier — with zero cross-tenant bleed, proven hostile.
"The platform can spin up distinctly branded autonomous developer clouds without cross-tenant leakage."
What SkyeFoundry provisions per tenant
Branded domainCustom domain, logo, color scheme, product name
Policy postureTenant-specific compliance mode and approval workflow
Audit configurationTenant-specific logging depth and retention
Feature tierPer-tenant capability limits and pricing surface
Export packageWhite-label deployment bundle for self-hosting
Cross-tenant bleed — all denied and proven
Branding bleed attemptTenant A cannot see Tenant B branding
Provider bleed attemptTenant A cannot access Tenant B providers
Policy bleed attemptPolicy boundaries are runtime-enforced
Business model implications
SkyeFoundry makes SkyeHands resellable. Any operator can provision a branded autonomous developer cloud for their own customers — with their own logo, their own compliance posture, their own provider bindings — all powered by SkyeQuantaCore underneath. This is an OEM / white-label revenue lane with no additional engineering work per tenant.
Section 55 · PASS
Proof artifact: SECTION_55_SKYE_FOUNDRY.json
·SECTION 56 · PASS · APRIL 7 2026
Autonomous Maintenance Mode
The platform detects, queues, and executes maintenance work without requiring the operator to initiate every action manually. Stale dependencies, flaky tests, vulnerability patches, doc refresh, infra drift — all handled unattended within policy gates.
"The platform can detect, queue, execute, and explain maintenance work without requiring the user to initiate every action manually."
What the maintenance scheduler detects
Stale dependenciesOutdated packages with available upgrades
Flaky testsTests that pass/fail non-deterministically
Doc refresh needsOutdated documentation detected against code
Infra driftConfig drift from declared posture
Safety gates — unattended doesn't mean unchecked
Every maintenance action requires a policy gate allowing it before execution. If the policy denies mutation, the scheduler logs the detection, proposes the action, and stops — loudly. No silent mutations. No action outside allowed windows.
Evidence ledger
Every maintenance run produces evidence: what was detected, what action was taken, what policy allowed it, what the before/after state was. Recurring issues are tracked in the scheduler — if a flaky test is fixed and recurs, the scheduler reopens it with cross-reference to the prior fix attempt.
Code generation that respects commercial profile. Founder-only modules stay locked. White-label exports exclude restricted components. Client work stays isolated from internal product. Every generation decision is policy-enforced, not just documented.
"Generation and export behavior changes by commercial profile, with founder-only modules and white-label restrictions enforced at the planner level."
Commercial profile types
Internal productFull access — no export restrictions
Client workIsolated — internal IP blocked from client export
White-label branchBranded but excludes founder-only components
Acquirable core assetDiligence-safe packaging — no operational secrets
Community editionOpen features only — premium components locked
Resale-restricted deliverableClient-licensed — cannot be reused or resold
What the policy engine enforces
Reuse restrictions
Founder-only module lock
Export restrictions
Ownership boundaries
Tamper detection on profile
Why this matters for SOL
Skyes Over London LC operates across multiple product lines — SkyeHands, SkyeRoutexFlow, AE CommandHub, SkyeFoundry tenants. Deal-Aware Generation ensures that code produced for a white-label client cannot inadvertently expose core IP, that acquirable asset packaging strips operational secrets, and that founder-only modules are enforced at the generation planner level, not just as a documentation policy.
Provider connectivity becomes policy-aware sovereign runtime orchestration. The platform reasons over multiple providers by capability, cost, latency, trust tier, tenancy scope, health, and policy limits — and routes the same task differently under different conditions.
"The platform can reason over multiple sovereign providers, route by policy, fail over, and explain every routing decision."
Routing policy modes
Lowest costCheapest provider meeting minimum capability bar
Highest trustPrefer providers with strongest trust tier
Private-onlyOnly route to private infrastructure
Fastest acceptableOptimize for latency within quality floor
Enterprise policy modeCompliance-bound routing with approval gates
Failover-onlyOnly engage when primary provider is down
Human approval requiredNo provider selection without explicit approval
Hostile scenarios — all proven
Provider outageFailover proven
No valid fallbackFails loudly with explanation
Cost cap breachRoute denied — cheaper route sought
Trust policy denies all routesLoud explanation — no silent failure
Invalid provider metadataValidation catches and rejects
Connection to Sovereign Provider Plane
SkyeSovereign Runtime (S50) is the routing intelligence layer. The Sovereign Provider Plane (S29–S35) is the credential storage and per-workspace binding layer. Together they form the complete sovereign infrastructure — user-owned credentials, encrypted at rest, routed by policy, audited on every access.
The integrated project-reader. Drop in any platform — SkyeHands scans it, reconstructs its launch topology, tests its paths, and produces a reader-dossier with evidence. This document you're reading was produced by this pipeline.
"The platform can scan any imported project, reconstruct its route topology, test launch paths, and produce a dossier with evidence."
What Deep Scan produces
Launch topology mapAll reachable entry points and their dependencies
Route test resultsWhich paths launch successfully, which deny or fail
Reader dossierHuman-readable summary of platform capabilities
Evidence chainSource-traced artifacts for every claim in the dossier
Valuation inputFeeds directly into Section 60 Valuation Audit Mode
The SkyeAccountExecutive scan
Section 61 imported SkyeAccountExecutive-CommandHub into the SkyeHands platform mesh. Deep Scan Mode was used to reconstruct the Credential Hub launcher's route topology, test which launch paths succeed versus which deny missing service targets, and produce the evidence that Section 62 Platform Power Mesh uses to answer capability queries.
The SkyeHands investor materials you are reading were produced by a Deep Scan + Valuation Audit Mode pipeline running over the SkyeHands platform itself. The platform audits itself and generates its own investor evidence chain.
Section 59 · PASS
Proof artifact: SECTION_59_DEEP_SCAN_MODE.json
·SECTION 60 · PASS · APRIL 7 2026
Valuation Audit Mode
SkyeHands generates investor-ready audit websites from its own proof evidence. Route proof, action proof, descriptor depth, replay evidence, council arbitration — assembled into a deterministic valuation lane with a public-facing investor surface.
"The platform can produce a deterministic valuation lane with an investor-ready audit website surface — backed entirely by proof evidence, not marketing claims."
What the audit website contains
Route proofEvery major claim backed by a traced launch path
Action proofkAIxU task completion evidence with replay refs
Descriptor depthPlatform architecture documented from scan, not from memory
Council arbitrationReal council runs with verdicts and disagreements
Honest gap listOpen items listed exactly as the proof planner sees them
Valuation rationaleWhy each section contributes what it contributes to the code floor
The meta-proof
Section 60 closes a remarkable loop: the platform you are reading investor materials about used its own Valuation Audit Mode to produce the investor materials you are reading. The audit website template at docs/templates/INVESTOR_AUDIT_WEBSITE_BASE_TEMPLATE.html is generated by the platform from its own proof chain.
This is not a circular argument — it is a capability demonstration. A platform that can produce a rigorous, honest, evidence-backed audit of itself is a platform that can do the same for any imported platform in the mesh. Deep Scan Mode (S59) + Valuation Audit Mode (S60) is the complete investor intelligence pipeline.
Imported platforms become searchable, queryable capability graphs — not parked source trees. The Power Mesh indexes capabilities, routes, and launch paths across every connected platform and answers questions about what each can do.
What the mesh indexes
Launch pathsEvery launchable entry point across all platforms
Capability inventoryWhat each platform can do, queryable by keyword
Script/package discoveryAll runnable commands indexed and described
Static surface mapHTML/JS surfaces across all platforms cross-referenced
Connected platforms
Currently meshed via Section 61 Platform Launchpad: SkyeAccountExecutive-CommandHub including the Credential Hub Launcher, AE Brain Command Site, AI Appointment Setter, Skye Lead Vault, SkyeRoutexFlow, SkyeOfferForge, SkyeBox Command Vault, and all branching apps.
The Power Mesh makes the SkyeHands platform capable of querying: "What can I launch from SkyeAccountExecutive?" and returning a real, evidence-backed answer from the capability graph — not a README.
The most complete app in the AE Central Command Pack. The uploaded zip shows a dependency-light Python server, a full SQLite-backed operating model, four operator/public surfaces, real booking and billing flows, live calendar adapters, outbound/inbound messaging, voice handling, and a production handoff lane — all packaged as one deployable service.
Capsule file count
53
Power manifest lists a 53-file branch app capsule in the uploaded zip.
HTML surfaces
6
Public intake, manage portal, admin desk, diagnostics desk, auth/login, and runtime surface.
HTTP route count
69
Public, admin, auth, calendar, voice, reminders, artifacts, billing, and runtime lanes.
App tables
30
Application tables defined in db.py across leads, sessions, bookings, billing, auth, audit, docs, proof, memberships, quotes, and routing.
Zip-backed architecture
What the uploaded package actually ships
Server runtimeserver.py on Python stdlib HTTP server — no framework lock-in
The package is deeper than a scheduler. The readme spells out qualification capture, transcript logging, live availability, round-robin rep assignment, reminder queueing, self-service appointment management, downloadable ICS, intake packet and waiver capture, invoice lifecycle control, credit memo handling, playbook sending, voice outbound/inbound, and real inbound SMS/email reply capture.
Calendar adapters exist for Google Calendar and Microsoft 365. Outbound delivery supports SMTP or webhook rails. AI is optional polish on top of a deterministic booking pipeline rather than the only thing holding the product together.
Route map visible in the server
Public APIs/api/appointments, /api/availability, /api/public/appointment/*, /api/public/quotes/*, /api/public/payments/*
The uploaded zip includes hardening notes for first-login rotation, password policy validation, login lockout, CSRF on authenticated writes, secure cookies for HTTPS, org-scoped admin access, signed voice webhooks, and a clean release database. That makes this page a true production-service breakdown, not just a feature list.
Inside SkyeHands, this branch app is a launchable connected platform. kAIxU can route work into it, Deep Scan Mode can inspect it, and Valuation Audit Mode can treat it as a standalone diligence-ready operating asset.
Standalone asset posture inside the platform mesh
The prior AE valuation pack placed AI Appointment Setter Brain v33 in the $3.2M–$6.4M standalone band. What the uploaded zip adds to that story is structure: 4 working operator/public surfaces, 69 visible server routes, 29 tables, 43 environment keys, and a proof+deployment bundle that makes the app legible as a real operating system for intake, booking, billing, and follow-up.
·AE COMMAND PACK · OFFLINE-FIRST PWA
Skye Lead Vault Offline Phase 2
The uploaded zip frames Lead Vault as a true offline field app rather than a single dashboard. It ships a static PWA shell, 12 HTML surfaces, a local data engine in one app bundle, route and territory planning, encrypted backups, recovery tools, script generation, analytics, and privacy controls — all with no backend required.
Capsule file count
20
The power manifest exposes Lead Vault as a 20-file launchable capsule.
Settings + privacyBackground studio, reminders, local app lock, and privacy mode
What the code says this product is for
The app runtime names the product as an offline lead-control system with dedupe radar, recovery lane, route planning, script generation, and encrypted backup. It is designed for the field: lead work without depending on a cloud round-trip every time an operator needs to capture, sort, recover, or follow up.
That makes this branch app valuable for seller/operator environments where reliability matters more than constant connectivity.
Intelligence + field layers in this pass
Smart duplicate detection
Business/email/phone/location matching
Local scoring engine
Rescore-all
Activity timeline
Relationship mapping
Dead-lead recovery
Saved views
Offer builder
Script generator
Resilience layer
Encrypted backupAES-GCM passphrase export in the static build
Restore previewSee what will change before restore is committed
Merge / replace restoreChoose additive or full replacement recovery behavior
Portable lead packsMove selected lead records cleanly between environments
Privacy modeLocal unlock/PIN lane for device-side protection
Mesh role inside SkyeHands
Lead Vault is the offline field-memory node in the AE Central Command Pack. Section 61 makes it launchable from the platform mesh, while the platform narrative makes it the place where route plans, lead intelligence, quick field capture, and resilient backup behavior live when a seller is away from the network.
Why this page matters
The uploaded zip proves this is more than a feature card. It is a packaged offline operating lane with twelve visible surfaces and a clear role in the connected AE stack: capture, organize, recover, route, and work leads without waiting on a backend.
·AE COMMAND PACK · v8 ADDITIVE
AE Brain Command Site v8
The uploaded zip shows AE Brain as the command-and-control layer of the AE stack: a launchable PWA capsule with 13 named AE profiles, 13 mapped key slots, a 196-check smoke proof, live brain routing hooks, client/task/transcript systems, multi-user controls, remote usage and audit lanes, and integration handoffs into Appointment Setter and commerce.
Capsule file count
16
Launchable branch capsule listed in the power manifest.
Smoke checks
196
SMOKE_RESULT.json in the zip shows an all-pass smoke chain.
AE key slots
13
AE_OPENAI_KEY_01 through AE_OPENAI_KEY_13 are mapped in the smoke proof.
Multi-provider postureOpenAI primary with Anthropic and Gemini fallback-ready runtime
Why AE Brain matters inside the connected platform stack
AE Brain is the orchestration desk for the connected platforms, not just another branch app. It decides who handles a client, what task or response gets created next, which transcript turns become work items, when a client gets handed into Appointment Setter, and how results come back into the AE operating loop.
Inside SkyeHands, that makes AE Brain the command surface that turns the other connected platforms into one coherent operating mesh instead of a pile of disconnected tools.
Additive build model
v8 is also explicitly documented as additive. The zip describes it as capabilities added on top of a proven prior state rather than rewritten from scratch. That aligns it with the larger SkyeHands proof-pass philosophy: preserve what works, extend the system, then smoke the new state until it is legible.
Why this page is now a full breakdown
This page is now driven by the uploaded zip’s real evidence: power manifest counts, smoke proof depth, runtime lanes, key-slot mapping, and the actual command views in the app code — not just a short summary card.
·ROUTEX PLATFORM · PARENT-SHELL EVIDENCE IN CURRENT CODEBASE
SkyeRoutexFlow
This uploaded package surfaces Routex through the parent SkyeAccountExecutive-CommandHub shell and its connected integration surfaces. The parent shell presents Routex as the field-execution side of the stack: route/dispatch control, bridge handoff, runtime console, live ops deck, production-closure deck, and a white-glove commerce/operations lane connected to the AE command system.
Parent shell entries
5
Direct Routex-facing entries visible in the parent shell: Routex app, Routex bridge, runtime console, live ops deck, and production-closure deck.
Working combined
$7.925M
Parent command surface valuation ledger for the combined commandhub + routex position.
Closure uplift
$550K
Stage-eleven production-closure uplift named in the parent shell ledger.
Low-end target band
$9.9M+
Parent ledger pushes the live-proof low end into the upper seven-figure band.
What the uploaded zip proves
Routex is wired as a connected field platform
Parent launcherSkyeAccountExecutive-CommandHub explicitly houses the AE Central Command Pack and the full SkyeRoutexFlow child platform surface
Routex bridgeDedicated cross-platform bridge entry for handoff, launch context, and management routing
Runtime consolePackaged runtime auth/sync/search console for real cross-platform execution
Live ops deckOperator-facing routex management surface exposed from the parent shell
Production closure deckDedicated closure lane for broker tickets, signed artifacts, and operational controls
Cross-platform navParent shell states nav was injected so the platform surfaces do not ship isolated
Operational lanes named in the parent shell
Field executionRoute, dispatch, and management entry points from the parent shell
Bridge telemetryHeartbeat logging and launch context across apps
Runtime auth/sync/searchServer-runtime code rather than localStorage-only wrapper behavior
Local HTTP runtime serviceNamed directly in the deep-scan snapshot of the parent shell
Production closure laneSigned broker tickets, signed artifacts, commerce reconciliation, tax enforcement, abuse scoring, media registration, white-glove packet closure
Operator deckDedicated deck for managing the live field-facing side of the system
How Routex fits the connected-platform stack
Inside this uploaded package, Routex is the field-execution half of the AE command system. Appointment Setter handles intake and booking. AE Brain handles routing, assignment, and command decisions. Lead Vault handles offline lead memory and territory work. Routex is where that work becomes managed operations, dispatch, and closure.
That is why the parent shell keeps surfacing Routex through the bridge, runtime console, ops deck, and production-closure deck rather than treating it like a side utility.
Valuation posture in the parent command shell
The parent shell’s valuation ledger names a $4.775M conservative present codebase, then layers stage uplifts through runtime/auth/sync/search, platform/runtime, branch-runtime, deep branch-runtime, local live-service/dashboard, and stage-eleven production closure to reach a $7.925M working combined position.
That makes Routex materially important to the connected-platform story in this zip even where the parent shell is the clearest evidence surface.
Mesh role inside SkyeHands
In the SkyeHands narrative, Routex is the node that turns AE intent into real-world fulfillment movement. It is the field lane, dispatch lane, and white-glove closure lane that completes the loop started in AE Brain, Appointment Setter, and Lead Vault.
Why this is now a fuller page breakdown
This page now reflects what the uploaded zip itself proves about Routex at the parent-shell and integration level: direct launch surfaces, runtime and bridge lanes, production-closure claims, and combined valuation role inside the connected platform stack.
⚖ Devil's Advocate — April 30 closure current codebase state · April 30 2026
Is this a bullshit platform?
This page is the hard read on the current codebase. Not the older deck copy. The actual read on what the current codebase state proves now, what is still mixed-state or stale, what remains genuinely incomplete, and what a hostile reviewer would still flag today.
DEEP SCAN VERDICT · PASS 45 · APRIL 10 2026
Not bullshit. Substantially more complete. One honest blank remains.
The current codebase now contains the active base plus a current-truth production-release lane. The current-truth VERSION_STAMP.json shows highestPassingStage: "11", releaseVersion: "3.1.9", and only one remaining blank: live provider variable configuration. Stage 11 regression proof and Section 42 hostile-environment rerun are green on the current working base.
A serious technical reviewer still would not call this vaporware. They would call it a real platform with a mixed-state repo history, a greener current chain, one host-bound remaining blank, and some older packet surfaces that still need normalization. That is a much stronger position than the earlier Pass 44 scan.
ARCHITECTURE
Real
PROOF SYSTEM
Honest
COMMERCIAL STAGE
Pre-revenue
BULLSHIT?
No
What the current codebase actually contains
These are findings from opening and scanning the uploaded codebase directly — not the marketing copy.
Hard facts from the codebase scan
Active-base files260,409 platform files on the counted working base
Live provider varsProvider-variable boundary — set at deployment
No paying customersPre-revenue — zero ARR to date
Section proofs vs stage proofsTwo different tracking systems — can confuse
SWE-bench 77.6%Split/harness/attempts unspecified
What is genuinely real right now
REAL · PROVABLE · IN CODE
The shell is product-owned original code
230 bin files and 132 lib modules are not wrappers around existing tools. They are original product-owned scripts covering bootstrap, launch, doctor, workspace management, provider vault, proof runners, ship-candidate, audit-export, and more. A buyer would be pricing a real implementation, not a config layer.
REAL · DATED · PROOF-BACKED
61 proof artifacts with timestamps
Every section proof in docs/proof/ is a JSON file with generatedAt, pass: true, and a checks array. Sections 29–63 all have passing artifacts. These are not mock files — they have execution paths, fixture outputs, and hostile-failure checks baked in.
REAL · ARCHITECTURAL · UNIQUE
AES-256-GCM sovereign credential vault
The provider vault (Sections 29–35) is real code: provider-vault.mjs, provider-sovereignty.mjs, provider-redaction.mjs. The Section 29 proof artifact shows actual ciphertext-at-rest posture, PBKDF2-SHA256 key derivation, and safe-metadata-only surfaces. This architecture exists nowhere else in the autonomous dev platform category.
The current-truth docs show the current chain is greener than the earlier Pass 44 read: Stage 9 deployment readiness, Stage 10 multi-workspace stress, Stage 11 regression proof, Section 8 deployment packaging, and Section 42 hostile-environment rerun are all CHECKMARK on the working base. The launch-readiness memo names the exact implementation files that closed those gaps. This is code-backed closure, not paperwork.
REAL · COHERENT · ORIGINAL
kAIxU Council architecture
The Section 48 proof artifact contains actual council role execution, arbitration results, security veto simulation, budget exhaustion mid-council, and human override. These are not stated features — they are smoke-proven capability paths. The council-role model (Architect, Implementer, Test Breaker, Security Reviewer) is original SOL architecture.
REAL · DISCIPLINED · CONSISTENT
The proof system itself is the product
The most compelling thing in the uploaded codebase is not any single feature — it is the consistent application of the completion gate: code exists, runtime path exists, hostile path exists, proof artifact passes, claim stays green. That discipline, applied across 63 sections over 44 passes, is itself a real asset. Most platforms don't have it.
What still needs normalization or closure
These are real things in the codebase or claimed in materials that have not yet reached the same proof standard as the sections above. They are not fake — they are in-progress.
Root packet normalization
The current codebase now has a stronger current-truth lane, but older packet surfaces remain in the root docs tree. A reviewer can still open docs/VERSION_STAMP.json or older investor pages and land on earlier snapshots. The repo is real, but the narrative surfaces are not yet single-state.
Status: current-truth lane accurate · root packet surfaces still mixed-state
Merged-base count ambiguity
This archive has at least three meaningful ways to count things: root platform files, broader archive entries, and counts that include mirrored dist/workspace copies. That is why older surfaces can cite 230 shell bins while the root shows 134. None of that means the product is fake; it means the counting method needs to be declared explicitly.
Status: counting method should be normalized across packet surfaces
Live provider vars
Live dispatch to paid providers requires production credentials and deployment environment variables. The code paths, dry-run contracts, and local proof harnesses exist; secrets are intentionally injected at deployment instead of being committed.
The Section 64 directive (Super-App Inheritance and Visual Analytics) exists in this codebase as a spec directive file. No proof artifact exists yet. It describes a compelling vision — imported platforms inheriting SkyeReplay, SkyeMemory, ProofOps, Council, and CostBrain — but it is a directive, not a proof-passing section.
Status: directive written · implementation not started
Commercial revenue
$0 ARR. No paying customers. The platform has not been commercially launched. Every revenue projection in this site is a model, not actuals. The seed raise is precisely to fund the path from working proof-backed platform to commercial launch. This is not hidden — it is the entire point of the raise.
Some root-level packet surfaces in this codebase still show earlier valuation eras. The current-truth working-base valuation is $86.8M in the production-release docs. A reviewer opening the wrong packet surface first can still land on a stale read.
Status: current-truth valuation accurate · older packet surfaces still need normalization
The hard questions — answered directly
Q: Could someone have fake-generated these proof artifacts?
Theoretically, yes. Any JSON file can be written. What makes this less likely than it sounds: the hostile/failure path proofs in each artifact require specific failure behaviors (tamper-detection fails, out-of-order events rejected, budget overruns denied). These are harder to fake convincingly than passing proofs — you have to model what a failure looks like too. The proof artifacts in sections 29–35 reference specific profile IDs, timestamps, and encryption postures that are consistent across artifacts. That's harder to fabricate than a single passing JSON.
The honest answer is: a buyer should do code review, not just read artifacts. The artifacts are evidence, not proof-of-concept. The code review is what closes the question.
Q: Are the shell counts impressive or confusing?
Both things can be true. The shell grew from 15 to 230 files across 44 passes. Some of those files are proof runners — purpose-built scripts that run a specific smoke check and emit a JSON artifact. They are real code, but they are not production-facing user features. The production-facing original code — bootstrap.mjs, launch.mjs, doctor.mjs, provider-vault.mjs, workspace-runtime.mjs, workspace-scheduler.mjs — is a smaller, genuinely impressive core. The proof runner scripts are the test infrastructure, not the product. Both are real. Neither is padding.
Q: What changed between the earlier $44.05M read and the current $86.8M working-base read?
The current uploaded website adds the richer category narrative, while the April 30 closure packet adds the full 72+ platform valuation stack. The move to $86.8M is tied to the expanded ecosystem inventory: SkyeCards, ValleyVerified v2, SkyeForgeMax, JobPing AE Dispatch, SkyDexia, SkyeSuite, NeuralSpacePro, SkyeLeticX, offline PWAs, Dynasty pipeline, and the green deploy proof lane.
A hostile reviewer would correctly note that three-day valuation jumps of $34M are extraordinary and warrant scrutiny. The answer to that scrutiny is: read the section directives and the proof artifacts, not just the headline numbers. If the section implementations pass a code review, the valuations hold. If they don't, the floor number should be revised down. That's how it's supposed to work.
Q: Is there a real IDE and real agent in this codebase?
Yes. The browser IDE is Eclipse Theia — a real, production-grade VS Code-compatible browser IDE. The platform also includes real autonomous agent lanes and a product-owned shell, launch contract, doctor, bridge, gateway, and proof layer. Those lower execution lanes are real, but kAIxU is not reducible to any single imported component. The product-owned value is the orchestration, routing, persistence, governance, and super-brain behavior above those lanes.
Q: Is kAIxU just OpenHands underneath?
No. kAIxU is the platform's super-brain and orchestration layer. It is not a rename for OpenHands. The platform runs through the gateway plane and can route work across multiple connected brain/model lanes, with kAIxU deciding which lane to use based on platform logic, training, and context. One autonomous agent lane may use tooling discussed in the eval disclosure, but that lane does not define the entirety of kAIxU. The correct client-facing statement is that kAIxU is the orchestrator above the execution lanes, not the label for a single underlying engine.
Compared to what actually got funded
The "is this real enough to fund?" question is best answered by looking at what investors have actually funded at comparable stages.
What SkyeHands has that most seed-stage companies don't
Working productLocal runnable platform, not slides
Original architectureNot a wrapper or reskin
Proof discipline63 sections with dated passing artifacts
Credential architectureAES-256-GCM, no competitor has this
Named categoryAutonomous Developer Cloud — no incumbent
Honest gap listOpen items listed in VERSION_STAMP
What most funded seed companies have that SOL doesn't yet
Revenue$0 ARR
UsersNo public user base yet
Team sizePrimarily solo-founder build
Hosted product URLLocal-only, not yet cloud-hosted
Enterprise pipelineNo active enterprise deals
The honest bottom line
SkyeHands is a real, working, original autonomous developer platform built by one person over 44 documented passes. The proof discipline is genuine — open items are disclosed, not hidden. The architecture is original — the sovereign credential layer, the kAIxU Council model, the Autonomy Gradient, and the proof-ops pipeline exist nowhere else in this category.
It is pre-revenue. It is pre-team. It has not been publicly launched. The gap between "working proof-backed platform" and "commercial product with paying users" is exactly what the seed raise is meant to close. That is not a weakness unique to SkyeHands — it is the definition of a seed-stage company.
A hostile reviewer who opened this codebase would not find fabricated claims. They would find a real platform with real gaps, documented by the platform itself, with a consistent proof system that holds the builder to the same standard as everyone else. The question investors should be asking is not "is this real?" The question is "can this team close the remaining gaps and get to commercial proof?" That is the bet.
