ailin¹
Ailin¹

Collective Intelligence: The Next Frontier of AI

101,986 models with different capabilities, together as one true Collective Intelligence.

37/38 on verifiable tasks Verified consensus scored 37 of 38 objectively verifiable tasks, against 68 to 82% for isolated frontier models, in a public, auditable benchmark.

From Individual AI to Collective Intelligence

Every moment, choosing gets harder, paralyzing teams and companies with the fear of choosing wrong. And the choice never ends. Labs ship new frontier models simultaneously, without pause. Every release restarts the evaluation, the testing, the pricing. We call this Model Fatigue: the exhaustion of betting on a model that keeps expiring. Meanwhile, the market floods the world with output that is ever more perfect and ever more generic. The cost of filtering is passed on to you, to your business, in a world that learned to see everything with distrust. We call it AI Slop. We aren't running that race. We changed the game. That is why we believe, and have proven, that the next frontier of AI is collective.

Not a slogan. Science: structured diversity beats lone expertise. Condorcet proved it. Hong and Page measured it. We turned it into a product: models that reason independently, check one another, and converge on a single auditable answer, through different collective strategies grounded in decades of research.

The goal isn't more models. It's different intelligences working better together.

That is Collective Intelligence. The model is just a component. The collective is the intelligence. Ailin¹ is the collective.

Ailin¹ Collective: The Mechanism Behind the Proof

Ailin¹ was born to be Collective Intelligence. Routing, discovery, orchestration, and verification are mechanisms that serve it. Drawing on 101,986 discoverable model identifiers, each request is routed through one of 31 registered orchestration strategies: a single model when speed is what matters, several coordinated to reason, debate, and cross-check one another when correctness is. We call the Collective Foundation Model the evolution of the foundation model through our collective intelligence thesis: the foundation stops being one model trained for everything and becomes the coordinated pool under a decision layer. It is a proprietary architecture with its own foundation model stack, and the ailin family joins that pool as it matures.

Every collective response exposes the decision: which models ran, what coordinated them, what it cost. You don't have to trust it: you verify it.

Foundation Model One model, trained for everything
Collective Foundation Model Decision layer Coordinated pool, 101,986 identifiers The ailin stack joins the pool as it matures
  • Which models ran
  • Which strategy coordinated them
  • What the collective cost
Build with Collective Intelligence

Measured against the world's biggest models. In public.

We ran the collective against GPT-5.5-pro, Claude Opus 4.8, Gemini 3.1 Pro, and Grok 4.3, graded by objective machine-checked answers, not a judge's taste. Result: the collective outperformed all four, in an auditable, reproducible experiment. Check the repository.

⭐ Join 214 stargazers on GitHub

Ailin¹ Collective

Every request runs through the same routing cascade before a single model is called, one that can call on collective strategies grounded in peer-reviewed results on group decision-making, Condorcet's Jury Theorem and Hong and Page's Diversity Prediction Theorem among them. Name exactly what you want, and it's honored immediately. Say nothing, and the cascade decides.

State-of-the-Art Isn't a Black Box. It's Two Levers You Control.

Five chat aliases span the full range, from an instant single model to five-model consensus. Two independent fields set the boundaries: max_cost is a ceiling, quality_target is a floor. Set one, the other, or both. The ceiling is enforced before any model is called; the floor steers every routing decision toward it.

Most platforms hand you a model list and call it a choice. Ailin¹ hands you two independent levers, not one slider: how good the answer needs to be, and what you're willing to spend to get it.

  • Cap spend and let quality find its own level.

  • Steer toward a quality floor and let cost follow demand.

  • Pin an exact corridor between them.

