AetherID: The Identity Layer for the Agentic Internet

Why we're building it as a sister venture to Stratafy, and what it means for how strategic work gets done.

If you've spent any time in Stratafy, you'll have noticed the same conviction running underneath every feature: strategic claims need provenance. An insight without a signal behind it is a feeling. A decision without traceable reasoning is a guess. A risk without evidence is a story. Strategy works when the substrate underneath it is structured, attributed, and inspectable.

That same conviction is what pushed us to build something adjacent. Today we're introducing AetherID — a new venture from Cortex Innovations, the same group behind Stratafy. AetherID is an open identity protocol for the agentic internet. The short version of what it does: it gives any person or organisation a verifiable, schema-first profile that AI systems can read instead of guessing.

This post explains why we think the problem is now urgent, what the protocol actually is, and why we're building it alongside Stratafy rather than inside it.

The problem isn't that AI doesn't know enough. It's that it doesn't know who is telling it what.

Every AI assistant today operates on a foundation of unattributed context. When Claude or ChatGPT or any model produces an answer about you, your company, or someone you're researching, the underlying inputs are a mixture of scraped public content, whatever the user just pasted into the prompt, and whatever the model absorbed during training. None of these inputs carries provenance. None is structured. None was claimed by the person it describes.

This is fine when the stakes are low. It is not fine when an AI agent is acting on your behalf — sending email, drafting a brief, evaluating a partner, summarising a candidate, briefing a board. Every action an agent takes routes through some implicit model of who the user is and who the subject is. When that model is wrong, the output is wrong in ways that are hard to debug because the source of the wrongness is invisible.

We watched this play out across the systems we build. The moment Stratafy started giving real agency to Expert Agent Runtime — agents that actually act on strategic context rather than just describing it — a second problem became obvious. Those agents needed to know who the user was at a level of rigour matching the strategy work they were doing. The open web didn't have a layer for that. So we started building one.

What AetherID actually is

AetherID is a protocol, not a product. Five things define it.

The first is a schema. Profiles and lenses are structured JSON-LD with explicit trust tiers — every claim is marked as self-attested, research-extracted, or backed by a signed verifiable credential. AI systems can read the schema and weight the claims accordingly, the same way a human reads a document differently when they know the source.

The second is a resolution model. Every AetherID has a stable URL — aetherid.ai/handle for the canonical profile, and opaque capability URLs for individual lenses. You share these URLs the way you'd share a Google Doc: anyone with the link can read it, no platform sign-up required. There is no walled garden.

The third is an ownership principle we call owner-pull. AetherID never builds, stores, or exposes a profile on anyone who hasn't personally claimed and verified it. No scraping. No shadow profiles. No aggregating-without-consent. If you don't have one, AetherID has nothing on you. This is non-negotiable in the design.

The fourth is portable storage. The canonical version of any AetherID can live on AetherID's hosted infrastructure, in a user's own GitHub repository, or on a server they control. The protocol is exportable by construction. You're never stuck inside an identity vendor.

The fifth is MCP-native discovery. AetherID ships with a Model Context Protocol server, which means any AI assistant that supports MCP — Claude today, an expanding list of others — can query AetherID directly. What do you know about this person? returns structured, attributed context instead of guessing.

That is the whole protocol. Schema, resolution, owner-pull, portable storage, MCP-native lookup. The rest is implementation.

Why now

Three things happened roughly in parallel that made an identity primitive both possible and urgent.

The first is that AI assistants stopped being chatbots and started being agents. They send email, file pull requests, schedule meetings, run research, draft contracts. Every one of those actions routes through an implicit identity layer — and right now that layer is held together with prompt-pasting and scraped LinkedIn pages.

The second is that supply-chain attacks on open-source ecosystems made clear how fragile identity in technical systems actually is. When a maintainer's account is compromised, downstream consumers have no continuous way to verify that the entity acting today is the entity they trusted yesterday. Authentication is a session; identity is supposed to be a continuity. The two have been conflated for a decade.

The third is that MCP and similar protocols established a real standard for how AI systems read context from external sources. That meant — for the first time — an identity layer didn't have to convince every model vendor to integrate. It just had to expose itself through MCP, and any compliant assistant would find it.

These three forces converge into a single requirement: an open, schema-first, owner-controlled identity layer that AI systems can read natively. AetherID is our answer.

Three concrete scenarios

The protocol is abstract until you put it next to actual work. Three scenarios where it lands today.

A founder running their AI assistant. The assistant has access to the founder's AetherID and the lenses beneath it — coding preferences, communication style, current focus, evidence-grounded claims about prior work. The assistant stops asking "what's your role?" every session. It tailors output to actual context, with provenance. The friction of re-explaining who you are to your own AI tools — friction that everyone has accepted as normal — disappears.

