Scoutica Protocol: Turn Your CV Into a Skill Card That AI Agents Can Discover, Score, and Hire

Your CV Is Invisible — That's the Real Problem

You’ve spent years polishing your skills, shipping real projects, earning certifications. But right now, your career profile lives as unstructured text inside a PDF — buried on a job board, trapped behind a login wall, or gathering dust in a recruiter’s inbox.

No AI agent can read it. No matching algorithm can score it. No employer’s hiring tool can discover it programmatically. Your professional identity is basically invisible to the systems that are actually making hiring decisions in 2026.

And the platforms that are visible? LinkedIn charges employers $10,000 per year just to search profiles that you filled in for free. Recruiting agencies take $15,000–$30,000 per hire. Standard job boards run on keyword-stuffing and ATS black holes where great candidates get filtered out because a PDF parser choked on their resume formatting.

We looked at this and asked: What if your CV could work for you 24/7 — discoverable by AI agents, machine-readable, self-negotiating — while you keep total control of the data?

That’s why we built the Scoutica Protocol.

So What Exactly IS the Scoutica Protocol?

Let me make it crystal clear right away: Scoutica is not a job board. It’s not a platform. It’s not even an app.

Scoutica is an open-source protocol that turns your messy CV into a structured, machine-readable Skill Card — and makes it instantly discoverable by any AI agent on the planet. Think of it like HTTP, but for careers. Or like RSS, but for your skills. You publish your card once, and AI agents from any company can find you, score your fit, verify your evidence, and even negotiate salary — all without you lifting a finger.

The architecture has one non-negotiable rule at its foundation:

Part	What’s In It	Who Controls It
The Protocol	Open schemas, agent rules, CLI tools, registry API	🌍 Public — anyone can fork, clone, and build on it
Your Skill Card	Your profile, salary floor, rules of engagement, evidence	🔒 Private — lives in your own storage, never on our servers

The protocol is the network. Your Skill Card is your node on it.

Think email: SMTP is public and standardized, but your inbox is private. Scoutica works exactly the same way — the rules for how agents discover and evaluate talent are open-source, but your data stays entirely under your control.

Anatomy of a Skill Card

Here’s the core idea: instead of sending a PDF that gets parsed (badly) by an ATS, you publish a Skill Card — a small set of 4 structured files that make your professional identity instantly readable, searchable, and actionable by any AI agent:

File	Format	What It Does
`profile.json`	JSON	Your skills, tools, certifications, seniority, years of experience, spoken languages
`rules.yaml`	YAML	Your salary floors, remote policy, allowed engagement types, blocked industries, auto-reject rules
`evidence.json`	JSON	Links to your public work — GitHub repos, portfolio sites, certifications, published articles
`SKILL.md`	Markdown	The entry point for AI agents — tells them how to navigate and evaluate your card

What `profile.json` looks like in practice

This is a real example from the protocol’s sample card. Notice how structured and clean it is — no free-text resume fluff, no PDFs to parse:

{
  "schema_version": "0.1.0",
  "name": "Alex Chen",
  "title": "Senior Full-Stack Engineer",
  "seniority": "senior",
  "years_experience": 10,
  "availability": "immediately",
  "primary_domains": [
    "Backend Engineering",
    "Cloud Infrastructure",
    "API Design"
  ],
  "skills": [
    "Python", "TypeScript", "Go",
    "REST API Design", "Microservices Architecture",
    "Database Design", "CI/CD Pipelines",
    "Technical Leadership"
  ],
  "tools_and_platforms": [
    "FastAPI", "React", "Node.js",
    "Kubernetes", "Docker", "AWS",
    "PostgreSQL", "Redis",
    "GitHub Actions", "Terraform"
  ],
  "certifications_and_licenses": [
    "AWS Solutions Architect Associate"
  ],
  "spoken_languages": [
    {"language": "English", "level": "native"},
    {"language": "Mandarin", "level": "fluent"},
    {"language": "Spanish", "level": "basic"}
  ],
  "summary": "Full-stack engineer with 10 years building cloud-native applications. Specializes in event-driven microservices, API design, and infrastructure automation."
}

Every field is machine-readable. Every field follows a validated JSON Schema. An AI agent doesn’t need to guess, interpret, or wrestle with a garbled PDF — it reads clean, structured data and can instantly match your profile against any job requirement. This is how you go from “invisible resume” to “discoverable Skill Card.”

Where YOU set the rules: `rules.yaml`