Ailin¹ Collective routing aliases, what each optimizes for, typical cost, and when to use it
Alias Optimizes for Typical cost Use when
ailin-auto Balanced fit, decided per request Normal Default. No constraint beyond balanced cost and quality.
ailin-best Quality, cost unbounded Highest Correctness-critical work where cost is not the binding constraint.
ailin-fast Latency, single model Low Interactive paths with a strict latency budget.
ailin-economy Cost, hard ceiling enforced Lowest High-volume background work
ailin-consensus Correctness via independent cross-checking Higher, on purpose Silent incorrectness is the failure mode you are paying to eliminate.

Every response returns decision provenance in ailin_metadata: strategy_used, models_used and cost_usd, so the routing decision can be verified rather than trusted.

Request: your existing OpenAI client, one line changed

from openai import OpenAI

client = OpenAI(
    base_url="https://api.ailin.one/v1",
    api_key="YOUR_KEY",
)

response = client.chat.completions.create(
    model="ailin-consensus",
    messages=[{"role": "user", "content": "..."}],
    extra_body={"max_cost": 0.15}
)

Response

{
  "ailin_metadata": {
    "strategy_used": "ailin-consensus",
    "models_used": [
      "gpt-5.5-pro",
      "claude-opus-4.8",
      "gemini-3.1-pro"
    ],
    "final_decider_model_id": "claude-opus-4.8",
    "final_decider_role": "synthesizer",
    "cost_usd": 0.0842,
    "subcalls": [
      { "model_id": "gpt-5.5-pro", "role": "voter", "cost_usd": 0.0301, "latency_ms": 1840, "success": true },
      { "model_id": "claude-opus-4.8", "role": "synthesizer", "cost_usd": 0.0288, "latency_ms": 2010, "success": true },
      { "model_id": "gemini-3.1-pro", "role": "voter", "cost_usd": 0.0253, "latency_ms": 1650, "success": true }
    ]
  }
}

How Ailin¹ Collective Decides: The AI Decision Layer

A layered cascade, evaluated fastest-first. Each request resolves as early as it safely can, so simple requests settle fast while harder ones draw on the deeper layers.

Before the cascade: semantic cache A near-duplicate of a recent request returns the cached response immediately. Triage and all six layers below are skipped entirely, not just shortcut, skipped.

  1. Explicit routing

    You named it, an alias, a model, or a strategy, so this layer resolves the request instantly. It always wins over every layer below it, and if what you named can't actually be met, the request fails outright instead of silently falling through to something else.

  2. Triage

    A dedicated model reads the task's intent and complexity and recommends a strategy before any collective model runs. Real analysis, not a lookup table, so it costs a real (small) call of its own.

  3. Configuration archive

    Unlocks after 5 recorded outcomes

    Once at least 5 outcomes are recorded for a task niche, Ailin¹ Collective reuses what's already proven instead of re-deriving it.

    Not a single black-box pick: a bank of elite configurations tracked across 6 optimization axes, quality, cost-efficiency, speed, balance, reliability, quality-per-token, for that niche, so the strategy and model set reused is the one that actually won on the dimension your request cares about.

  4. Cost / quality / latency frontier

    Unlocks after 3 recorded outcomes

    Optimizes the multi-objective trade-off (quality, cost, speed, success rate) directly once enough history exists, even without a proven exact-niche match yet.

  5. Learned strategy preference

    Unlocks after 5 recorded outcomes

    A Thompson Sampling bandit weights strategies by their real, measured outcomes over time, refining the cascade's own defaults, and it audits itself: if its overall measured reward rate drops below 95% of the best snapshot it has ever recorded, the bandit automatically rolls its entire learned state back to that best-known snapshot.

  6. Fallback heuristic

    If no layer above resolves the request, a deterministic scored heuristic selects the strategy from task type, complexity and the available model pool. Strategy resolution always terminates with a decision, recorded in strategy_used.

After the cascade: cost governance gate Whatever layers 1 to 6 picked, unless you routed explicitly, one last check can still downgrade an expensive collective pick back to a single model when the estimated payoff doesn't clear the bar. Only an explicit request skips this check too.

