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