This is the file that changes everything. The candidate — not the platform, not the recruiter — defines the terms:

engagement:
  allowed_types:
    - permanent
    - contract
    - advisory
  compensation:
    minimum_base_eur:
      permanent: 80000
      contract: 600    # daily rate
      advisory: 150    # hourly rate

remote:
  policy: "remote_only"

filters:
  blocked_industries:
    - "gambling"
    - "weapons"
    - "tobacco"
  stack_keywords:
    preferred:
      - "Python"
      - "TypeScript"
      - "Kubernetes"
  soft_reject:
    weak_stack_overlap_below: 3

privacy:
  zone_1_public:
    - title
    - seniority
    - primary_domains
    - availability
  zone_2_paid:
    - full_profile
    - evidence
    - experience_details
  zone_3_private:
    - email
    - phone
    - exact_salary

If a job offer violates any of these rules — salary too low, wrong industry, requires office attendance, tech stack has less than 3 matching keywords — the AI agent auto-rejects it before it ever reaches the candidate. No spam. Zero wasted time.

Proving your skills: `evidence.json`

Talk is cheap. Evidence isn’t. This file links to the actual public artifacts that prove your claimed skills:

{
  "items": [
    {
      "type": "github_repo",
      "title": "CloudDeploy — Kubernetes Deployment Toolkit",
      "url": "https://github.com/alexchen/cloud-deploy",
      "skills_demonstrated": ["Kubernetes", "Go", "CI/CD Pipelines"]
    },
    {
      "type": "article",
      "title": "Designing Event-Driven Microservices at Scale",
      "url": "https://blog.alexchen.dev/event-driven-microservices",
      "skills_demonstrated": ["Event-Driven Architecture", "Technical Leadership"]
    },
    {
      "type": "certificate",
      "title": "AWS Solutions Architect Associate",
      "url": "https://www.credly.com/badges/example-badge-id",
      "skills_demonstrated": ["AWS", "Cloud Infrastructure"]
    }
  ]
}

AI agents can automatically verify every item: check if the GitHub repo exists and matches claimed languages, confirm certificate URLs are live, verify portfolio sites load correctly.

The Three-Zone Privacy Model

Not all your data should be equally accessible. Scoutica enforces a strict, progressive privacy model that every conforming agent must respect:

Zone	What’s Visible	Who Can Access It
Zone 1 — Public	Title, seniority, top domains, availability	Anyone — free, no credentials needed
Zone 2 — Verified	Full profile, all evidence, detailed experience	Authenticated agents only
Zone 3 — Private	Email, phone, exact salary	Your explicit approval only

Here’s what makes this powerful:

An employer’s AI agent can freely scan Zone 1 to check for a rough fit — “Is this person senior? Are they available? Do they work in backend engineering?” That costs nothing and requires no authentication.
To see the deep profile, the agent needs to authenticate. In the future roadmap, this triggers a ~$0.05 micropayment that goes directly to you, the candidate.
To get your contact info? That requires your explicit, per-request consent. No more random recruiters cold-calling you because they scraped your LinkedIn.

And here’s the kill switch: delete your GitHub repository and you vanish from the network instantly. No residual data. No “data retention policies.” No begging a platform to delete your account. You pull the plug, you’re gone.

How Agents Find and Hire You — Step by Step

This is the part that makes Scoutica fundamentally different from every job board and recruiting tool out there. Your Skill Card isn’t passive — it’s a living, queryable profile that AI agents actively search for, evaluate, and act on. Let’s walk through the complete flow.

Step 1: Discovery

The agent queries the Scoutica registry for candidates matching specific criteria:

Search(skills=["Kubernetes","Terraform"], seniority="senior", remote="remote_only")
→ Returns: [card_url_1, card_url_2, card_url_3]

Step 2: Rules Pre-Screening (Before Scoring!)

The agent’s first move isn’t scoring skills — it’s checking rules.yaml. There’s no point computing a fit score for an offer that will be auto-rejected.

def pre_screen(rules, offer):
    # Check blocked industries
    if offer['industry'] in rules['filters']['blocked_industries']:
        return "REJECTED — industry blocked"

    # Check salary floor
    minimum = rules['engagement']['compensation']['minimum_base_eur']['permanent']
    if offer['salary'] < minimum:
        return "REJECTED — salary below minimum"

    # Check remote policy
    if rules['remote']['policy'] == 'remote_only' and offer['location_required']:
        return "REJECTED — candidate requires fully remote"

    return "PASS"

