For 2,000 years the money was in the lie.
Information asymmetry — I know what you don't, I hide it, I profit from the gap — is the business model under advertising, finance, platforms, and supply chains. The web we got runs on it: value extracted from what you can't see. The dark web is just the honest name for what the whole thing already is underneath.
Imajin is the light web. A sovereign, auditable layer where identity, history, and value are things you can see and own — not things done to you in the dark. It flips the gradient: honesty becomes the profitable move, because the signed record is the value. Hiding stops paying; disclosure starts. Be honest. Make money. The human is centered not as a slogan but as a consequence — a system that can't profit by lying to you has to serve you.
You do a human thing — send a voice note, take a photo, drop a file. An agent figures out what you meant, does it on your behalf, asks before anything leaves your hands, and signs a record of what it did. The machinery recedes; the proof remains.
See it live · Buy us a coffee · Jin's Launch Party
Live since February 2026. 2,700+ commits. One kernel, two platform apps, five Imajin apps, three client apps. All real, all self-hostable. Open source, MIT. Your data, your keys, your domain.
The thesis is the substrate; these are the proof it's real and running.
- Run a community. Members, forums, governance, shared identity — without renting from Discord, Circle, or Mighty Networks.
- Run events. Sell tickets, accept e-Transfer or Stripe, send receipts, manage guest lists. jin.imajin.ai/events
- Host an identity. Cryptographic DID, profile page, link tree, attestations, contact channels. jin.imajin.ai/profile
- Accept payments. Stripe plus optional Solana. Your keys, your account, your money.
- Plug in custom apps. Reuse auth, identity, payments, and attribution as primitives instead of stitching together five SaaS APIs.
- People who want an agent that manages their digital life without selling them out.
- Community operators running clubs, courses, events, or member groups who want to leave Discord, Circle, Eventbrite, or Mighty Networks.
- Developers building on a sovereign identity plus payments plus attribution stack instead of SaaS APIs.
- Founders who want to own their data layer end to end rather than rent it.
- People who want a turnkey hosted SaaS with no setup. Today this is self-hosted or instance-hosted by us.
- People looking for a token to trade. There isn't one. MJN is an internal accounting unit (1 MJN = 0.01 CHF), not a public asset. Hardware first, token later. Year 3.
Imajin runs on MJN, an open protocol that carries identity, attribution, consent, and value natively in every exchange.
The protocol is currency-agnostic. Your node can settle in CAD via Stripe, in USD, in community credits, in MJNx if you choose, or in whatever makes sense for your community. MJNx is to Imajin as USD is to SWIFT. SWIFT moves money. It doesn't BE money.
The protocol doesn't require the token. The token requires the protocol.
Today: One dominant hosted kernel at imajin.ai. We run it. You can sign up, use the apps, and verify everything works. Self-hosting is documented and supported. The code is open source and MIT-licensed.
Tomorrow: Federation means any community can run its own node on its own domain with its own policies. The architecture is already federated at the protocol layer. The missing piece is the node-to-node handshake and data migration tooling. That work is in progress.
Year 1: Software. Year 2: Devices. Year 3: Chip.
The matrix is the substrate's vocabulary — the verbs any intent resolves to, the same whether the actor is a person, a family, or a community. The agent doesn't invent capabilities; it composes these cells on your behalf. Every problem the protocol solves is a cell; every service in this repo implements cells.
| Attestation | Communication | Attribution | Settlement | Discovery | |
|---|---|---|---|---|---|
| Actor | Credentials, reputation | Direct messaging | Personal .fair manifests | Payments, tips | Profile, presence |
| Family | Custodial consent | Shared channels | Shared attribution | Shared resources | Family node |
| Community | Governance weight | Scoped forums | Collective .fair | Quorum settlement | Federated registry |
| Business | Reviews, compliance | Commercial messaging | Product attribution | Transaction fees | Marketplace listing |
Crypto got proof of work wrong. Burning electricity to win a lottery isn't work. It's waste. Imajin's attestation model is proof of history: a signed, append-only record of real things that happened. You showed up. You created something. You paid for that. This person vouched for you.
The value isn't in the burning. It's in the record. And that record can't be forked, because you can copy software but you can't copy lived experience.
Core services that make up the sovereign stack.
| App | Dev Port | Prod Port | Domain | Purpose | Status |
|---|---|---|---|---|---|
| kernel | 3000 | 7000 | imajin.ai | Core platform: auth, identity, pay, profile, connections, registry, chat, media, notify | Live |
| events | 3006 | 7006 | jin.imajin.ai/events | Create events, sell tickets | Live |
Account-based apps tied to a user's DID, accessible at jin.imajin.ai/{service}/{handle}.
| App | Dev Port | Prod Port | Purpose | Status |
|---|---|---|---|---|
| coffee | 3100 | 7100 | Tip jar / support page | Live |
| dykil | 3101 | 7101 | Surveys & polls | Live |
| links | 3102 | 7102 | Curated link collection | Live |
| learn | 3103 | 7103 | Courses, lessons, learning progress | Live |
| market | 3104 | 7104 | Marketplace: listings, trust-gated commerce | Alpha |
Separate repos. Consume the platform but aren't part of it. Own databases.
| App | Repo | Domain | Purpose | Status |
|---|---|---|---|---|
| fixready | imajin-fixready | fixready.imajin.ai | Home repair knowledge marketplace | Live |
| karaoke | imajin-karaoke | karaoke.imajin.ai | Music & performance | Live |
| scorecard | imajin-scorecard | scorecard.imajin.ai | Scored assessments & lead generation | Alpha |
The platform exposes a plugin surface — auth, pay, registry, trust-graph, profile, and .fair attribution — consumed by independent apps that own their own data and ship on their own cadence. Three apps currently build on this surface: karaoke, fixready, and scorecard. Three is the threshold where bad abstractions start to show; the surface has held under it.
| Consumer | Repo | Live deps | Planned |
|---|---|---|---|
| karaoke | imajin-karaoke | Identity, Events, Connections | Attestation, Settlement (PWYC tipping) |
| fixready | imajin-fixready | Identity | Attestation, Settlement, Discovery |
| scorecard | imajin-scorecard | Identity | Attestation, Settlement, Discovery |
Three consumers pulling on different cells is the project's strongest current evidence that the matrix is a real surface, not a diagram.
Shared libraries used across all apps.
| Package | Purpose |
|---|---|
| @imajin/auth | Ed25519 signing, verification, DID creation |
| @imajin/db | Database layer (postgres-js + drizzle-orm) |
| @imajin/pay | Unified payments (Stripe + Solana) |
| @imajin/config | Service manifest, session config, CORS |
| @imajin/ui | Shared UI components |
| @imajin/input | Input components (emoji, voice, GPS, file upload) |
| @imajin/media | Media browser & asset display components |
| @imajin/fair | .fair attribution (types, validator, editor components) |
| @imajin/onboard | Anonymous to soft DID onboarding (<OnboardGate>) |
| @imajin/email | Email sending (SendGrid), templates, QR generation |
| @imajin/chat | Chat components (Chat orchestrator, MessageBubble, voice, media) |
| @imajin/trust-graph | Trust graph queries (connection checks) |
| @imajin/cid | Content-addressed identifiers (CID generation) |
| @imajin/dfos | DFOS integration — an open standard for cryptographic identity and verifiable content (chain provider, relay) |
| @imajin/llm | LLM inference abstraction (cost tracking, routing) |
Everything that acts gets a DID.
import { generateKeypair, createIdentity, sign, verify } from '@imajin/auth';
// Generate keypair (you hold the private key)
const keypair = generateKeypair();
// Create identity
const identity = createIdentity(keypair.publicKey, 'human');
// → { id: "did:imajin:abc123...", type: "human", publicKey: "..." }
// Sign messages
const signed = await sign({ action: 'purchase' }, keypair.privateKey, identity);
// Verify anywhere
const result = await verify(signed, keypair.publicKey);1. Client generates Ed25519 keypair (client-side, never leaves device)
2. POST /api/register { publicKey, type } → DID assigned
3. POST /api/challenge { id } → challenge string
4. Client signs challenge with private key
5. POST /api/authenticate { id, challengeId, signature } → session token
6. Token used for authenticated requests
No passwords. No OAuth. No "Sign in with Google." Just cryptography.
App (events, coffee, etc.)
│
└── POST /api/checkout { items, successUrl, ... }
│
↓
Pay Service (node's Stripe keys)
│
↓
Stripe Checkout Session
│
↓
Webhook → Fulfillment callback
Apps don't need Stripe keys. They call the node's pay service. Pay uses Stripe Connect — each node operator is a connected account with their own KYC and is independently the merchant of record for their transactions. The platform is not a shared merchant. Funds settle directly to the operator.
git clone https://github.com/ima-jin/imajin-ai.git
cd imajin-ai
bash scripts/setup-local.shThe script checks prerequisites, installs dependencies, creates the imajin_dev database, generates .env.local files for every service with all secrets wired together, and runs migrations. When it finishes, start kernel:
pnpm --filter @imajin/kernel dev # http://localhost:3000Then open http://localhost:3000/register to create your first identity. See docs/DEVELOPER.md for the full developer guide.
imajin-ai/
├── apps/
│ ├── kernel/ # Core platform (3000)
│ ├── events/ # Events & ticketing (3006)
│ ├── coffee/ # Tip jar (3100)
│ ├── dykil/ # Surveys & polls (3101)
│ ├── links/ # Link collection (3102)
│ ├── learn/ # Lessons & courses (3103)
│ └── market/ # Marketplace (3104)
├── packages/
│ ├── auth/ # @imajin/auth — signing, DIDs
│ ├── cid/ # @imajin/cid — content identifiers
│ ├── chat/ # @imajin/chat — chat components
│ ├── config/ # @imajin/config — shared config
│ ├── db/ # @imajin/db — database layer
│ ├── dfos/ # @imajin/dfos — protocol integration
│ ├── email/ # @imajin/email — email + templates
│ ├── fair/ # @imajin/fair — attribution
│ ├── input/ # @imajin/input — input components
│ ├── llm/ # @imajin/llm — inference abstraction
│ ├── media/ # @imajin/media — media components
│ ├── onboard/ # @imajin/onboard — DID onboarding
│ ├── pay/ # @imajin/pay — payments
│ ├── trust-graph/ # @imajin/trust-graph — trust queries
│ └── ui/ # @imajin/ui — shared components
├── docs/
│ ├── DEVELOPER.md # Getting started guide
│ ├── ENVIRONMENTS.md # Database & deployment config
│ ├── MIGRATIONS.md # Database migration system
│ └── mjn-whitepaper.md # MJN protocol spec
└── tests/
├── HAPPY_PATH.md # End-to-end test cases
└── AUDIT.md # Security audit checklist
Self-hosted on HP ProLiant ML350p Gen8 (Ubuntu 24.04). Caddy for reverse proxy plus auto-SSL. pm2 for process management. GitHub Actions self-hosted runner for CI/CD.
Port convention: 3xxx = dev, 7xxx = prod (1:1 mapping). Three tiers:
x000-x099— Core platform servicesx100-x199— Imajin apps (account-based, DID-linked)x400-x499— Client apps (standalone repos, own databases)
pm2 naming: Bare names = prod (kernel, events). Prefixed = dev (dev-kernel, dev-events).
See ENVIRONMENTS.md for full deployment topology.
| Document | Purpose |
|---|---|
| MJN Whitepaper | Protocol specification — 4 scopes x 5 primitives |
| Developer Guide | Getting started — quickstart, env vars, local dev |
| Environments | Database & deployment config |
| Migrations | Database migration system |
| Essays | Thesis, architecture, industry applications (30+ essays) |
| Metric | Value |
|---|---|
| Codebase | ~122K lines |
| Commits | ~2,480 |
| Identities | 246 |
| Live since | February 2026 |
| Inference cost | ~$12K |
| Services | 9 apps + 21 shared packages |
| License | MIT |
1 kernel (9 domains) plus 6 federated apps. All open source. All self-hostable.
Jin's Launch Party — April 1, 2026
The genesis event. First real transaction on the sovereign network.
- Virtual: $1 (unlimited)
- Physical: $10 (Toronto)
Built with this stack. Tickets signed by the event's DID.
This is early. The architecture is stabilizing but APIs will change.
If you want to run your own node or build on the stack, start with the Developer Guide, then open an issue or find us on DFOS.
- Talk to us first. Before requesting assignment on issues, claiming work, or submitting PRs — come find us on DFOS and introduce yourself. We want to know who we're working with.
- No drive-by PRs. Unsolicited PRs from accounts with no prior conversation will be closed.
- Bot accounts and automated "/apply" comments will be deleted and blocked.
Found a vulnerability, or want to know what we do and don't guarantee yet? See SECURITY.md for the responsible-disclosure process and an honest list of known limitations. We're pre-1.0 sovereign plumbing — not claiming to be unhackable, just claiming to be honest about where we are.
Imajin is open source. We're not going to stop you — the license means what it says, run it for anything you like, no permission required. That's the point of a sovereign system.
But know what you're running. Imajin signs everything. Every action leaves an attributable, non-repudiable record — that's not a feature we bolted on, it's the whole thesis. For two thousand years the money was in the lie; Imajin is built so that hiding stops paying and disclosure starts.
So we'll be honest about the uses we don't jive with: surveillance, targeting, anything built to act on people in the dark. We're not going to forbid them. We're going to do something we think is stronger — make them legible. If you use this system to do something you'd rather not have on the record, understand that the system's job is to put it on the record. That's not a bug we'll fix for you.
We hold ourselves to the same thing. Imajin is built in the open, its actions signed, its history auditable — including ours. We're prepared to be on the record. That's the deal we're offering everyone else, and we took it first.
Have at it. Careful what you wish for.
MIT
Built by Imajin — 今人 (ima-jin) — "now-person" / "imagination"