Layers 3 to 5 unlock independently as usage history accumulates for a task niche, from 3 recorded outcomes for the cost/quality/latency frontier up to 5 for the configuration archive and the learned-preference bandit; until then, layer 6's deterministic, auditable heuristic makes the call whenever layers 1 and 2 don't resolve it first.

31 Strategies. Every One Grounded in Research.

Dozens of ways for models to think together, every one auditable. Different problems demand different forms of collective reasoning.

None of these are ad hoc. Every strategy in the catalog maps to a specific, named result in coordination or collective-decision research, not an internal guess dressed up as science.

  • consensus

    Condorcet's Jury Theorem (1785): majority vote across 3 to 5 models, with a diversity floor so agreement can't come from cloned reasoning.

  • diversity-ensemble

    Hong and Page's Diversity Prediction Theorem (PNAS, 2004): assembles a team that maximizes cross-axis diversity by construction.

  • debate

    Models argue across structured rounds with a moderator.

  • swarm-explore

    Parallel exploration, auto-selected by triage for open-ended design and architecture work.

  • stigmergic-refinement

    Convergence through a shared artifact rather than a vote, auto-selected by triage for high-complexity writing.

  • expert-panel

    Independent multi-role review before an answer ships, addressable directly for verification-heavy requests.

  • tri-role-collective

    Planner, Solver, Auditor: a deterministic state machine, not a trained coordinator, that structurally blocks the Auditor from being the same model or reasoning pass that just produced the answer as Solver.

  • +24 more strategies

You Don't Pick the Model. Ailin¹ Collective Does.

Simplicity when the task is simple. Depth when it isn't. You set the boundaries, Ailin¹ Collective decides within them, and one field always overrides it. Creative goes single by default. Verifiable goes collective.

You never have to decide whether a request needs one model or five. Every request runs through Ailin¹ Collective, the same routing cascade behind ailin-auto, before a single model is called. Know exactly what you want? Name it: an alias like ailin-fast, a specific model, or strategy: "single", and Ailin¹ Collective honors it immediately, no negotiation, no added latency. Say nothing, and the cascade reads the task itself and picks a shape that fits it. Running a single model through Ailin¹ isn't a fallback or a downgrade. It's a first-class path Ailin¹ Collective reaches for constantly, on purpose.

Single model

One consistent voice, start to finish. Lower cost, lower latency, and exactly as reachable as the alternative.

ailin-fast

Multi-model collective

Independent proposers working in parallel, cross-checked and reconciled by a synthesizer before you see one answer, so disagreement gets caught before it reaches you, not after.

ailin-consensus

What about creative work and refactors?

On objectively verifiable tasks, machine-checked, not a taste judgment, the collective is the one that wins. On open-ended creative work, a single well-chosen model wins just as clearly. That's exactly why triage exists: the cascade doesn't average across task types, it discriminates between them. Creative work goes single by default. Verifiable work goes collective.

Verifiable tasks 97%

accuracy (37 of 38), against 68 to 82% for single frontier models. The verifier never let a wrong answer through across three full rounds.

You don't choose between simple and thorough by memorizing when to use which. You say what you know, Ailin¹ Collective fills in what you didn't, and the override is always exactly one field away.

Build with Collective Intelligence ⭐ Star Collective Intelligence on GitHub

Thousands of models. Only the right ones take the stage.

The Collective Is the Advantage

Access to more models isn't the breakthrough. The breakthrough is what happens when different intelligences work together. Ailin¹ turns a continuously discovered ecosystem of 101,986 model identifiers into a collective, then activates only the subset each strategy needs.

101,986 discoverable model identifiers. What runs is chosen for diversity, not counted for size.

  • Always current

    A newly published model is indexed on the same discovery cycle it appears in, with no release train to wait for.

  • Full-spectrum

    Text, vision, audio, and embeddings in the same catalog, behind the same endpoint.

Why Intelligence Becomes More Powerful When It Becomes Collective