If the pre-screen returns REJECTED, the agent stops immediately. It does not contact the candidate. It does not log a “missed opportunity.” It simply moves on. The candidate never even knows there was a mismatched role — because why would they want to?

Step 3: Skills Scoring

For candidates who pass the rules check, the agent scores their profile against the job requirements:

def score_candidate(profile, job_requirements):
    candidate_skills = set()
    for field in ['skills', 'tools_and_platforms', 'specializations']:
        for item in profile.get(field, []):
            candidate_skills.add(item.lower())

    required = set(s.lower() for s in job_requirements['required_skills'])
    matched = required & candidate_skills

    score = (len(matched) / len(required)) * 100
    return min(score, 100)

The scoring thresholds are defined by the protocol:

Score	Verdict	Action
80–100	`STRONG_MATCH`	Proceed to interview
60–79	`GOOD_MATCH`	Review and decide
40–59	`WEAK_MATCH`	Only if other factors compensate
0–39	`NO_MATCH`	Do not proceed

Step 4: Evidence Verification

Before scheduling an interview, the agent verifies the candidate’s claimed evidence:

GitHub repos: Fetches stars, commit counts, and programming languages via the GitHub API — do they match the claimed skills?
Certificates: Sends a HEAD request to check the URL is live
Portfolio sites: Verifies HTTP status

If 4 out of 5 evidence items verify successfully, the agent proceeds with a trust score of 80%.

Step 5: Autonomous Negotiation

If everything passes, the company’s agent sends a structured offer to the candidate’s personal AI agent. The candidate’s agent evaluates it against rules.yaml and responds:

Company Agent → Candidate Agent:
  {role: "Lead DevOps", salary: 95K, remote: "hybrid"}

Candidate Agent checks rules.yaml:
  ✅ Salary 95K > minimum 80K
  ✅ Remote hybrid allowed
  ✅ Industry not blocked
  
Candidate Agent → Company Agent:
  {status: "INTERESTED", counter: {salary: 105K}}

Company Agent → Candidate Agent:
  {status: "ACCEPT", next: "interview_link"}

Candidate Agent → Human:
  📧 "Interview scheduled: Lead DevOps, 105K"

The candidate doesn’t lift a finger until there’s a real, verified, rules-compliant match with a scheduled interview.

Real-World Scenarios — Both Sides of the Table

Use Case 1: Maria — From Invisible PDF to Discoverable Skill Card

Maria is a senior backend engineer. She has an excellent CV, but it lives as a .docx file on her laptop. No AI agent can find her. She runs three commands:

scoutica scan ~/maria-cv/ --with gemini
scoutica validate
scoutica publish

In under two minutes, her messy CV has been transformed into a structured Skill Card, validated against the protocol schemas, and published to github.com/maria/skills. Her documents never left her machine.

Now the magic happens: Maria’s card is discoverable. Any company’s AI agent searching for “senior backend engineer + Python + Kubernetes + remote” will find her card, score her skills, and — if the offer passes her rules — reach out with a structured proposal. Maria went from invisible to searchable in three commands.

Her rules.yaml sets a minimum €85K salary, remote-only, and blocks gambling/weapons industries. When a role pays €65K? Auto-rejected before it reaches her. Role requires office attendance? Auto-rejected. The first time Maria hears about an opportunity, it’s already been verified, scored, and approved against every single one of her filters.

Use Case 2: TechCorp — Find the Right Engineer in Seconds, Not Months

TechCorp needs a Senior DevOps Engineer. Instead of paying $10K/year for LinkedIn Recruiter, drowning in 500 irrelevant applications, and spending weeks screening, their AI agent searches the Scoutica registry with a single structured query:

Search(skills=["Kubernetes","Terraform","Python"], seniority="senior", remote="remote_only")

In seconds, the agent returns a ranked shortlist. It has already fetched every matching Skill Card, scored each one against the job requirements, run rules pre-screening, and verified evidence links — all automatically.

Results:

Candidate	Score	Outcome
Maria	85	Contacted — strong match, evidence verified
Alex	72	Contacted — good match, noted remote preference
Sam	91	Auto-rejected — salary below Sam’s minimum

Sam was never bothered. No wasted time for either party. TechCorp contacted two verified, pre-screened candidates in under a minute — for essentially zero cost.

Use Case 3: DevJobs.io — Job Board Auto-Import

