• Strategic Vision: The Full Picture
  • The thesis in one paragraph
  • The analogies
    • git → GitHub
    • Key insight from this analogy
    • Second key insight
    • Third key insight
  • The trust gradient
  • Recipes: the viral unit
    • Recipe examples across domains
    • Why recipes go viral
  • The spectacle (free distribution)
  • Two doors, one room
  • The product is not for developers
  • Competitive positioning
  • The moat
  • Signet’s role
  • Bootstrap sequence
  • AWS GAIA pitch (June 2026)
  • The tagline

§Strategic Vision: The Full Picture

Source: Gods-tier session, 2026-03-10 Status: Living document. Update as the picture evolves.

§The thesis in one paragraph

The agentic internet is arriving and it has no trust layer. Every AI provider is building walled gardens. Developers can’t run agents from different providers together. Normal people can’t use AI privately. Nobody can tell whether an AI configuration is good at what it claims to do. We’re building the open-source, local-first, provider-agnostic foundation that solves all of this — not by convincing anyone to care about decentralization, but by being the best way to use AI. Signet is the network layer that emerges on top.

§The analogies

§git → GitHub

§Key insight from this analogy

Git came first because Linus needed it. GitHub came three years later, built on real usage patterns. The local tool comes first because developers need it. Signet comes later, built on the event stream the local tool generates. You can’t build GitHub before git exists. You can’t build Signet before the event stream exists.

§Second key insight

Git works fully offline. So does the local tool. But agents are NEVER offline — they’re cloud API calls (or local model inference). The “offline” property isn’t about network connectivity. It’s about data sovereignty and zero-dependency adoption. Like git: your repo is yours regardless of whether you push to GitHub.

§Third key insight

The target user doesn’t run git init. They use GitHub Desktop or click “Create Repository” in a browser. The infrastructure is invisible. The experience is simple.

§The trust gradient

The fundamental product insight: people don’t adopt AI agents because they fear ruin — irreversible damage they can’t undo and can’t assess.

The solution isn’t better permission systems. It’s eliminating ruin architecturally.

CURRENT STATE:
  "dangerously-skip-permissions" ← the word "dangerously" is in the flag name
  Developer must manually build trust through weeks of observation
  One agent at a time, one provider at a time
  
OUR PRODUCT:
  Container sandbox = ruin is impossible
  Full autonomy from minute one
  Trust timeline collapses from weeks to zero
  
THE REFRAME:
  Not "fear of ruin → ruin impossible → full autonomy"
  But "build anything → break nothing → limitless experimentation"
  Positive framing. Creative freedom. A sandbox is where kids play.

The trust gradient as an adoption funnel:

1. “I want to build something” → one agent, one model, container, zero risk
2. “I want more control” → choose your model, customize your config
3. “I want multiple agents” → add agents to the same container
4. “I want to share what works” → publish your recipe
5. “I want to find what works” → browse recipes with track records → Signet

Each step is pulled by the user’s needs, not pushed by the feature roadmap.

§Recipes: the viral unit

The most valuable artifact in AI isn’t code or conversations. It’s the configuration that reliably produces good output. System prompts, model selection, role definitions, coordination protocols. These are:

• Fragile: changing one line can ruin the output
• Expensive to discover: weeks of trial and error
• Hoarded and shared like coveted family recipes

A recipe is a portable, versioned, shareable AI configuration. It runs identically on any machine with the runtime installed.

§Recipe examples across domains

Developer: “My three-agent code review pipeline — Claude for architecture, Codex for implementation review, local model for test coverage checking.”

College student: Three variants of a crush — emotionally available, avoidant, honest-but-awkward. Run conversations with all three. Discover which patterns you’re drawn to. Share a recipe with your roommate: “try talking to this and tell me if I’m crazy.”

CFO: Four simulacra of her board members. Stress-test a strategic pitch twenty times against simulated personalities calibrated to real objections. Walk into the real meeting having rehearsed every scenario.

Bad recipe (and why reputation matters): A guy creates a simulacrum of his ex configured to always lose arguments. Every conversation validates him. The receipts look good but the recipe is garbage — it’s a strawman, not a simulation. Signet’s reputation layer catches this: a recipe where every conversation ends the same way is rated poorly. The receipts reveal the recipe’s quality, not just the outcome.

§Why recipes go viral

Developers share configs because they’re nerds. Everyone else shares personality configs because they’re human. “Try talking to this” spreads faster than any developer tool.

§The spectacle (free distribution)