AI was built around individual models. The next frontier is collective. An individual model can be extraordinary, and it still carries its own architecture, history, blind spots, and failure modes. Collective Intelligence makes independent models contribute different perspectives, challenge assumptions, specialize, compare alternatives, and verify results where the task allows. What follows isn't a wish list: it's five mechanisms running in production now.

Single-model cost, when it matters

Resilience

One provider's outage doesn't become yours. The collective routes around degraded models and failures on its own, and every response still carries decision provenance: which strategy ran, which models, and what it cost.

Diversity by construction

Provider, architecture, and training objective are forced apart by round-robin selection, so consecutive models in a run never share a provider. That's Hong and Page's Diversity Prediction Theorem built into the routing layer, not a hope that different training data happens to disagree usefully. It surfaces blind spots; it doesn't promise to erase them.

No single provider owns your product

The right specialist, in real time

Frequently asked questions

Straight answers, with the field, file, or number behind each one. If we claim it, you can check it.

Integration & basics

Yes. The core surface (chat/completions, responses, embeddings, models) is drop-in compatible, with an additive ailin_metadata block carrying decision provenance. Point your existing client at the Ailin¹ endpoint, swap the auth header, and the same request shape works.

Built for Collective Intelligence, and that's a specific engineering claim, not a tagline. Routing decides where a request goes; orchestration scripts a sequence you write yourself; Collective Intelligence is the layer that defines how multiple models reason, cross-check, and synthesize together, with routing, orchestration, and verification as mechanisms that serve it. The mechanisms trace back to named research: Hong and Page's Diversity Prediction Theorem (PNAS, 2004), Condorcet's Jury Theorem (1785), and Woolley et al.'s collective intelligence factor 'c' (Science, 2010). One strategy is even named after it in the source: diversity-ensemble ships as 'Diversity Ensemble (Page Theorem).' A request activates several models under one of these strategies, then returns one answer with decision provenance for how it got there.

The live catalog holds 101,986 discoverable model identifiers, continuously discovered and capability-tagged across dozens of providers, never a static list someone edits by hand. A single request never touches all of them: each collective strategy activates only the subset it requires, never the entire catalog.

Ailin¹ Collective & strategies

ailin-auto (balanced default, let the cascade decide), ailin-best (quality first, cost unbounded), ailin-fast (latency first, single model), ailin-economy (cost first, hard ceiling enforced), ailin-consensus (correctness via independent cross-checking). Start with ailin-auto. Reach for another only when you know something the router doesn't.

By default, Ailin¹ decides, through Ailin¹ Collective's routing cascade: explicit routing first if you named something, then triage if you didn't. You can override any layer by pinning a model, an alias, or a strategy directly, and that choice always wins. Most integrations never need to.

A layered cascade, evaluated fastest-first: explicit routing if you named it; triage, which classifies the task and maps it to a strategy; a configuration archive that reuses what's historically worked for that exact task niche; a cost/quality/latency frontier that optimizes the trade-off directly; and a learned strategy preference (a Thompson Sampling bandit) that weights strategies by real outcomes over time. The configuration archive and the learned-preference bandit need at least 5 recorded outcomes for a given niche before they activate, and the cost/quality/latency frontier unlocks from 3; until then, a deterministic, auditable fallback heuristic makes the call, the same heuristic that backstops every layer above it if none of them resolve the request.

31 strategies are registered in the coordination engine, from a single routed model up to nine-agent swarms exploring a problem in parallel. Fifteen are auto-selectable in the routing cascade; the other sixteen are explicit-only and run only when you name them. You can also address any of them directly as <strategy>:<tier>, for example consensus:large, locking in the exact mechanism and price tier.

