Introducing

The Poly Platform

A complete infrastructure ecosystem. Built for the next generation of intelligent, cross-platform applications.

0
Crate Families
0
Individual Crates
0
Target Languages
Built Different

Everything you need.
Nothing you don't.

From AI inference to cross-platform deployment, Poly provides the building blocks for ambitious software.

🧠

AI Inference

Multi-provider LLM runtime with conversation trees, streaming, and native tool calling.

6
Providers
4
Crates

Cross-Platform FFI

Write once in Rust. Deploy everywhere. Swift, Kotlin, Python, TypeScript, WASM.

8
Languages
14
Crates

Wire Format

Schema-driven binary serialization with cross-language codegen and projection decoding.

13
Wire Types
4
Languages
AI Infrastructure

Inference without
compromise.

Native provider integrations. Conversation branching. Durable storage. Everything streaming, everything typed.

let provider = AnthropicProvider::new(config);
let handle = provider.open(open_config).await?;

let session = provider.run_query(
    &handle,
    QueryParams {
        model: "claude-sonnet-4-20250514",
        tools: tool_allow_list!["read_file"],
        ...
    }
).await?;

while let Some(item) = session.next().await {
    match item {
        StreamItem::TextDelta(text) => ...,
        StreamItem::ToolCall(call) => ...,
    }
}

Chickpea
Inference Runtime

A provider-agnostic inference layer that treats conversations as first-class data structures. Branch anywhere. Resume anytime. Store everything.

Conversation Trees
Native Streaming
Tool Orchestration
Durable Storage
Extended Thinking
Prompt Caching

PolyThink
Multi-Model Analysis

Query six models simultaneously. Find consensus. Surface disagreements. Make decisions with confidence.

6+ Parallel Queries
Consensus Detection
MCP Server Mode
Code Generation
╭─────────────────────────────────────╮
PolyThink Query Results
├─────────────────────────────────────┤
Claude Yes, use async/await
GPT-4 Async is preferred
Gemini Async recommended
DeepSeek Use async patterns
├─────────────────────────────────────┤
Consensus: STRONG (4/4)
Recommendation: async/await
╰─────────────────────────────────────╯
Identity & Auth

Authentication that
scales with you.

75 API procedures. 41 events. 10 authentication factors. Event-sourced from day one.

🔐

Authentication Factors

10 methods
Email OTP
Phone OTP
Apple Sign-In
Google Sign-In
Passkey (WebAuthn)
TOTP
Secure Enclave
BIP39 Recovery
GPG Recovery
IDV Recovery

API Surface

75 procedures
Login (16)
Session (6)
Challenge (6)
Enrollment (9)
Account (9)
Recovery (11)
Membership (5)
Guardianship (6)
Resource (3)
Device (3)
Serialization

One schema.
Every language.

PolyWire: A binary wire format designed for schema evolution, projection decoding, and cross-language codegen.

Wire Types

13 types
Unsigned Integers (8-128 bit)
Signed Integers (8-128 bit)
Floats (f16–f256)
Decimals (d32–d128)
Timestamps (4 precisions)
UTF Strings (5 encodings)
Boolean
Record
Union
Ordered List
Ordered Set

Code Generation

4 targets
Rust Structs
Swift with Codable
Kotlin Data Classes
TypeScript Interfaces
Integrations

Works with everything
you already use.

Native integrations with leading AI providers, platforms, and storage engines.

A
Anthropic
OpenAI
G
Google AI
OpenRouter
D
DeepSeek
C
Cerebras
🦀
Rust
S
Swift
K
Kotlin
🐍
Python
TS
TypeScript
WebAssembly
iOS
🤖
Android
SQLite
🦆
DuckDB
Redb
Cursor