Platform & DX teams
You own the CLI, the auth SDK, and the “it works on my machine” Slack thread. You need signal from evaluators before support ever opens a ticket.
About AethelLayer
AethelLayer is the DX layer for teams who build tools developers are supposed to love — and who keep finding out about churn from a chart, three days too late.
We kept sitting in rooms where onboarding looked fine. Support had nothing in the queue. Engineering said the stack traces looked like noise. Product wanted to send an NPS survey on Friday.
Meanwhile a developer had hit Docker OOM on the exact page you call the happy path, closed the laptop, and copied another SDK into the repo. They were not angry. They did not want to write a ticket. They had a staging cut. That is the whole company, in one afternoon — and your Mixpanel chart will not have a sentence attached to it.
We wanted the conversation to happen in the terminal, at the error, with the stack still on screen. Not in a form. Not in a war room next quarter. If you have ever watched a funnel drop and had no sentence from a human, this is the product you want sitting next to your SDK.
That is why we built AethelLayer. A probe in the CLI, the SDK, and the API. A short question. A draft issue for GitHub or Linear. You still hit send. The Memory Graph remembers the cluster so the next developer is not a cold start. Intelligence turns those clusters into friction scores, playbooks, and Monday digests your GTM team can actually use.
quiet churn · 10 evaluators
filed a ticket
1
left in silence
9
Mission
We believe the install is the product. When a CLI dies, a JWT expires in CI, or a starter key burns before noon, that moment is the most honest research you will ever get. AethelLayer captures it, asks one clarifying question, and turns it into work your engineering team can ship — without becoming another dashboard nobody opens.
Not every SaaS team. The ones whose revenue depends on developers completing an install, an auth flow, or a first API call — and who lose them in silence.
You own the CLI, the auth SDK, and the “it works on my machine” Slack thread. You need signal from evaluators before support ever opens a ticket.
Your funnel drops at OAuth or first API call. You need the error code, the surface (CLI vs Web vs API), and a human sentence — not another NPS prompt.
You have three competitors in the prospect’s tabs. The install is the product. If it dies quietly, the bake-off is over before your demo call.
One continuous loop: catch → ask → remember → act. Not four tools you have to stitch together in a Notion doc.
CLI, Web SDK, and API middleware that catch the failure with stack, runtime, OS, and command — while the developer is still in the loop.
One thread per failure. Live updates. Intent when they answer. Capture when they walk away. Intercom for people who just hit your SDK.
Graph-RAG over errors, runtimes, and known fixes. The next probe is not cold — it arrives with cluster context and a suggested path.
Friction scores by surface, auto-reply playbooks, eval-mode keys, churn digests, SDK health badges, competitor-win alerts, and taxonomy → roadmap.
The people who write long GitHub issues are not the ones you are losing. The ones who type the command, hit Docker, and close the laptop take the next evaluation with them — and never tell you why.
Mixpanel can show a drop at /oauth/callback. Datadog can show exit 137. Neither can ask what they were trying to do while the stack is still on the screen. That sentence is the research.
We draft the ticket. We do not fire it into your repo. If a product writes issues on its own, it is not a teammate. It is a mess you will spend a quarter cleaning up.
We sit in the failure. We do not ask you to rebuild onboarding around us. One line in the CLI, SDK, or middleware. Read-only to your product. Then we get out of the way.
We care about the cluster, the runtime, and the intent — not a dossier. Developer identifiers are hashed. You keep the customer relationship. We keep the failure context.
Most teams are live before lunch. The 60-day pilot is for teams who want us in the repo writing taxonomy with you — not a deck about developer experience.
The arc
The problem
01
We kept watching teams celebrate green uptime while evaluators left on the happy path — Docker OOM, JWT skew, starter 429s — without a single sentence in the inbox.
The bet
02
Put a probe in the failure path. Ask one question. Keep the stack. Draft the issue. Let a human approve. That second is worth more than a quarterly survey.
The product
03
Threads became clusters. Clusters became playbooks, friction indexes, and public health badges — so DX is not a slide, it is an operating system.
Today
04
Starter through Scale plans, Growth+ Memory Graph, sales eval keys without opening Growth, and bots that answer !probe with graph context — not vibes.
Why now
Every platform team now ships a CLI, a web SDK, and an API. Every evaluator has three other vendors in a tab. The install is the product. If it dies, they do not file a bug. They leave. We built the layer that treats that second as the most valuable research you will ever get — and the Memory Graph so your team does not solve the same OOM twice.
Observability tells you the process died. Product analytics tells you the funnel bent. AethelLayer tells you what the developer was trying to do, on which surface, with which cluster of known fixes — before the bake-off is over.
Whether you are evaluating for a bake-off, running a DX org, or shipping your first public CLI — we want the same thing you do: fewer silent exits, more shipped fixes.
Early access
Paste npx --yes @aethellayer/sdk run -- false and read the drafted issue in your terminal. Book a call when you want the probe in your CLI.