On open-ended creative writing and code refactoring, our own (small-sample) strategy comparisons show a single strong model beating the full collective outright. On objectively verifiable tasks, that comparison flips: a verified consensus strategy scored 37 of 38 (97%), against 68 to 82% for the single frontier models tested alongside it. Ailin¹ doesn't force consensus onto those requests by default, and it never locks you into its own guess either way: one field gets you a single consistent voice (ailin-fast, strategy: "single"), and the same one field gets you independent multi-model verification (expert-panel, tri-role-collective) if that's what you actually want instead.

Cost & accountability

Yes, per request. max_cost hard-caps spend before any model is called; if the estimated cost of the strategy that would run exceeds it, the request fails with 400 strategy_budget_exceeded instead of silently overspending. quality_target is the paired floor. Every response reports the real number back: ailin_metadata.cost_usd, with a line-item breakdown. Multi-model strategies cost meaningfully more than a single model. For tasks a machine can check (structured extraction, math, code with tests, factual QA), that premium mostly disappears: when a verified strategy's deterministic short-circuit fires, our latest frontier benchmark measured collective cost at about $2.98/Mtok, roughly 100x cheaper than the unverified collective path and within the same order of magnitude as single-model pricing.

Every response carries ailin_metadata.final_decider_model_id, the exact model that produced your answer, plus final_decider_role (primary, synthesizer, fallback, or cache) and a full subcalls[] array listing every participant with its own cost, latency, and outcome. If you're escalating a quality issue to a provider, that identifier is what matters, not "the Ailin¹ API." If you need to reconstruct why a multi-model decision came out the way it did, enable the persisted coordination trace: GET /v1/collective/runs/:id/trace returns a millisecond-level timeline of every phase, and it's built so one tenant can never confirm another tenant's run even exists, a lookup on someone else's run ID returns the same 404 as a run that was never created.

Evidence & trust

On a benchmark of 10 objectively verifiable tasks (machine-checkable answers, not a taste judgment), run 38 times, a consensus strategy paired with a deterministic verifier answered correctly 37 of 38 times in our own evaluation, against 68 to 82% for the individual frontier models tested alongside it (GPT-5.5-pro, Claude Opus 4.8, Gemini 3.1 Pro, Grok 4.3). Across all three rounds, the verifier never once selected an objectively wrong answer. Without it, other collective strategies fall back inside the same range as the single flagships, so the advantage tracks the verifier, not the extra models. For completeness: the strongest single model also scored 100% on the second round alone (15 executions), so read the 97% across the full three-round protocol rather than as a per-round promise. The reported score can be recomputed from the published raw outputs and evaluation checker. Run it yourself instead of taking our word for it.

No, not your raw prompts. The training-data export pipeline never touches prompt content: it exports anonymized operational metadata only (strategy used, cost, latency, quality scores), with trace IDs hashed via SHA-256 plus a secret pepper and truncated to 16 characters, and your organization and user identifiers stripped before anything is staged. If that pepper isn't configured, the export job refuses to run rather than exporting unprotected data.

Every call runs through authentication, tenant isolation, quota enforcement, capability-filtered routing, and request tracing. That's live today, and so is the supply-chain and licensing side: AGPL section 13 compliance endpoints (/source, /license), SLSA/Sigstore release provenance, and an SPDX SBOM ship with every release. What isn't done yet: formal certification. SOC 2 and ISO 27001 are in progress, not certified, so if procurement needs a specific attestation, ask your account team instead of inferring one from marketing copy, ours included. You don't have to take our word for any of it either: the coordination engine behind the numbers on this page is public at github.com/ailinone/collective-intelligence (AGPL-3.0-or-later), benchmark scripts and raw data included.

The Collective Era of AI Has Already Begun

On verifiable tasks, our verified consensus scored 37 of 38, against 68 to 82% for isolated frontier models, and never once picked a wrong answer. That's not a promise: it's a published benchmark, with the engine, scripts, and raw data open for anyone to check. The model becomes a component. The collective becomes the intelligence.

Request access Build with Collective Intelligence ⭐ Star Collective Intelligence on GitHub