ailin¹
Ailin¹

Collective Intelligence: The Next Frontier of AI

101,986 models with different capabilities, brought together selectively when the task truly needs a collective.

The game has changed: the era of Collective Intelligence

Choosing a model has become an impossible game. Every week, a new frontier model ships. Every launch expires your bet. We call it Model Fatigue. Meanwhile, the world drowns in output that is polished outside and hollow inside. We call it AI Slop. We are not running that race. We changed the game, and we can prove it: the next frontier of AI is collective.

Not a slogan. Science: structured diversity beats lone expertise. Condorcet proved it in 1785. Hong and Page measured it in 2004. We turned it into a product: independent models that reason, debate, and check one another until they converge on one auditable answer.

The future doesn't belong to whoever has the most models. It belongs to whoever makes different intelligences work better together.

The model is the component. The collective is the intelligence. Ailin¹ is the collective.

Ailin¹ Collective: Many Models. One Intelligence.

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.

Every answer ships with its own receipt: which models ran, which strategy coordinated them, and what it cost, down to the cent. Don't take our word for it. Verify it.

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.

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

We Beat 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 on tasks with machine-checked answers, no judge's taste. The collective beat all four: 37 of 38 against 68 to 82%. Auditable, reproducible, and fully public: engine, scripts, raw data. Check the repository and run it yourself.

⭐ Join 225 stargazers on GitHub

Ailin¹ Collective: The Engine Behind Every Answer

Every request runs through one routing cascade before a single model is called. It decides, per request, when one model is enough and when a collective is worth it. Name exactly what you want, and it's honored immediately. Say nothing, and the cascade decides.

Two Levers. Total Control. A Receipt for Every Cent.

Five aliases span everything from an instant single model to five-model consensus. Two independent fields put you in command: max_cost is a hard ceiling, quality_target is a quality promise. Set one, the other, or both. The ceiling is enforced before a single model is called, and the floor pulls every routing decision toward it.

Most platforms hand you a model list and call it choice. Ailin¹ hands you the two questions that actually matter: how good must this answer be, and what is it worth to you? You draw the lines, the collective delivers inside them, and the exact cost lands on the receipt of every response.

  • 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.

Enforcement

max_cost is a hard ceiling, not a suggestion: exceeding it fails the request immediately with 400 strategy_budget_exceeded before any model is called, instead of quietly overspending.

Proof

Every response carries a receipt: strategy_used, every model that touched your request, and the exact cost_usd. Not a black box is something you can check, not just something we claim.

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 }
    ]
  }
}

The AI Decision Layer: Six Layers That Never Miss

Six layers race to resolve your request, fastest first. Simple requests settle in an instant. Hard ones unleash the deeper layers and the full power of the collective.

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 Ways to Win. Every One Grounded in Science.

Models that argue, vote, debate and cross-check each other until the weak answers die and the strongest survives. Different problems, different shapes of collective thinking, every single one auditable.

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 for open-ended design and architecture work, invoked explicitly whenever you name the strategy.

  • stigmergic-refinement

    Convergence through a shared artifact rather than a vote, for high-complexity writing, invoked explicitly whenever you name the strategy.

  • 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

Power users can pin a strategy and tier directly: <strategy>:<tier>, for example consensus:large or expert-panel:extra, locking in the exact mechanism and price tier instead of an alias default.

Running five models costs more than running one, sometimes by orders of magnitude, and max_cost is what keeps that bounded, enforced before a single model is called. On tasks a deterministic verifier can check, math, code with tests, structured extraction, factual QA, that verifier short-circuits the collective outright, so cost lands close to single-model territory while still holding the benchmark's 97% accuracy. Off that path, the premium is real and deliberate, and the ailin_metadata.cost_usd receipt itemizes every line of it.

You Don't Pick the Model. Ailin¹ Picks the Winner.

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 the benchmark's 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 Catalog Isn't the Advantage. The Collective Is.

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 a Collective Wins

AI was built around individual models. That era is ending. An individual model can be extraordinary and still carries its own architecture, blind spots, and failure modes. Collective Intelligence turns independent models into a team that contributes different perspectives, challenges assumptions, specializes, compares alternatives, and verifies results wherever the task allows. What follows isn't a wish list: it's five mechanisms running in production now.

Near single-model cost, when it matters

On easy tasks, triage routes the request to a single model outright, and the cost cascade escalates to a richer model only when a cheaper one falls short, so cost tracks the task's difficulty, not the collective's full size. And where the collective does run, a deterministic verifier checks the answers before they reach you, right where its accuracy advantage is strongest.

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

A collective spans multiple providers, so no single provider's roadmap, pricing, or policy defines your product alone.

The right specialist, in real time

The right specialist for the right task: reasoning, code, vision, long-context, or low-latency, elected in real time for every request.

Straight Answers. Hard Numbers. Nothing to Hide.

Every claim on this page comes with the field, the file, or the number behind it. If we say 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). The one miss? A truncated generation that emitted no final answer. 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 its deterministic verifier never selected an objectively wrong answer across the full protocol. 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.

Open Ailin¹ Chat Request access Build with Collective Intelligence ⭐ Star Collective Intelligence on GitHub