A developer applies to a job posting by pasting their Scoutica card URL instead of uploading a PDF. The job board fetches profile.json, auto-fills every form field, reads rules.yaml, and pre-screens the offer against the candidate’s rules. If the role pays €75K but the candidate’s minimum is €85K, the platform warns them before they waste time applying.

Use Case 4: Full Agent-to-Agent Negotiation

Maria’s personal AI agent receives an inbound opportunity. It checks rules.yaml, auto-negotiates salary (counter-offering €110K against an initial €95K), TechCorp’s agent counters at €105K with equity, Maria’s agent accepts — the total package is within range. Maria receives a notification: “Interview scheduled.” Three negotiation rounds completed in seconds.

Use Case 5: Team Cards

SquadAlpha — a team of 4 engineers — publishes a composite team card. Companies can now hire the entire team as a unit, with combined skills, team engagement rules, and collective evidence. The card even supports ai_agent as an entity type, so a team’s coding assistant can be listed as a team member.

Five Trust Levels

Not all Skill Cards are equally trustworthy. The protocol defines a progressive trust model:

Level	Name	Trust Factor	How It Works
0	Self-Asserted	0.0×	Candidate claims it — no external verification
1	URL-Verified	0.5×	Evidence URLs confirmed reachable
2	Peer-Endorsed	1.0×	Other card holders vouch for specific skills
3	Platform-Verified	1.5×	CI/CD: commits and contributions verified automatically
4	Blockchain-Verified	2.0×	Soulbound Token endorsement on-chain

Levels 0–3 work today. Level 4 (blockchain) is on the roadmap.

Getting Started — 4 Ways to Create Your Card

Option 1: AI Scan (Recommended — Zero Effort)

Drop your CV, certs, and portfolio files in a folder. The CLI reads your documents and pipes them to your local AI — nothing leaves your machine.

# Install the CLI
curl -fsSL https://raw.githubusercontent.com/traylinx/scoutica-protocol/main/install.sh | bash
source ~/.zshrc

# Auto-generate your card from documents
scoutica scan ~/my-docs/

# Or pick a specific provider
scoutica scan ~/my-docs/ --with gemini    # Gemini CLI
scoutica scan ~/my-docs/ --with claude    # Claude Code
scoutica scan ~/my-docs/ --with ollama    # Fully offline

# Validate and publish
scoutica validate && scoutica publish

Supported document formats: .md .txt .pdf .docx .json .yaml .csv .html

Supported AI providers (auto-detected):

Provider	CLI	Repo
Gemini CLI	`gemini`	google-gemini/gemini-cli
Claude Code	`claude`	anthropics/claude-code
OpenAI Codex	`codex`	openai/codex
Ollama	`ollama`	ollama.com
OpenClaw	`openclaw`	openclaw/openclaw

Option 2: Interactive Wizard

Answer questions step by step to build your card manually:

scoutica init ./my-card/

Option 3: AI Paste (No Install Needed — Easiest for Non-Developers)

Open GENERATE_MY_CARD.md on GitHub
Copy the entire file
Paste it into any AI assistant — ChatGPT, Claude, Gemini, Copilot
Follow the conversation — the AI interviews you and generates your 4 files
Save the files to a GitHub repo — your card is live

No git, no CLI, no install. This is the recommended path for non-technical users.

Option 4: GitHub Template (One Click)

Click “Use this template” on the Scoutica Protocol repo, name your repo, edit the template files, push. Done.

What your published card folder looks like

my-card/
├── profile.json        # Your skills, experience, tools
├── rules.yaml          # Your rules of engagement
├── evidence.json       # Links to your public work
├── SKILL.md            # Agent entry point
├── scoutica.json       # Discovery file (auto-generated)
└── rules/              # Evaluation rule templates
    ├── evaluate-fit.md
    ├── negotiate-terms.md
    ├── verify-evidence.md
    └── request-interview.md

CLI Quick Reference

scoutica init              # Interactive card creation wizard
scoutica init --ai         # AI-assisted card creation
scoutica scan ~/docs/      # Auto-generate card from documents
scoutica validate          # Validate card against protocol schemas
scoutica publish           # Push card to GitHub
scoutica resolve <url>     # Fetch and display a card from a URL
scoutica info              # Show card summary
scoutica doctor            # Check prerequisites (Git, Python, AI providers)
scoutica update            # Update CLI to latest version

Anti-Bias by Design — EU AI Act Compliant

This isn’t an afterthought. It’s baked into the schema itself.