The viral distribution mechanism isn’t something you build. It’s an emergent property of the product being provider-agnostic.

Nobody has seen Claude, Codex, and Gemini in the same room working on the same problem. People have parasocial relationships with these models — preferences, loyalties, opinions about which is smarter. Watching them interact is inherently compelling. Marvel-meets-DC for AI.

Every user session is shareable content. The developer’s multi-agent coding session AND the student’s simulated conversation are both watchable, shareable, compelling. The TikTok isn’t “watch AI build a todo app” (commoditized). It’s “watch Claude and Codex argue about architecture while Gemini plays devil’s advocate” (nobody has this).

This selects for the right audience: people curious enough about AI agents to eventually become builders/users themselves.

Critical: the spectacle is not a feature. It’s not scope creep. It’s what naturally happens when the product works. You don’t build it. You make interactions visible and shareable by default.

§Two doors, one room

The product has two entry points into the same infrastructure:

Both users run the same runtime. Both generate Nostr events. Both create and consume recipes. The architecture doesn’t distinguish between them.

§The product is not for developers

Or rather: it’s not ONLY for developers. The “$30/month is too expensive” person running Ollama on their laptop and the college student who wants private AI conversations are the SAME user. They both want:

• Free (local models, no API keys)
• Private (on their machine, no cloud)
• Customizable (saved configurations that persist)
• Shareable (give my friend my setup)

The developer is a subset of this audience, not the whole audience.

§Competitive positioning

Every AI provider is building walled gardens. Anthropic wants you all-in on Claude. OpenAI wants you all-in on Codex. Google wants you all-in on Gemini. None of them will EVER build the interop layer because it’s against their incentive structure.

We’re the Switzerland of AI. Provider-agnostic by design. The only place where Claude, Codex, Gemini, Llama, and whatever ships next month all work together.

We don’t compete with any of these. We compose them.

§The moat

1. Recipe network effects: Recipes improve through forking and competition. More developers sharing → better recipes → more developers. Compounds.
2. Event data: Every session generates signed Nostr events. Signet is the only indexer. By the time anyone realizes a recipe reputation layer matters, we have the data.
3. Provider-agnostic positioning: No provider will build this. Interop is against their business model.
4. Open source + open protocol: Can’t be acquired and killed. Can’t be enshittified. Nostr is the protocol (nobody owns it). The tool is FOSS. Value accrues to Signet.
5. Two-sided adoption: Developer and non-developer users reinforce the same network through different entry points.

§Signet’s role

Signet was always described correctly: “Signet lets you see what matters and why. With receipts.”

It was just pointed at the wrong entry point. The original approach: convince the world they have a credibility crisis, then offer Signet as the solution. Nobody wakes up caring about that.

The new approach: give everyone a free, private, powerful AI runtime. Recipes emerge. Sharing happens. The event stream grows. Signet indexes it and tells you which recipes are good and which are bullshit. “With receipts” means: here’s the track record, verified, for any AI configuration anyone has ever shared.

The college girl’s roommate can check the recipe’s reputation before running it. The developer can see that a coding recipe has a 94% task completion rate. The CFO can verify that a board-simulation recipe actually challenges users instead of validating them.

Signet doesn’t judge what you use AI for. It tells you whether the configuration is actually good at what it claims to do.

§Bootstrap sequence

1. Ship the runtime — Docker image, any agent, any model, zero risk, free
2. Recipes emerge — users save and share configurations organically
3. Events accumulate — every session generates signed Nostr events locally
4. Relay sync — users opt into publishing, the network forms
5. Signet indexes — recipe reputation, agent trust, discovery
6. Network effects compound — better recipes attract more users attract better recipes

The swarm bootstraps the event stream. The event stream bootstraps Signet. Signet bootstraps the network. The network bootstraps the market.

§AWS GAIA pitch (June 2026)

Millions of people are adopting AI — for coding, for conversation, for creative work. They all hit the same walls: they can’t use AI privately, they can’t run agents from different providers together, and they can’t tell which AI configurations actually work. We built an open-source runtime that makes AI safe, private, and free — any agent, any model, containerized so nothing can break. Users save their AI configurations as “recipes” — portable, forkable, with verifiable track records. Signet is the network layer that indexes recipe reputation across the ecosystem. We’re building the trust infrastructure for the agentic internet. Our own multi-model agent swarm runs on it today.

§The tagline

It never needed to change.

Signet: see what matters and why. With receipts.

[Local tool]: Build anything. Break nothing.