Polywrap - Co-Founder
WebAssembly development framework for building cross-language SDKs, referred to as 'wraps' - composable modules with GraphQL interfaces, usable in any application environment. The toolchain provided schema-driven code generation, reproducible Docker-based builds, and automated documentation generation. Polywrap had 20+ launch partners, and obtained venture funding totaling $8.5M. Polywrap was sunset due to LLMs making the need for cross-language SDKs obsolete.
Polywrap was a new way to build extensible software that ran anywhere. We built a developer toolchain and execution environment that made it easier to build, run, and compose integrations no matter where they lived — so product teams could break down language silos instead of maintaining parallel SDKs for every language.
After years of shipping protocol integrations through dOrg, we started where the pain was loudest: Web3 protocols often needed custom logic at the application layer (not just a thin HTTP API), which made them a strong early beachhead. The product matured into a general-software integration model — the same wrapper + client architecture applied to mainstream systems, not only Web3 protocols. The company began as Web3API at HackFS (2020), won recognition including a Filecoin award, raised early funding, and grew into a full protocol, CLI, and client ecosystem teams could ship on.
Introduction: Wraps, GraphQL, Clients, and Toolchain
These slides were from our core product deck—the fastest on-ramp we had for how wraps worked end to end: GraphQL interfaces on composable modules, WebAssembly sandboxing, composability and versioning, fetch-on-demand upgrades, flagship clients, and the Polywrap CLI.
My Role: Technical + Project Lead
As tech and project lead, I owned the architecture and execution model end-to-end: from early protocol design through production hardening, hiring/onboarding engineers, and establishing the baseline standards that kept a multi-runtime, multi-language system coherent.
Traction, Partners, and Funding
We scaled the organization to roughly ten full-time people, signed 20+ partners for integrations, and received ecosystem grants to accelerate wrapper development. We raised multiple venture rounds totaling $8.5M.
Engineering Highlights
We shipped the full vertical: wraps as composable WebAssembly modules behind GraphQL contracts, flagship embed clients (TypeScript/JavaScript, Python, and Rust), schema-driven codegen, and a Polywrap CLI workflow with reproducible Docker builds so authors could test and ship wraps without brittle per-machine toolchains. We also built client-readiness, a shared test harness that ran a conformance matrix across 5 client implementation languages to show how completely each one complied with the WRAP standard. The schema pipeline fully parsed Polywrap’s custom GraphQL Schema Definition Language and composed linked schemas through an import/linking pass, so external schema dependencies resolved into one graph you could build against. Handlebars templates generated per-language bindings from that resolved GraphQL schema, and MessagePack framed traffic at the runtime boundary. We also integrated the runtime into partner infrastructure—for example collaborating with Gelato so protocol nodes could execute user-defined payloads with stronger isolation guarantees.
- Polywrap GitHub Organization
- Awesome Polywrap (Ecosystem Projects)
- Polywrap CLI (Core Developer Experience)
- Client-readiness (Multi-client Test Harness vs. the WRAP Standard)
Talk: Polywrap — Any Protocol, Any Language (ETHCC 4, 2021)
Why We Pivoted
Polywrap’s wedge was the real cost of shipping and maintaining the same integration across many language ecosystems — Web3 was where we first proved demand, but the product thesis applied to software more broadly. By 2022–2023, LLM-era tooling had substantially reduced the need for teams to maintain parallel cross-language SDKs, which weakened the standalone case for a WASM-wrapper platform. The Polywrap product was sunset and the company pivoted toward AI agents in Web3, renaming itself to Agentcoin.
PolyGPT: On-Demand Agentic Capabilities via WebAssembly
PolyGPT was our first serious foray into agentic systems while we were still Polywrap—before the Agentcoin rebrand. It applied the same on-demand wrap model we used in production apps, but inside an LLM-driven agent loop: the assistant could fetch and activate new capability modules at runtime as WebAssembly wraps, so it could grow new behaviors without loading arbitrary native code—preserving the sandbox guarantees that had defined Polywrap’s integration story.