The profile schema deliberately excludes any field that could enable discrimination: no gender, no age, no ethnicity, no nationality, no photo, no marital status, no religion. If the data isn’t in the schema, the AI literally cannot discriminate on it.

The protocol enforces four EU AI Act principles for high-risk recruitment systems:

Human-in-the-loop — no fully automated hiring decisions
Audit trail — all evaluations are logged with reasoning
Explainability — score breakdowns show exactly which skills matched and which were missing
Non-discrimination — zero demographic inference possible

Not Just for Humans

Here’s something most people don’t expect: the protocol supports Skill Cards for more than just individual professionals. The entity_type field in the discovery file allows any entity to participate:

Entity Type	Example
`human`	Software engineer
`ai_agent`	Coding assistant
`service`	Translation API
`robot`	Warehouse drone
`team`	Engineering squad
`organization`	DevOps department

This means a company could search the registry not just for individual engineers, but for entire pre-formed teams, AI agents with proven capabilities, or even API services that match specific technical requirements.

The Cost Comparison

Channel	Cost Per Hire
LinkedIn Recruiter	~$10,000/year
Recruiting Agency	$15,000–$30,000
Scoutica Protocol	~$4

That ~$4 comes from the roadmap micropayment model: employers pay ~$0.05 to unlock each candidate’s Zone 2 data. That payment goes directly to the candidate — not to a platform, not to a middleman. The protocol takes a 10% commission.

What's Live Today vs. What's on the Roadmap

Feature	Status
CLI install (macOS / Linux / Windows)	✅ Live
AI-powered card generation from documents	✅ Live
JSON Schema validation	✅ Live
GitHub publishing	✅ Live
Agent-side matching and scoring	✅ Live
Three-zone privacy model	✅ Live
EU AI Act compliance (no demographic fields)	✅ Live
Discovery file (`scoutica.json`)	✅ Live
Evidence URL verification	✅ Live
Multiple entity types (humans, agents, teams)	✅ Live
`scoutica resolve` — fetch any card by URL	✅ Live
GitHub-based central registry	🔜 Phase 2
GitHub Action for CI/CD validation	🔜 Phase 2
JavaScript and Python SDKs	🔜 Phase 3
Embeddable card widget and badge	🔜 Phase 3
Peer endorsements	🔜 Phase 4
GPG-signed cards	🔜 Phase 4
Soulbound Tokens on Base L2	🔜 Phase 5
Zero-Knowledge Proofs	🔜 Phase 5
Decentralized federated registry	🔜 Phase 5
`$SKILL` token micropayments	🔜 Phase 5

For Developers: Build on the Protocol

Scoutica isn’t just for candidates and recruiters. If you’re building an ATS, a job board, a recruiting agent, or any HR-adjacent tool, you can consume Skill Cards programmatically.

Coming soon — JavaScript SDK

import { ScouticaCard, ScouticaSearch } from 'scoutica-protocol';

const card = await ScouticaCard.fromGitHub('user/my-card');
console.log(card.profile.name);       // "Alex Chen"
console.log(card.skills.languages);   // ["Python", "Go"]

const fit = card.evaluate({
  required_skills: ['Python', 'Kubernetes'],
  salary_budget: 100000,
  remote: true
});
console.log(fit.score);    // 85
console.log(fit.verdict);  // "STRONG_MATCH"

Coming soon — Python SDK

from scoutica import Card, Registry

card = Card.from_github("user/my-card")
fit = card.evaluate(required_skills=["Python", "Kubernetes"])
print(fit.score, fit.verdict)  # 85, "STRONG_MATCH"

GitHub Action — Auto-Validate on Push

name: Validate Scoutica Card
on: push
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: traylinx/scoutica-action@v1
        with:
          validate: true
          register: true  # auto-register in global index

The Future: Blockchain, ZKPs, and the $SKILL Token

The V1 you can use today is just the foundation. The long-term vision includes cryptographic trust and a native economy:

Soulbound Tokens (SBTs): Non-transferable on-chain tokens on Base L2 that prove endorsements. An employer can query a smart contract to verify “Does this person have a verified Kubernetes endorsement from TechCorp?” — no intermediary needed.
Zero-Knowledge Proofs: Prove facts without revealing the data. “I earn above $100K” → ZKP proof → ✅ True (without revealing the exact salary). “I have AWS certification” → ✅ True (without revealing the cert ID).
$SKILL Token: The native currency powering micropayments (Zone 2 access fees flow to candidates), verifier staking (fraudulent endorsements get slashed), and registry subscriptions.