A maintainer publishing to a package registry. The publish action is bound to an AetherID. Downstream consumers can verify that the entity publishing today is the same verified entity that has been publishing for six months — not just an authenticated session, but a continuous claimed identity. Compromise becomes visible faster because the identity layer is doing work the authentication layer was never designed to do.

A team researching a partner. Instead of pasting LinkedIn screenshots into a prompt, they point their research assistant at the partner's AetherID URL. The assistant pulls structured, claimed context — including the parts the partner has chosen to make public — and returns an answer grounded in attributable claims rather than scraped guesswork. The receiving team can see, at a glance, which parts of that answer carry signed credentials and which are self-attested.

Each of these is downstream of the same observation. AI systems are acting on us faster than the web has caught up to provide them anything trustworthy to act on. AetherID is the layer that catches up.

Why this is a sister venture, not a feature

Cortex Innovations builds operating infrastructure for the agentic era. Stratafy is the operating system for strategic work — it gives founders, executives, and operators a way to do strategy with the same rigour they bring to product or finance. AetherID is the identity primitive that work depends on.

The two ventures share a foundation but solve different problems, which is why they need to be separate.

Both are schema-first. Stratafy and AetherID share the conviction that AI is only as useful as the structure of the context it reads. Unstructured context produces unstructured outcomes.

Both are evidence-grounded. Stratafy traces every strategic claim to its supporting signal. AetherID traces every identity claim to its trust tier. Neither product accepts "trust me" as the trust layer.

Both are open by default. Stratafy's strategic architecture and AetherID's protocol are both designed for export, portability, and inspection. Critical infrastructure shouldn't be locked.

The products are independent. You don't need an AetherID to use Stratafy. You don't need Stratafy to use AetherID. But for organisations using both, the integration is real: Stratafy can resolve AetherIDs to pull richer context about decision-makers, partners, and stakeholders; AetherIDs can carry strategic context, with the owner's explicit consent, drawn from a Stratafy workspace. Each makes the other better at its own job.

We're keeping them separate because the audiences are different, the trust models are different, and conflating them would make both worse. An identity protocol that's "part of" a strategy product can't claim openness. A strategy product that's "part of" an identity protocol loses its focus. They belong adjacent, not nested.

What this means for Stratafy users

Three things in the immediate term.

You'll be able to claim your AetherID. Phase 1 of the protocol is live — the schema is stable, resolution works, and the first profiles are publicly resolvable today. We expect to open Phase 1 broadly through the second half of 2026. The first publicly-resolvable AetherID is mine: aetherid.ai/leonard-cremer.

You'll see AetherID resolution begin to appear inside Stratafy's research and briefing workflows. When you ask Stratafy to prepare context on a partner, customer, or stakeholder, it will check for an AetherID first. Schema-first context beats scraped context every time, and we'd rather Stratafy reach for a trustworthy primitive when one exists.

You'll see this blog reference AetherID work going forward. Some posts will be about strategy — Stratafy's lane. Some will be about identity primitives, MCP, and the substrate of the agentic internet — AetherID's lane. They share a publication because they share an underlying thesis: AI systems need better inputs, and "better" means structured, owned, attributable.

How to engage

If you want to follow what we're building, three concrete next steps.

Visit aetherid.ai to read the protocol overview and see the first publicly-resolvable profiles. The page rendering today reflects the v1.0-draft schema. Future versions will surface lenses, trust-tier indicators, and the MCP integration directly in the UI.

If you run AI assistants in your daily work, watch for the AetherID MCP server release. Connecting it to a Claude Desktop, Claude Code, or any MCP-compliant client gives that assistant the ability to read AetherIDs natively — to know who you are without you having to re-explain, and to research others through a primitive rather than a scrape.

If you're a developer, a maintainer, or an organisation thinking seriously about how identity should work in agent-mediated systems, get in touch. Phase 1 is being shaped by a small set of early collaborators, and the protocol is still close enough to its first publication that good questions from the right people materially change the shape of it.

Strategy is downstream of context. Context is downstream of identity. We're building the layer at the bottom of the stack — because everything we want Stratafy to do, and everything the agentic internet needs to do, depends on it being there.

Continue Reading

• Identity Is Infrastructure — Why the deepest layer of an organisation has to be queryable
• Strategy Is the Meta-Layer — Whoever owns the substrate where strategy lives owns distribution into every function
• The MCP Protocol and the Agentic Business — Why agents need protocols, not prompts
• Your Strategy Is Already in SharePoint — Why structured, attributed context beats scraped guesswork
• Your AI Can Access Everything — When agents act on your behalf, identity stops being optional

Explore AetherID:

1. aetherid.ai — Read the protocol overview and the first publicly-resolvable profiles

Leonard Cremer is the founder of Cortex Innovations, the parent of Stratafy and AetherID. He's based at SRTIP, Sharjah. His AetherID is at aetherid.ai/leonard-cremer.