AeAethelLayer

How it works

From a dead install to a ticket you actually want — then a graph that remembers.

No rewrite. No IT project. The probe watches failures and keeps enough context that someone on your team can fix them. Memory Graph and Intelligence are Growth, Scale, and Enterprise only.

01

SDK dies

OOM, JWT, gRPC

02

Probe keeps it

stack + OS + cmd

03

One question

in the terminal

04

Draft ticket

you hit send

01

Install once

npm i @aethellayer/sdk, wrap the CLI, or hang middleware on the API. The probe is read-only to your product. It does not sit in the hot path as a new surface. Most teams are live before lunch. You authenticate ingest with a workspace API key — or an eval-mode key for a sales PoC.

02

A real error fires

Docker runs out of memory. A JWT expires before the popup returns. gRPC hits a deadline. The probe already has the stack, the OS, the runtime, the endpoint, and the command they ran. Metadata can carry competitor_install, PostHog ids, and runtime version.

03

One question, in context

It does not open with a generic how can I help. It asks what they were trying to do, in the terminal or the SDK error UI. They can answer in a sentence. If they walk away, you still have the capture. On Growth+, an armed playbook can answer from the graph without a human for known clusters.

04

A thread lands in your inbox

It looks like Intercom. It is for developers. Next to it: environment specs, a GitHub or Linear draft, and — on Growth+ — graph correlations plus one-click PostHog / Mixpanel replay.

05

You hit send

Nothing publishes on its own. You read the draft, you edit it, you ship it. Quiet churn turns into a queued fix instead of a number that went down last quarter.

06

The graph remembers (Growth+)

Each capture can ingest nodes and edges. ERR_DOCKER_OOM ↔ auth-worker ↔ Raise container mem. The next evaluator is not a cold start. Friction scores, health badges, churn digests, and Linear epics are how that memory becomes an operating cadence.

Live demo

Watch it happen in the terminal, not in a slide.

Run the failing login. See the probe catch ERR_DOCKER_OOM. Type what you were actually doing. A GitHub issue draft appears. That is the whole product, in one go.

aethel · probe · staging

developer@acme payments-api %

Replay the moment a developer hits Docker or OAuth friction. The probe fires inside the terminal, keeps the root cause, and drafts the ticket for someone on your team to approve.

By surface

Same ingest contract. Different environments. Friction scoring later treats CLI, Web SDK, and API as three risk indexes — not one blended “errors this week” chart.

CLI

  1. Wrap the binary or the command they already type.
  2. On non-zero exit, POST /api/v1/probes with error_code, stack, environment=cli.
  3. Developer sees one question in the terminal. Your team sees a thread.

Web SDK

  1. probe.wrap(client) around the browser or Node SDK.
  2. OAuth popup timeout, JWT expiry, and callback failures become web_sdk threads.
  3. Replay links attach from developer identifier + error code.

API

  1. Middleware or Next.js instrumentation on the request path.
  2. 429s, gRPC deadlines, and callback 5xxs ingest as api_middleware.
  3. Friction index later compares this surface to CLI and Web week over week.

What each person sees

The developer

A short question in the place they already are. Not a chatbot landing page. Not an NPS form three days later. If a playbook is armed (Growth+), they may get a known-cluster fix immediately — still in the same thread, still with the stack attached.

DX / platform

A thread, a stack, a draft issue, and a yes or no. Same afternoon if you want it in your own CLI. Growth+ adds the atlas, friction by surface, and Monday’s churn digest.

Engineering

A GitHub or Linear draft with taxonomy and a suggested fix. You edit. You ship. On Scale, shared labels across workspaces keep product lines from inventing three names for the same OAuth bug.

GTM / sales

Eval-mode keys for PoCs without opening Growth. Competitor-win alerts when the same error code is followed by “installed Auth0 then left.” Lost evaluators show up in the Monday digest — not in a CRM note written from memory.

Memory Graph · Growth, Scale, Enterprise

How Graph-RAG actually runs

  1. 1. Ingest. Probe metadata and error codes become nodes (error, runtime, solution, developer) and edges (CORRELATED_WITH, CAUSED_BY, RESOLVED_BY).
  2. 2. Match. The next probe looks up graph context. Playbooks fire only if confidence clears the threshold you set.
  3. 3. Act. Auto-reply in the thread, bump hit counts, optionally draft a Linear epic from the taxonomy cluster. Humans still approve public tickets.
  4. 4. Score. Weekly friction for CLI vs Web vs API. Public badge for OAuth (or any path). Onboarding heatmap for which quickstart step leaks unique developers.

Starter workspaces keep the probe → inbox → draft loop. They do not open the atlas. Upgrade on Pricing when clusters start repeating.

A typical afternoon

11:04 — An evaluator runs npx @acme/cli auth login inside Compose. auth-worker is capped at 512Mi. Node asks for a 4GB heap. Exit 137.

11:04 — Probe posts ERR_DOCKER_OOM. Inbox thread opens. Playbook (Growth+) replies: raise Compose memory, retry the endpoint. Replay link sits on the rail.

11:11 — They still bounce. Metadata later shows competitor_install=auth0. GTM gets a high-severity alert. Monday digest lists them as a lost evaluator.

14:20 — DX pushes a Linear epic from the Docker cluster: “Compose memory defaults for auth-worker.” You still hit send on the public GitHub issue.

See the productMemory Graph on Growth+

Early access

Stop finding out about churn in a dashboard three days later.

No self-serve signup. Book a Calendly slot, or send details to sales.

Early accessTalk to sales