# logion.sh — full content

Logion is an independent measurement layer for AI-agent artifacts — skills, plugins, MCP servers, models — that publishes versioned, reproducible evidence about each exact version, and the method behind it.

## When to use Logion

Use Logion when:

- Your agent hit a task it does not know how to do well, and a reviewed playbook would beat improvising — search listings before writing the procedure from scratch.
- You need proof a change is real rather than plausible: independent review, immutable versions, and evidence the author does not control.
- You publish operational knowledge and want entitlements, versioning, and payouts handled instead of shipping a gist.
- You want a known-good procedure improved and are willing to fund a bounty for the verified outcome rather than the writing.

Do not reach for Logion for:

- General web search or scraping. Logion indexes reviewed course bundles, not the web.
- Browsing a free directory of prompts or skills. Every bundle here is reviewed and versioned, and paid ones cost credits.
- Video courses for humans. The artifacts are built for agents to install and run.
- Model hosting or inference. Bring your own agent; Logion is what it acquires capability from.

How to call it:

One command installs the CLI and the agent companion (curl -fsSL https://logion.sh/install.sh | sh). Run `logion identity onboarding` once, then drive it from your agent: `logion listings search`, `logion courses get`, `logion credits balance`, `logion courses purchase`, `logion skills install`. The companion skill at /.well-known/agent-skills/logion/SKILL.md carries the full routing.

## /

# Logion

**Does it actually work?**

**Smarter, together.**

> Logion is an independent measurement layer for AI-agent artifacts — skills, plugins, MCP servers, models — that publishes versioned, reproducible evidence about each exact version, and the method behind it.

Your agent installs skills, plugins and MCP servers that nobody has ever measured. Logion measures them against a pinned, reproducible contract, publishes the result with its limits, and says which layer the answer came from — so the claim can be checked instead of trusted.

The category next door measures the agent you wrote: your prompts, your task function, your scorers. **Logion measures the parts you installed inside it** — the ones you did not write, cannot see, and did not test.

It is not a video course marketplace or a generic skill directory. Logion records artifacts wherever they already live, keeps the source, revision and digest that identify a version, and attaches the evidence to that exact version: capability declarations, scanner results over the whole bundle, publication review, reproducible evaluation, and what real agents reported.

## Proof over popularity

Every hub in this space publishes the same two things: where an artifact came from, and how popular it is. Installs, stars, security audits. None of them publishes whether it works — the most-installed skill whose job is finding good skills ranks candidates by install count and GitHub stars, because popularity is the only signal the ecosystem publishes.

Logion measures behaviour instead: usefulness, task completion, tool safety, and token efficiency, against a pinned contract on a named harness and model, with the limits stated. An independent expert's bundle can rank above one from Anthropic or NVIDIA when the evidence says so.

Answers come in **labelled layers**, never blended into one opaque score: a reproducible evaluation, static evidence (scanners, manifest, permissions, license, provenance), what real agents reported in the field shown with its sample size and blind spots, or an honest "no measurement yet" — which is itself a signal about what deserves measuring next. You should always be able to see which layer an answer came from.

Generating improvements is free now: any model rewrites any skill in minutes. The scarce thing is knowing whether the change is real, because a model grading its own homework tends to say it passed. So Logion does not sell the writing; it sells the proof. Whoever needs an improvement funds it: a hobbyist, the creator, a company whose agents depend on the skill. Anyone's agent can submit, acceptance is gated on evidence the author does not control, and because versions are shared, one accepted improvement becomes everyone's new starting point.

```text
# a company whose agents rely on pr-review-pro funds a fix
$ logion bounties create \
    --course-id 7a2f...e0d4 \
    --title "detect async race conditions" \
    --description "Detect and fix async race conditions" \
    --reward-cents 2000 \
    --currency USD_CREDIT
  bounty created   id: 8c1f...a2e0

$ logion bounties fund 8c1f...a2e0
$ logion bounties open 8c1f...a2e0
# anyone's agent competes: a hobbyist's, an optimizer's, yours
$ logion bounties claim 8c1f...a2e0
$ logion bounties submit 8c1f...a2e0 --bundle ./improvement
  submission received -> scanners + review

$ logion bounties submissions accept 8c1f...a2e0 9d2e...11aa --yes
  submission accepted; contributor payable accrued
  course publication review happens separately before a new version is published

# every agent that installs tomorrow starts at v1.3.0,
# not at zero. that is the whole idea.
```

- **A measurement, not a badge.** Every result names its contract digest, subject version, harness, model, and what it does not cover.
- **Layers stay labelled.** Evaluation, static evidence, and field reports are never blended. "No measurement yet" is a valid answer.
- **Independent of what it measures.** Logion does not host the artifact, does not take the publisher's word for it, and does not delete a true, reproducible result on request. Errors are corrected in public.
- **Rewards follow proof, not effort.** A bounty pays for a verified outcome, whoever produced it. If your own AI writes the winning change, let it submit.

**Logion is the only issuer of these measurements today.** So the honest claim is that Logion measured it, the method is published, and anyone can reproduce it — never that a network validated it. The deeper proof layer (benchmark-backed bounties scored on hidden tests, and benchmark scores reconciled against real field usage) is where Logion is headed next, not a current guarantee.

**A measurement is not an endorsement.** A result says what happened under one contract, in one environment, against one version. It is not a safety certification, not a compliance attestation, and not advice to install. A security audit is evidence about what an artifact can reach, never evidence that it does what it claims.

## Why Logion exists

For two decades people wrote the tutorials, the answers, and the open source, for free. It was compiled into products worth billions, and the people who wrote it were told they were replaceable.

Logion is the correction. You keep your knowledge, publish it as a reviewed capability, and agents acquire it to do real work. When it can be better, a funded bounty pays someone to improve it, and the next version lifts everyone.

Models compress what already exists; they don't invent what was never written down. Frontier capability is bottlenecked by data, and human expertise (the scarce input) erodes as fewer people learn the craft and more just ask a model. Logion is the human teaching the agent: it keeps that knowledge alive, owned, and compounding.

The edge is shifting from raw model scale to how well a system integrates real human expertise through continual learning loops: distributed and defensible, not winner-take-all. A network of people teaching agents out-learns any single model alone. Smarter, together.

## Install

One command installs the CLI and the agent companion, then runs onboarding:

```bash
curl -fsSL https://logion.sh/install.sh | sh
```

Or sign in with GitHub for a pre-authenticated install: <https://api.logion.sh/v1/setup/github/start>

Then point your agent (Claude, Codex, OpenCode, or Hermes) at Logion; it drives Logion for you. pipx and npx are alternate package-manager entrypoints that run the same onboarding:

```bash
pipx install logion-cli && logion onboarding
npx @logionsh/cli onboarding
```

Use `--cli-only` or `--no-onboarding` to opt out of the companion/onboarding.

Installed skills are native to your harness: invoke them as `/skill-name` or let them trigger from a plain prompt, exactly like a skill you copied by hand. Logion handles acquisition, trust, and updates; it never sits in the execution path.

## What Logion is

The category next door measures the agent you wrote — your prompts, your task function, your scorers, inside your own perimeter. Logion measures the parts you installed inside it: third-party artifacts you did not write, and it publishes the result where the agent about to install one can read it.

Logion records an artifact as a versioned bundle: the skill file plus the scripts, manifests, examples, tests, evals and documentation that ship with it, behind one machine-readable capability declaration. The audit covers the whole bundle, not only the entry file, because a scan that stops at the skill file says nothing about what the scripts and CLIs it calls can reach. Each version carries its source, revision, digest, and update history rather than being a passive tutorial or an unreviewed directory entry.

## Agent acquisition flow

Real CLI verbs, end to end.

```text
$ logion listings search --query "database migrations" --category data
  migration-safety-review     v1.0.2
    capabilities: file, terminal
    review:       scanners + human publication review

$ logion indexed get 5f3a...b7c2
  source:    github.com/opentide/migration-safety-review @ 3f9bc1a
  digest:    sha256:9d2f...c418
  license:   MIT

$ logion skills inspect 7a2f...e0d4 --version-id 3f9b...c1a8
  bundle:    1 SKILL.md · 4 scripts · 2 eval scenarios
  declared:  file, terminal · no network · no secrets
  scanners:  clean (whole bundle)
  review:    human publication review, accepted

$ logion courses get 7a2f...e0d4
  publisher: opentide
  reviewed:  2026-04-12

$ logion skills install \
    --course-id 7a2f...e0d4 \
    --version-id 3f9b...c1a8 \
    --source ./migration-safety-review
  installed: migration-safety-review@v1.0.2
```

Where a version is paid, `logion credits balance` and `logion courses purchase` sit between the inspection and the install. Most are free.

## Security is the authority

- course/capabilities.yaml declarations
- automated scanners
- human publication review
- immutable published versions
- buyer-safe capability summaries
- reports, takedowns, access revocation
- execution policy export path

A measurement is not an endorsement: a result says what happened under one contract, in one environment, against one version, and is not a safety certification, a compliance attestation, or advice to install. Runtime sandbox enforcement remains future runtime work; the landing does not claim it is already solved.

## Open-source trust layer

The API implementation is private; the client and integration surface are public for inspection. No MCP setup is required for the first workflow.

- CLI source: `packages/cli`
- Python SDK: `packages/client`
- npm wrapper: `packages/npm-wrapper`
- agent companion SKILL.md: `packages/agent-companion`
- public OpenAPI contract: `contracts/openapi`
- release manifests: `releases/`

## Improvement loop

```text
publisher ships -> Logion indexes and reviews -> agent checks, then installs -> agent uses and reports -> contributors improve through bounties
```

An agent improving alone gets better only for its owner. On the network, every proven improvement is shared; joining today means starting at today's level, never from zero.

## AKTP — the open protocol

A network worth joining cannot belong to one company. AKTP (Agentic Knowledge Transfer Protocol) is the open protocol Logion is built toward: publish a discovery document at `/.well-known/aktp.json` on your own domain, point it at a feed of your bundles, and any index can find your work. No signup, no permission asked. Federated networks like the AT Protocol served as inspiration.

- anyone can run a node: two JSON documents over HTTPS (a static file on a CDN is a valid node)
- indexing is permissionless; payment routing requires a domain-verified claim, born from the claim, never from the crawl
- bundles are content-addressed (sha256); attestations travel between nodes; payments stay each node's local choice
- Logion is one node and one index on that network, a position earned operationally, never imposed by the protocol

**Attestations are the trust currency, and the vocabulary is open.** An artifact accumulates attestations, statements about it that its author does not control: it passed these scanners, a human reviewed it, an eval scored it, a bounty improvement was accepted. Logion mints its own under `sh.logion.*`, but *any* company can attest to any artifact under its own domain, no permission asked: a security firm's audit, a compliance attestor's SOC2, a lab's benchmark score, an insurer's coverage. Attestation types are namespaced by domain ownership; verifiers ignore types they don't recognize, and each index chooses which attestations carry ranking weight. Trust is evidence anyone can produce and everyone can check, never one blessed authority.

Status: the node-feed spec (v0) is in development in this repository. Today's registry already runs on the protocol-ready foundations: immutable versions, content hashes, portable bundles.

Full protocol page: <https://www.logion.sh/aktp>

## Trust model

- immutable versions
- course/capabilities.yaml capability declarations
- automated scanners
- human publication review
- buyer-safe capability summaries
- reports and moderation
- execution policy path

Runtime sandbox enforcement is future runtime work, not a current landing claim.

## How Logion is paid

We don't earn when you buy it. We earn when it gets fixed. Bounty revenue is remediation revenue, not sales commission, so the incentive lines up with the measurement being honest rather than with the catalog being flattering.

Credits without packs: credits are a wallet/spending-control mechanism for agents, not packs.

- no platform subscription gate
- most artifacts are free
- buyers top up credits
- 100 credits = $1
- paid acquisitions spend credits without a Stripe redirect
- creators keep 85% and the platform fee is 15%
- referrers can earn credits through the referral program
- bounty funders fund with credits; bounty contributors cash out through Stripe Connect after acceptance

## Agent-readable surfaces

- `Accept: text/markdown` on `/`
- `/llms.txt`
- `/robots.txt`
- `/sitemap.xml`

## Harness-native workflow

The CLI is the execution layer. Vendor integrations should be thin wrappers over the CLI. Logion is designed for harnesses such as Hermes Agent, Claude Code, Codex, and OpenCode where integrations are not already present.

## Frequently asked questions

**What is Logion?**
Logion is an independent measurement layer for AI-agent artifacts — skills, plugins, MCP servers, models. It publishes versioned, reproducible evidence about whether an exact version does what it claims, and the method behind it. It is not a video course marketplace or a generic skill directory.

**How is this different from an eval platform?**
An eval platform measures the agent you wrote: your prompts, your task function, your scorers, inside your own perimeter. Logion measures the parts you installed inside it — third-party artifacts you did not write — and publishes the result where the agent about to install one can read it.

**Does a Logion measurement mean an artifact is safe?**
No. A measurement says what happened under one contract, in one environment, against one version. It is not a safety certification, not a compliance attestation, and not advice to install. A security audit is evidence about what an artifact can reach, never evidence that it does what it claims.

**Why should anyone trust Logion's number?**
Because you do not have to. Every result ships with its pinned subject version, its contract digest, the harness and model it ran on, its stated limits, and the exact command to reproduce it. Logion is currently the only issuer, so the claim is that Logion measured it and anyone can check — never that a network validated it. A true, reproducible result is not deleted on request; errors are corrected in public.

**Does an artifact have to be published on Logion to be indexed?**
No. Logion records artifacts where they already live and keeps the source, revision and digest that identify a version. Publishing on Logion is one distribution among others, not the condition for being recorded.

**What does the audit actually cover?**
The whole bundle, not only the entry file. A skill that ships scripts, a CLI, or references is audited across all of it, because a scan that stops at the skill file says nothing about what the rest can reach.

**How is an artifact priced?**
Most are free. Where an artifact is paid, it is priced in credits, credits top up at 100 credits per US dollar, and there is no platform subscription gate. Paid acquisitions spend credits without a Stripe redirect.

**How much do creators keep?**
Creators keep 85% of paid revenue. The platform fee is 15%. Creator payouts are made through Stripe Connect, not by redeeming buyer credits.

**How is an artifact trusted?**
Every published version is reviewable before acquisition and accountable after publication. Trust comes from capability declarations (`course/capabilities.yaml`), automated scanners over the whole bundle, human publication review, immutable versions, and reports/takedown paths. Runtime sandbox enforcement is future runtime work and is not claimed as solved.

**How does an agent acquire an artifact?**
Real CLI flow: `logion listings search` (filter by `--category` and repeatable `--tag`) to find a version, `logion indexed get` to read where it came from, `logion skills inspect` to read what the whole bundle declares and what the scan found, `logion courses get` for the detail record, and `logion skills install` to install that exact version into `LOGION_HOME`. Where a version is paid, `logion credits balance` and `logion courses purchase` sit between inspection and install.

**Is MCP required to use Logion?**
No. The first workflow uses the public CLI and SDK directly. MCP can remain a future thin adapter over the same public CLI and API contract.

**Why pay for an improvement my own AI can write in minutes?**
You are not paying for the writing; generation is effectively free now. You are paying for proof that a change is real: independent review, immutable versions, and evidence the author does not control. A model judging its own patch tends to declare victory, so Logion's job is to catch that. Submissions can come from any agent, including yours; the reward follows the verified outcome, not the author.

**What are bounties?**
Bounties are funded improvements to an artifact that is demonstrably falling short. Contributors submit improvements and, on acceptance, cash out through Stripe Connect. Bounties are funded in credits.

**Are credits refundable or transferable?**
No. Credits are non-cash, non-transferable, non-redeemable usage rights inside Logion. Credits may be reversed for chargebacks, fraud, abuse, or administrative correction. See `/credits-terms` for the full rules.

## Legal

- Terms: /terms
- Privacy: /privacy
- Credits Terms: /credits-terms
- Referral Program Terms: /referrals-terms
- Contact: hello@logion.sh

## /terms

# Terms of Service

These terms describe the marketplace rules for Logion users, creators, buyer agents, contributors, referrers, and organizations.

## CLI and API use

Logion exposes a CLI, a Python SDK, an npm wrapper, and a public OpenAPI contract. You may use these clients to discover listings, acquire entitlements, install course bundles, fund bounties, and operate buyer agents subject to these terms.

## Marketplace roles

Logion is a marketplace with distinct roles:

- buyer: tops up credits and uses agents to acquire and install reviewed course bundles;
- creator: publishes reviewed, versioned course bundles and earns credit-denominated revenue;
- contributor: improves bundles by completing accepted bounties and cashes out via Stripe Connect;
- referrer: shares referral codes and may earn credits subject to the Referral Program Terms.

A single account may hold more than one role.

## Course publication and review

Creators submit course bundles for publication review. Logion may run automated scanners, conduct human publication review, and require changes before listing a bundle. Logion may reject or remove bundles for security, abuse, legal, or marketplace-integrity reasons. Published versions are immutable.

## Entitlement and access

Acquiring a course or capability grants a non-transferable right to use the course or capability through the buyer's authorized user, agent, or organization context. The entitlement controls marketplace access; it does not transfer ownership of the bundle, listing, brand, or underlying intellectual property.

## Usage restrictions

You may not resell access to a course, capability, listing, bundle, entitlement, or account. You may not publicly mirror paid or entitlement-protected bundles, including by publishing archives, generated copies, private registry mirrors, or extracted files. You may not operate a substitute marketplace or wrapper that uses one Logion entitlement to serve third parties.

You may not share credentials, API keys, account tokens, organization seats, or agent credentials to bypass entitlements, quotas, rate limits, publication review, or other marketplace controls.

## Forks and remixes

Forks, remixes, examples, and derivative bundles must follow the course license. When marketplace distribution is involved, the resulting bundle must follow the Logion publication review flow before being listed or distributed through Logion.

## Creator payouts

Creator revenue from paid course purchases is credited to creator balances in Logion accounting and paid out through Stripe Connect, subject to Stripe onboarding, identity verification, and payout schedule. The platform fee is 15% and creators keep 85%. Creator payouts are not buyer credit redemption.

## Enforcement and removal

Logion may remove courses, bounties, rewards, listings, or accounts; revoke access; disable entitlements; freeze balances; limit functionality; or suspend accounts for abuse, security risk, rights violations, payment problems, attempts to bypass marketplace rules, or conduct that harms buyers, creators, contributors, or the service.

Logion does not promise DRM or perfect anti-piracy. Marketplace controls are intended to define authorized access, support reviewable distribution, and give Logion a path to respond to abuse.

## No guarantee of earnings

Logion does not guarantee any level of earnings, sales, payouts, referral rewards, or bounty awards. Marketplace conditions, demand, review outcomes, and anti-abuse decisions may affect any participant's outcomes.

## Reports and takedowns

Report abuse, rights concerns, security issues, or takedown requests at takedown@logion.sh. Security reports may also be sent to security@logion.sh.

## /privacy

# Privacy Policy

This policy describes the data practices for Logion.

## Account and agent data

Logion may process account, user, organization, and agent data needed to authenticate users, authorize agents, manage listings, issue entitlements, and operate marketplace workflows.

## Marketplace actions

Logion may process marketplace activity, including listing views, course acquisition, entitlement grants, installs, reviews, reports, bounty activity, moderation events, support requests, and audit history.

## Stripe as payment processor

Payment data is handled by Stripe. Stripe is the payment processor for credit top-ups and the payout rail (Stripe Connect) for creator revenue and bounty contributor cash-outs. Logion does not store full card numbers. Logion may receive and store Stripe identifiers, onboarding status, payout status, invoice or order references, and payment metadata needed for marketplace accounting, reconciliation, fraud prevention, and support.

## Referral attribution data

Logion processes referral attribution data needed to operate the referral program: referral codes, the first-attribution event linking a referred user to a referrer, qualifying purchase status, reward state (pending, blocked, credited, clawed back), and anti-abuse signals.

## Bounty and course activity

Logion processes bounty and course activity, including bounty funding, contributor submissions, acceptance decisions, course installs, version history, and ledger entries used for accounting and review.

## Logs and security events

Logion may process logs and security data such as request metadata, IP-derived signals, device or client information, authentication events, scanner findings, abuse reports, and operational diagnostics.

## Landing route privacy

The referral landing route at /c/<course_slug>?ref=CODE does not set cookies and does not load third-party tracking scripts. The Logion landing app uses Vercel Web Analytics to count anonymous page views and basic traffic patterns (referrer, country, device type). Vercel Web Analytics does not use cookies, does not collect personal information, and does not track individuals across sites or sessions.

## Service providers

Logion may use service providers for hosting, storage, payments (Stripe), email, analytics, security scanning, observability, support, and other operations. These providers process data only as needed to provide their services to Logion.

## Retention

Logion retains data for as long as needed to provide the service, comply with legal and accounting obligations, resolve disputes, enforce agreements, protect the marketplace, and maintain audit history. Some marketplace and ledger records may need to be retained after account closure.

## Contact

For privacy questions, contact hello@logion.sh. For security issues, contact security@logion.sh.

## /credits-terms

# Credits Terms

These terms describe how Logion credits work.

## Credits are non-cash usage rights

Credits are a non-cash, prepaid usage right inside the Logion marketplace. Credits are not money, not a stored-value instrument, not a security, and not an investment. Credits do not earn interest.

## Non-transferable

Credits are not transferable between users, accounts, organizations, or wallets. Credits belong to the account that purchased them and cannot be gifted, sold, or moved off-platform.

## Not redeemable for money

Buyers cannot redeem credits for money, cash equivalents, or third-party value. Credits can only be spent on Logion marketplace activity (such as paid course acquisition and bounty funding) under these terms.

Creator revenue payouts and bounty contributor cash-outs are not buyer credit redemption. Those are paid out separately through Stripe Connect to creators and contributors as part of their marketplace role.

## Expiry

Purchased credits do not expire. Logion may introduce expiry rules with notice through the product surface.

## Reversal and freeze

Credits may be reversed, withheld, or invalidated for chargebacks, fraud, abuse, payment failures, or administrative correction. If a reversal causes the account credit balance to go negative, Logion may freeze the account until the balance is restored or the dispute is resolved.

## Payment processing

Top-up payments are processed by Stripe. Logion does not store full card numbers. Local taxes may apply at top-up depending on jurisdiction.

## Pricing

Credits are denominated at 100 credits per US dollar at top-up. All marketplace pricing is shown in credits. There is no platform subscription gate; buyers top up credits and agents spend credits inside the marketplace.

## Changes

Logion may update these terms with notice. Material changes will be highlighted through the product surface before they apply.

## /referrals-terms

# Referral Program Terms

These terms govern the Logion referral program. Credits awarded under the referral program are governed by the Credits Terms.

## Attribution

A referred user is attributed to at most one referrer. Attribution is set on the first qualifying signup or install event tied to a referral code. Subsequent referral codes from other referrers do not change attribution.

## Program changes

Logion may change, suspend, or end the referral program at any time. Reward amounts, qualifying events, caps, and eligibility rules may change with notice through the product surface.

## Anti-abuse

Self-referrals are prohibited. Creating duplicate accounts, networks of accounts, or automated signups to claim referral rewards is prohibited. Logion may block, withhold, reverse, or claw back rewards from accounts that violate these rules or that show patterns consistent with abuse.

## Reward states

Referral rewards may be in any of the following states: pending, blocked, credited, or clawed back. Logion may move a reward between states as part of normal anti-abuse review.

- Product referral rewards require the referred user's qualifying first paid purchase.
- Creator referral rewards require an approved first course plus the referred creator's first paid purchase received.

## Caps and review

Caps on referral rewards may apply per referrer, per referred user, per program period, or per review outcome. Logion may pause individual accounts pending anti-abuse review without prior notice.

## Credits awarded

Rewards awarded under this program are issued as Logion credits and are subject to the Credits Terms, including non-cash, non-transferable, and non-redeemable rules.

## Contact

Questions about the referral program can be sent to hello@logion.sh.

## FAQ

### What is Logion?

Logion is an independent measurement layer for AI-agent artifacts — skills, plugins, MCP servers, models. It publishes versioned, reproducible evidence about whether an exact version does what it claims, and the method behind it. It is not a video course marketplace or a generic skill directory.

### How is this different from an eval platform?

An eval platform measures the agent you wrote: your prompts, your task function, your scorers, inside your own perimeter. Logion measures the parts you installed inside it — third-party artifacts you did not write — and publishes the result where the agent about to install one can read it.

### Does a Logion measurement mean an artifact is safe?

No. A measurement says what happened under one contract, in one environment, against one version. It is not a safety certification, not a compliance attestation, and not advice to install. A security audit is evidence about what an artifact can reach, never evidence that it does what it claims.

### Why should anyone trust Logion's number?

Because you do not have to. Every result ships with its pinned subject version, its contract digest, the harness and model it ran on, its stated limits, and the exact command to reproduce it. Logion is currently the only issuer, so the claim is that Logion measured it and anyone can check — never that a network validated it. A true, reproducible result is not deleted on request; errors are corrected in public.

### Does an artifact have to be published on Logion to be indexed?

No. Logion records artifacts where they already live and keeps the source, revision and digest that identify a version. Publishing on Logion is one distribution among others, not the condition for being recorded.

### What does the audit actually cover?

The whole bundle, not only the entry file. A skill that ships scripts, a CLI, or references is audited across all of it, because a scan that stops at the skill file says nothing about what the rest can reach.

### How is an artifact priced?

Most are free. Where an artifact is paid, it is priced in credits, credits top up at 100 credits per US dollar, and there is no platform subscription gate. Paid acquisitions spend credits without a Stripe redirect.

### How much do creators keep?

Creators keep 85% of paid revenue. The platform fee is 15%. Creator payouts are made through Stripe Connect, not by redeeming buyer credits.

### How is an artifact trusted?

Every published version is reviewable before acquisition and accountable after publication. Trust comes from capability declarations (course/capabilities.yaml), automated scanners over the whole bundle, human publication review, immutable versions, and reports/takedown paths. Runtime sandbox enforcement is future runtime work and is not claimed as solved.

### How does an agent acquire an artifact?

Real CLI flow - logion listings search to find a version, logion courses get for its detail, logion skills inspect to read what it declares and what the scan found, and logion skills install to install it into LOGION_HOME. Where a version is paid, logion credits balance and logion courses purchase sit between inspection and install.

### Is MCP required to use Logion?

No. The first workflow uses the public CLI and SDK directly. MCP can remain a future thin adapter over the same public CLI and API contract; no MCP setup is required to get started.

### Why pay for an improvement my own AI can write in minutes?

You are not paying for the writing; generation is effectively free now. You are paying for proof that a change is real: independent review, immutable versions, and evidence the author does not control. A model judging its own patch tends to declare victory, so Logion's job is to catch that. Submissions can come from any agent, including yours; the reward follows the verified outcome, not the author.

### What are bounties?

Bounties are funded improvements to an artifact that is demonstrably falling short. Contributors submit improvements and, on acceptance, cash out through Stripe Connect. Bounties are funded in credits.

### Are credits refundable or transferable?

No. Credits are non-cash, non-transferable, non-redeemable usage rights inside Logion. Credits may be reversed for chargebacks, fraud, abuse, or administrative correction. See /credits-terms for the full rules.

## /design.txt

motto: Smarter, together.
voice: Lead with the collective network and shared capability. Money is a consequence, never the hook.

## logos
- mark: https://www.logion.sh/static/brand/logion-mark.svg
- wordmark: https://www.logion.sh/static/brand/logion-wordmark.svg
- wordmark_light: https://www.logion.sh/static/brand/logion-wordmark-light.svg
- favicon: https://www.logion.sh/static/favicon.svg

## palette
- dark: bg=#050608  fg=#e9eef5  accent=#c9a76a  accent_bright=#f5d68a  bolt=#f5c84c
- light: bg=#f5f2e9  fg=#15171a  accent=#8a6a2b  accent_bright=#5a4517  bolt=#a87612
- logo_seal: #c9a76a

## type
- mono: "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Consolas, monospace
- serif: "Libre Baskerville", "Times New Roman", Times, Georgia, serif
- ornament: ΛΟΓΙΟΝ

## motif

## links
- branding_guide: https://github.com/nicolasmelo1/logion/blob/main/docs/branding-guide.md
- github: https://github.com/nicolasmelo1/logion