Everything Is Open Source

The entire stack — protocol, schemas, CLI, documentation, agent skills — is Apache 2.0 licensed. Fork it, build on it, contribute.

🌐 Landing page: scoutica.com
📚 Full documentation: docs.scoutica.com
💻 GitHub repo: github.com/traylinx/scoutica-protocol

Your CV shouldn’t be a file gathering dust on your laptop. Turn it into a Skill Card, publish it once, and let AI agents find you, score you, and bring you the right opportunities — on your terms.

Scoutica Protocol: Turn Your CV Into a Skill Card That AI Agents Can Discover, Score, and Hire

Your CV Is Invisible — That's the Real Problem

So What Exactly IS the Scoutica Protocol?

Anatomy of a Skill Card

What `profile.json` looks like in practice

Where YOU set the rules: `rules.yaml`

Proving your skills: `evidence.json`

The Three-Zone Privacy Model

How Agents Find and Hire You — Step by Step

Step 1: Discovery

Step 2: Rules Pre-Screening (Before Scoring!)

Step 3: Skills Scoring

Step 4: Evidence Verification

Step 5: Autonomous Negotiation

Real-World Scenarios — Both Sides of the Table

Use Case 1: Maria — From Invisible PDF to Discoverable Skill Card

Use Case 2: TechCorp — Find the Right Engineer in Seconds, Not Months

Use Case 3: DevJobs.io — Job Board Auto-Import

Use Case 4: Full Agent-to-Agent Negotiation

Use Case 5: Team Cards

Five Trust Levels

Getting Started — 4 Ways to Create Your Card

Option 1: AI Scan (Recommended — Zero Effort)

Option 2: Interactive Wizard

Option 3: AI Paste (No Install Needed — Easiest for Non-Developers)

Option 4: GitHub Template (One Click)

What your published card folder looks like

CLI Quick Reference

Anti-Bias by Design — EU AI Act Compliant

Not Just for Humans

The Cost Comparison

What's Live Today vs. What's on the Roadmap

For Developers: Build on the Protocol

Coming soon — JavaScript SDK

Coming soon — Python SDK

GitHub Action — Auto-Validate on Push

The Future: Blockchain, ZKPs, and the $SKILL Token

Everything Is Open Source

Bridging Architecture & Execution

Written by Sebastian Schkudlara Follow View Profile →

Scoutica Protocol: Turn Your CV Into a Skill Card That AI Agents Can Discover, Score, and Hire

Your CV Is Invisible — That's the Real Problem

So What Exactly IS the Scoutica Protocol?

Anatomy of a Skill Card

What profile.json looks like in practice

Where YOU set the rules: rules.yaml

Proving your skills: evidence.json

The Three-Zone Privacy Model

How Agents Find and Hire You — Step by Step

Step 1: Discovery

Step 2: Rules Pre-Screening (Before Scoring!)

Step 3: Skills Scoring

Step 4: Evidence Verification

Step 5: Autonomous Negotiation

Real-World Scenarios — Both Sides of the Table

Use Case 1: Maria — From Invisible PDF to Discoverable Skill Card

Use Case 2: TechCorp — Find the Right Engineer in Seconds, Not Months

Use Case 3: DevJobs.io — Job Board Auto-Import

Use Case 4: Full Agent-to-Agent Negotiation

Use Case 5: Team Cards

Five Trust Levels

Getting Started — 4 Ways to Create Your Card

Option 1: AI Scan (Recommended — Zero Effort)

Option 2: Interactive Wizard

Option 3: AI Paste (No Install Needed — Easiest for Non-Developers)

Option 4: GitHub Template (One Click)

What your published card folder looks like

CLI Quick Reference

Anti-Bias by Design — EU AI Act Compliant

Not Just for Humans

The Cost Comparison

What's Live Today vs. What's on the Roadmap

For Developers: Build on the Protocol

Coming soon — JavaScript SDK

Coming soon — Python SDK

GitHub Action — Auto-Validate on Push

The Future: Blockchain, ZKPs, and the $SKILL Token

Everything Is Open Source

Bridging Architecture & Execution

Written by Sebastian Schkudlara Follow View Profile →

Data Protocol / Consent

Data Protocol / Consent

What `profile.json` looks like in practice

Where YOU set the rules: `rules.yaml`

Proving your skills: `evidence.json`