We founded Lilypad to reimagine how artificial intelligence is built and accessed, and enabled developers to run AI models across a distributed network of global compute providers. Our mission was to make high-performance inference and training accessible, affordable, and auditable - all on decentralised infrastructure - and we did.

What we’re proud of

Over the past two years, Lilypad has built a powerful open-source framework, onboarded global contributors, secured partnerships with enterprise and Web3 leaders, and demonstrated real-world applications across deSci, Agents, distributed inference, AI APIs, and user-friendly UI. The platform served thousands of jobs and showcased a new model for trust-minimised AI compute.

We wrote cutting edge research papers (including this arvix-published verification in decentralised networks paper), collaborated with renowned researchers (such as Cedars-Sinai Oncology Researcher Vivek Pujara), unleashed new scientific discoveries (including a new heart medication in collaboration with Dr. Michael Levin and Amelie Schroder thats now in wet lab trials), launched cutting-edge AI Agents and teamed up with some incedible projects across the space including Morpheus, Hive, Baselight.ai, Recall, Chiper.ai.

We’re also proud of our committed dev community and their support over the past 2 years.

• Building a world-class team

• Being one of the first deAI projects in the space (Augment hackathon)

• Pushing the boundaries and having an ambitious vision

• Partnerships across the space with top-tier projects

• Top-tier research & research partnerships support.

• Our committed dev-first community

Why not just…

We know the market is on the rise and conditions are incredibly favourable to deAI projects currently. We want to assure interested parties that we have considered all the possibilities for continuation. This was not an easy decision to come to, and disappointing our committed community, supporters, partners, and stakeholders was not an announcement we ever wanted to make.

We put our blood, sweat and tears into building something we believed in; we were not a memecoin, a rugpull or a fake deal. We built real technology and provable infrastructure that pushed the deAI space forward.

However, 90% of startups fail, and unfortunately, alongside personal founder commitments, we weren't able to secure the support needed to continue to beat the odds.

We still believe wholeheartedly in the decentralised AI future and the vision of Lilypad continues to show that it is relevant and necessary - perhaps even more so than when we first set out to build it.

That’s why we are open-sourcing all of the code and guides to running it on the Github.

Open Sourcing Lilypad

While Lilypad will cease operations, the team is committed to ensuring that open-source components remain available to the community where possible. All support and further updates will be posted to Github.

We will continue to host the infrastructure while we can, alongside our personal GPUs to ensure continuity for our users and partners.

We’d love to see others continue the mission of decentralised AI, or even see a LilypadDAO form.

If you have ideas for the future of Lilypad, feel free to get in touch.

Closing

We set out to prove that open, verifiable compute could change how AI is built - and we showed that it can. From demos to research breakthroughs, enterprise collaborations to community-driven innovation, Lilypad wouldn’t have been possible without you.

Though Lilypad as a company is ending, the mission of decentralised AI is far bigger than us. We remain convinced that decentralised infrastructure, coupled with the primitives of crypto, offers a lasting competitive advantage - for businesses, developers, and end-users alike (We blogged about this here).

We are proud of what we built. We are grateful to everyone who joined us in believing in this vision. And we can’t wait to see where the community takes it next.

Thank you.

The Lilypad Team

Meet Facial DNA Network (FDN)

FDN is building token-incentivised facial recognition tools that let users contribute images, refine biometric models, and earn for their participation. Their approach combines privacy-aware ML pipelines with reward systems that align incentives across communities, developers, and model creators.

Aligned Vision

Both Lilypad and FDN believe in building systems where AI is accessible, transparent, and driven by the people who use it. This partnership is grounded in mutual respect for open ecosystems, user ownership, and scalable infrastructure providing a virtuous cycle and fair economics for contributors.

Synergistic Strengths

Lilypad provides:

• Monetisable Open-Access Model Marketplace

• Flywheel for sustainable data incentives -> model training -> model end use

• Decentralised GPU network capable of running containerised models

• Open API layer with verifiable, pay-per-job execution

• Built-in provenance and proof-of-compute

FDN contributes:

• High-signal facial matching models trained on consented, user-contributed data

• Data incentives for data collection & clear data provenance audits

• A user-friendly interface with filters and remixable outputs

• A tokenised economy ($FDN) designed to support growth, access, and contribution

Together this enables:

• A system where users can run facial inference jobs, choose to share their data, and earn $FDN -> creating a virtuous loop and audit trail for model provenance & economic sustainability

• A platform for launching creative, co-branded campaigns that amplify both utility and reach

• Live containerised deployment of FDN’s model on Lilypad

Why This Partnership Matters

A Real Incentive Flywheel

FDN’s facial inference model is now live on Lilypad. Users can:

• Run inference

• Opt in to share their image

• Improve the model

• Earn $FDN for participating

Each run fuels the system. Data trains better models, better models attract more users, and more users keep the loop spinning.

Specialised Models, Monetised Natively

FDN’s models are designed for identity, avatar generation, and video outputs. They are containerised, callable, and monetised on a per-job basis using Lilypad’s infrastructure. This gives model creators a scalable and direct way to publish and earn.

Transparent Provenance

All Lilypad jobs come with built-in proof. Developers and users can verify what was run, when, and on which hardware. This allows for auditability, reproducibility, and trust across the pipeline.

Clear Benefits for Every Audience

Developers get plug-and-play access to advanced identity models.
Users can contribute, earn, and play with custom outputs.
Ecosystem builders get a composable layer for building next-gen agents, identity flows, or user-facing experiences.

Technical Approach

This collaboration focuses on containerising FDN’s models in a reproducible, job-based format. These models run through Lilypad’s decentralised compute network, with each execution signed by the hardware operator and verified through Lilypad’s proof system. This provides on-chain compatibility, audit trails, and structured attribution.

Use Case Spotlight

This integration unlocks new biometric capabilities for builders and creatives alike. Imagine:

• A decentralised identity onboarding flow that uses FDN’s face match tech for secure verification

• Earning tokens for contributing your image to improve a model, tracked transparently through Lilypad’s job logs

• Lilypad’s first advanced creative model provider joining the network

These aren’t blue-sky ideas. These are now within reach.

Stay Tuned for our exciting collab!

We’re already collaborating on a follow-up project designed to push this even further - bringing creative outputs, on-chain rewards, and social integrations into one launch. We can’t tell you about it yet…. but you’re going to have fun with it!

Stay tuned for more ;)

Get Involved

Follow, test, and build with us:

• @Lilypad_Tech

• @Project_FDN

• facialdna.ai

• lilypad.tech

The future of biometric AI is decentralised, permissionless, and user-powered. Let’s build it together!

Revolutionizing AI Research Through Decentralized Infrastructure

Lilypad Network has established itself as a pioneer in serverless, distributed compute networks that enable internet-scale data processing for AI, ML, and other computation-intensive applications. The Olas Accelerator program, which awards $1M in grants and OLAS Dev Rewards to developers building AI agents for Pearl, represents the perfect synergy for Lilypad's mission to democratize AI infrastructure.

"This partnership represents a fundamental shift in how researchers and developers access computational resources from the Lilypad Network. Developers can simply download the Pearl client and use the Research agent with ease, no need for an API key or other complex configurations" said Alison Haire, CEO and Founder of Lilypad Network. "Our mission is to equip developers with the necessary tools they need to build an open web and be a critical link in a collaborative, decentralized AI platform that anyone can contribute to and use."

Introducing the Lilypad Research Agent

The Lilypad Research Agent leverages the network's distributed compute infrastructure to provide users with unprecedented access to AI-powered research capabilities. Key features include:

• Cost-Effective Research at scale: Eliminates the need for expensive analyst team used to read through large numbers of research papers. Professional from the Biomedical fiend o marketing can use the agent to scale their work, build a critical knowledge base, and produce actionable reports

• Decentralized Compute Access: Harnesses Lilypad's global network of on-demand GPU nodes for computationally intensive research tasks. Compute is verified on-chain using Arbitrum (currently on testnet)

• Open Source AI: Leverage leading models from the open source AI community via the Lilypad network. The research assistant will start using Llama3.3 70b (Quantized)

• Verifiable Results: Utilizes Lilypad's verifiable, trustless computational network to ensure research integrity and reproducibility

Strategic Integration with Pearl Marketplace

Pearl, the world's first "agent app store," allows users to fully own and customize their AI agents while running them autonomously. The integration of Lilypad's Research Agent will enable Pearl users to:

• Scale research efforts while running an agent locally: Pearl is simple to get started and runs locally on the users machine. With the Lilypad research agent, users can run a local agent while accessing powerful AI models and computing resources for scaling inference needs

• Conduct Advanced Research: Access powerful AI models and computing resources for scientific research, data analysis, and academic studies

• Maintain Ownership: Retain full control and ownership of research data and results through Pearl's decentralized architecture

Accelerating Open Science and AI Development

Lilypad's vision extends to "swarms of agents coordinating scientific research" and building decentralized AI systems across a permissionless network. This partnership with Olas represents a crucial step toward that future, where:

• Research institutions can access enterprise-grade compute without the enterprise costs

• Independent researchers gain access to the same computational resources as major tech companies

• Open AI and ML development flourishes through transparent, efficient, and accessible computational ecosystems

• Academic collaboration transcends geographical and institutional boundaries

Looking Forward: The Future of Decentralized AI Research

This partnership positions both organizations at the forefront of the decentralized AI revolution. As Lilypad prepares for its mainnet launch in 2025 and Olas expands the Pearl ecosystem, users can expect:

• Enhanced research capabilities through improved AI model access

• Lower barriers to entry for computational research

• Increased collaboration between the decentralized computing and AI agent communities

• New revenue streams for both compute providers and research contributors

About Lilypad Network

Lilypad is powering democratic participation in the AI Innovation Economy by pioneering avenues for AI Scientists to deploy, distribute and monetise models. As a full stack modular AI services platform, Lilypad provides a model marketplace, MLops tooling, and a distributed, on-demand compute network for scaling AI inference for ML pipelines, agent workflows and desci applications.

The Lilypad Network provides a verifiable, serverless decentralized compute network that offers global, permissionless access to compute power. The network orchestrates off-chain compute through a global GPU marketplace and uses on-chain verification to guarantee compute success.

About Olas

Olas enables everyone to own a share of AI, specifically autonomous agent economies. Founded in 2021, Olas offers the composable Olas Stack for developing autonomous AI agents and the Olas Protocol for incentivizing their creation and co-ownership. Pearl, Olas's flagship application, streamlines entry into the world of autonomous AI agents, enabling users to participate without special skills, advanced hardware, or previous experience.

Keep Up to Date!

https://linktr.ee/LilypadNetwork

This partnership is deeply rooted in history. We first worked with the Recall team back when they were Textile.io, showcasing the potential of decentralized data and compute through early demos with their Basin network.

Today, as Textile has evolved into Recall, with a bold mission to accelerate agentic intelligence through crowdsourced AI competitions, Lilypad is proud to support builders in the Recall ecosystem as they compete in performance based challenges! Check out the latest agent competition on Recall “ETH vs SOL” trading competition to catch the latest action! https://x.com/recallnet/status/1923393004259115417

Shared Vision: Democratizing AI using verifiable systems and p2p tech

Recall is building a foundational layer for AI agents to verifiably track output quality and performance over time! Immutable agent performance logs have proven to be a source of information when choosing to use agents for multi-agent workflows. Lilypad helps to power agent workflows via a decentralized, permissionless compute infrastructure for verifiable AI workflows and inference. Easily on-board new AI models to the network allowing any user of the Lilypad API and CLI low cost access to the model! Compute workloads are verified on the Ethereum blockchain via Arbitrum.

Together, we are:

• Building verifiable systems to ensure actions taken by AI agents have a censorship-resistant record of output performance and inference completed

• Powering a future where AI agents can transact, collaborate, and evolve openly across modular decentralized services

• Providing new tool sets to simply deploy and monitor verifiable AI agents

Details of Partnership - Synergistic Strengths

Lilypad's capabilities:

• Verifiable, on-demand compute network using decentralised edge GPU nodes optimized for AI workloads

• AI model marketplace to easily access and deploy

• Blockchain-backed infrastructure providing verifiability, payment rails, and provenance

Recall's expertise:

• Crowdsourced skill competitions and benchmarks

• Performance-based reputation, rankings, and discovery

• Transparent, auditable chain-of-thought and reasoning

• A credibly neutral foundation for the agentic economy

Together, we are combining technology, infrastructure, community, and tooling to deliver a powerful and modular decentralized AI ecosystem.

Practical Synergies (Short-Term)

• Builders can now deploy AI models on Lilypad and track agent performance on tasks like crypto trading on Recall

• Collaborate on agent competitions including the upcoming ETH vs SOL agent trading competition (https://x.com/recallnet/status/1924818635425538405) as well as future events such as research or marketing agent competitions

Leveraging advances in p2p networking and data verifiability, this partnership helps developers build agents with provable mechanisms to improve agent performance. Immediate benefits of this partnership include:

• Verifiable, decentralized RAG (Retrieval-Augmented Generation) agent pipelines

• Skills benchmarking based on transparent compute and storage proofs

• Censorship-resistant knowledge publishing for agentic systems

Strategic Value and Potential Impact

Why this is strategic:

• Unlocks new agentic AI use cases: decentralized knowledge markets, autonomous skill upgrades, and persistent agent memory

• Empowers developers and researchers to access modular, composable infrastructure without centralized bottlenecks

• Strengthens Lilypad’s ecosystem positioning as the compute backbone of decentralized intelligence

Benefits for the Web3 and OSS ecosystem:

• Creation of composable AI infrastructure primitives

• Greater credibility and adoption of decentralized AI stacks

• New standards for verifiable agentic data, compute, and skill certification

Benefits for developers and users:

• Easier integration between AI computation and decentralized storage

• Access to ready-made pipelines for deploying verifiable agents

• Performance gains, faster development cycles, and cost savings through decentralized architectures

Long-Term Vision - Global Ecosystem Thesis

This partnership reflects a broader shift toward open, decentralized AI infrastructure. Together, Lilypad and Recall are:

• Championing modular ecosystems where AI agents, compute, and storage interact transparently

• Building infrastructure that is owned by its users and communities, not monopolized by platforms

• Setting a new precedent for ecosystem-aligned alliances that grow stronger through collaboration

The future of AI must be permissionless, composable, and community-driven. Lilypad and Recall are working to ensure it is.

Future Outlook - Looking Ahead

Immediate next steps:

• Continued technical integration between Lilypad’s compute marketplace and Recall’s AI competition platform

• Launch of developer resources, co-marketing initiatives, and community onboarding programs

• Joint hackathons, grants, and pilot project showcases across DeSci, DePIN, and Agentic AI sectors

Vision for the long term:

• A thriving decentralized intelligence economy where builders, agents, researchers, and users access a seamless, trustless infrastructure backbone

📍 Explore Recall: recall.network📍 Build with Lilypad: lilypad.tech

Join us in building a future where intelligence is open, composable, and driven by the communities that create it.

1. Physical Infrastructure: The GPU Backbone

These platforms form the compute base layer by renting out GPU resources from individuals or data centers, often using tokenized incentives.

• Akash: Offers a permissionless marketplace for general-purpose compute. Ideal for lightweight AI tasks or persistent inference endpoints.

• io.net: Aggregates idle enterprise-grade GPU resources. Supports heavy ML workloads like image generation and video processing.

• Aethir: Designed for gaming and real-time compute but increasingly focused on AI workloads.

• Hyperbolic: AI-specific DePIN network with focus on inference services and fine-tuning.

• Vast.ai: A fiat-based GPU marketplace with thousands of available rigs. Often used for Stable Diffusion and training.

• Golem: One of the earliest P2P compute networks; suitable for basic AI jobs and distributed simulations.

• Exabits, Spheron, Impossible Cloud: Differentiated on availability, performance pricing, and decentralized guarantees.

Interoperability: These GPU networks often plug into protocols like Lilypad, Gensyn, or Ritual to serve on-demand inference or training jobs. Lilypad coordinates job dispatch and payment, abstracting compute across providers.

2. Decentralized Cloud VMs: Stateless Infrastructure for AI Pipelines

This layer mimics services like AWS Lambda or Docker containers—but decentralized.

• Fluence: Offers WASM containers for stateless execution. Ideal for agent coordination, ephemeral inference, and middleware.

• Aleph.im: Focused on decentralized indexing and serverless hosting—useful for storing and calling AI model metadata.

• Swan Chain, Cartesi: Run secure off-chain compute, Cartesi through Linux-based VMs. Suitable for off-chain model evaluation or RL environments.

Interoperability: These platforms can host parts of AI workflows—such as metadata indexing or post-inference validation—and invoke Lilypad or OpenGradient for actual model execution.

3. AI Agents and Frameworks

The emergent UX of deAI is agentic: models that act autonomously, coordinate resources, and reason.

• Eliza, Morpheus, Virtuals: AI agents that autonomously run jobs, maintain memory, and interact with other agents or protocols.

• Naptha, Olas, Gaia, Theoriq, Recall: Frameworks for building and running these agents. Olas is the most robust, offering incentives, gossip coordination, and scheduling.

• Nevermined: Payments middleware for agents to settle costs autonomously.

Interoperability: Agents built on these frameworks submit jobs to inference platforms like Lilypad or Gaia, store state on IPFS or Arweave, and pay using smart contracts on chains like Optimism or Ethereum.

4. Data, Storage, and Databases

AI’s raw material is data. These platforms ensure it remains verifiable, accessible, and censorship-resistant.

• Data networks & datasets: Baselight.ai (structured datasets), Vana (user-owned data), Grass (web crawling), Openmesh (data commons).

• Storage: Filecoin (deep storage), Arweave (permaweb), IPFS (general-purpose distributed storage).

• Databases: Fireproof.storage, Space & Time (verifiable compute over indexed data).

Interoperability: Lilypad jobs often consume data from Vana or Openmesh, read/write artifacts to IPFS/Filecoin, and can validate lineage via Space & Time or Story Protocol.

5. Middleware & Service Layer

This category handles routing, orchestration, and economic logic in a composable deAI stack.

• SingularityNET: Offers a token-gated AI service registry. Hosts models and agents that can call each other.

• OpenGradient: Coordinating distributed training jobs, with tokenized rewards.

• Ritual: Programmable compute infrastructure for LLMs, often integrated with io.net.

Interoperability: These tools often wrap and route calls to infrastructure like Lilypad or Hyperbolic. For instance, Ritual jobs may be executed on Lilypad’s protocol but initiated through Ritual’s SDK.

6. AI Service Chains

Layer 1 or 2 chains optimized for AI use—either through VM design or native tokenomics.

• 0g: A modular AI operating system focused on scalable storage, data availability, and GPU scheduling. Ideal for high-throughput agent workflows.

• Near: Home to deAI projects and models. Supports contract-level model inference.

• OG Labs, Sahara AI, IoTeX: Building app-specific chains that integrate AI directly into their execution layers.

Interoperability: Lilypad can dispatch workloads or validate results using smart contracts on these chains. These chains also host front-end dApps that submit jobs.

7. Distributed Training Platforms

Instead of centralized clusters, these platforms coordinate training jobs across distributed nodes.

• Gensyn: The gold standard in this space. Coordinated LLM training with incentives for participants.

• Prime Intellect, Nous: Research-focused alternatives enabling RLHF, fine-tuning and collaborative model development.

Interoperability: Lilypad can route fine-tuning tasks to Gensyn or enable collaborative training pipelines across multiple datasets pulled from Vana or Filecoin.

8. Inference Platforms

These specialize in high-throughput, pay-per-use model serving.

• Hyperbolic: GPU inference network focusing on low-latency model runs.

• Gaia: Focused on LLMs and foundational inference for agents.

• Bittensor Subnets: Specialized for specific AI tasks, like vision or translation.

Interoperability: Lilypad is interoperable with Gaia, and in the future could connect to Bittensor subnets via bridging wrappers. Lilypad also offers its own marketplace with inference APIs.

9. Model Hosting Marketplaces

Places where models are deployed, discovered, and monetized.

• Bagel, Prime Intellect, Flock.io: Offer permissionless upload, API-based access, and in some cases, provenance.

• Bittensor Subnets: Some act as model hosts, rewarded via stake.

Interoperability: Models on Lilypad can be cross-posted to Bagel or exposed via Flock APIs. Model metadata can be stored on IPFS and referenced on Arweave.

10. Privacy & Security Layers

Key to enabling AI that respects ownership, user data, and safe execution.

• TEE: Phala, Nillion (confidential execution of inference jobs)

• ZK Proofs: Nexus (privacy-preserving inference verification)

• FHE: Zama, Gateway (encrypted model execution)

• Other Privacy: Lit Protocol (access control), Story Protocol (IP + provenance)

Interoperability: Lilypad can integrate ZK or TEE as plugins for sensitive jobs—e.g., confidential medical inference.

11. Reinforcement Learning Protocols

Still early, but these explore incentive-aligned training via RL.

• Newcoin: RL-based learning from social graph behavior.

• Cambrian Network: RL for distributed learning in autonomous agents.

Interoperability: Lilypad jobs can be used as reward signals or task environments within these RL frameworks.

12. IP & Provenance Tooling

Tracks who built what, how it’s used, and where value flows.

• Story Protocol: Royalty-enabled provenance across derivative works.

• EQTY Lab: Licensing and creator attribution.

Interoperability: Lilypad’s token rails and job graphs can integrate Story Protocol for remix royalties and IP lineage.

13. DeFAI: AI + DeFi Intersections

Finance rails designed specifically for AI workflows and autonomous agents.

• Glif, Parasail: DeFi rails for model monetization, agent staking, or inference loans.

Interoperability: Lilypad can use Glif as a settlement layer, or Parasail to underwrite compute requests.

14. AI Research & Commons

Think tanks, foundations, and data commons ensuring open AI development.

• Foresight Institute: Research funding for AGI safety and open science.

• RMIT Blockchain Innovation Hub, dbForest, CEL: Focused on building frameworks and commons for deAI.

Interoperability: Lilypad can support their agents, training models, or infrastructure. These orgs may also help shape governance.

Where Lilypad Fits

Lilypad is the decentralized execution and economic coordination layer for the AI ecosystem.

• For Model Creators: A frictionless way to deploy and monetize models

• For Compute Providers: Monetize idle GPUs via permissionless job participation

• For Developers: Plug into an on-chain model marketplace with API-based access

Key Differentiators:

• On-chain job routing, execution, escrow, and rewards

• Composability across data, models, compute, and agentic frameworks

• Modular and chain-agnostic, with EVM-based smart contracts

Lilypad acts as the “glue” of decentralized AI—connecting demand and supply across categories through a standardized protocol and token incentive layer.

Final Insight: deAI as a Parallel Chain

Decentralized AI is bigger than a category: it’s an ecosystem. Like DeFi redefined finance, deAI redefines intelligence, coordination, and value creation.

Lilypad’s role isn’t to compete with these players, but to make them usable, valuable, and coordinated.

The future is not closed AI APIs. The future is programmable, composable, community-owned intelligence. And Lilypad is building it.

Together, we are unlocking a new paradigm for community-aligned scientific discovery and decentralized, verifiable AI.

This isn’t just another partnership: it’s the convergence of two pioneering ecosystems solving real-world challenges through compute, coordination, and credibility.

🌟 Details of Partnership - Synergistic Strengths

Lilypad provides:

• A decentralized compute layer designed for AI workloads: model hosting, inference, and agent workflows

• Modular APIs, onchain job execution, and blockchain-native proof-of-compute

• A growing library of machine learning models and agentic tooling for public-good science applications

PoscidonDAO brings:

• Deep expertise in DeSci infrastructure, research coordination, and Web3-native scientific funding

• A vibrant builder and contributor community focused on regenerative health, science, and AI

• Flagship projects like weCura, designed to make decentralized medical AI accessible, transparent, and impactful

Together, we are setting the foundation for a permissionless, collaborative, and evidence-backed approach to decentralized science at scale.

🔧 Practical Synergies (Short-Term)

• Lilypad will serve as the compute layer for PoscidonDAO’s upcoming AI-powered projects, starting with weCura

• Researchers and contributors in PoscidonDAO can now deploy models and workflows on Lilypad's decentralized inference engine

• Shared infrastructure tooling, co-branded documentation, and public demos of science running onchain

Use cases available now:

• weCura: a decentralized platform for trusted medical AI, executed with Lilypad-backed verifiability

• Integration with Rare compute to amplify access to GPU supply for scientific modeling

• New experiments using Lilypad to run, benchmark, and publish reproducible compute pipelines in the open

🚀 Roadmap Collaboration (Mid-Term)

Over the coming months, Lilypad and PoscidonDAO will:

• Build an onchain AI research registry using verifiable Lilypad compute

• Co-develop a model standard for publishing, funding, and validating open science algorithms

• Launch public quests, hackathons, and contributor bounties for AI+science innovation

• Expand weCura’s capabilities across image-based diagnostics, language models, and agentic workflows

What this unlocks:

• Credible, traceable, permissionless compute for DeSci

• A path for research DAOs and contributors to publish inference-ready models backed by transparent results

• Scalable coordination between GPU supply, open-source algorithms, and incentivized research goals

📈 Strategic Value - Benefits for the Ecosystem

Why this matters:

• Scientific research is compute-intensive and credibility-constrained. Lilypad and PoscidonDAO solve both.

• By combining AI-native infrastructure with DeSci-native governance and coordination, we make open science scalable and sustainable

• It aligns communities, capital, and computation in a single, public pipeline

Benefits for Web3/OSS:

• Stronger bridges between DePIN, DeSci, and AI ecosystems

• Model and workflow standardization for open-source researchers

• A new market for verifiable research outputs onchain

Benefits for builders and users:

• Researchers can deploy jobs without centralized gatekeepers

• Compute providers can directly support science workloads

• Communities can co-own and coordinate progress in health, climate, and biological discovery

🌍 Long-Term Vision – Broader Narrative & Ecosystem Thesis

This partnership sets the tone for how AI and science can evolve through decentralized infrastructure.

It reflects Lilypad's core mission: making permissionless compute a public good. And Poscidon's mission: restoring trust and accessibility in scientific progress.

Together we will:

• Power regenerative AI in medicine, climate, and bioscience

• Set best practices for reproducible, open compute-backed research

• Establish a new norm: science and AI that is peer-reviewed by code and executed transparently

This is a blueprint for a new knowledge economy.

📅 Future Outlook / Looking Ahead

Immediate next steps:

• Co-announce partnership and initial integration plans

• Begin onboarding contributors to use Lilypad for weCura and related Poscidon initiatives

• Launch a public roadmap and joint technical showcase

Long-term:

• Expanded DeSci + AI compute economy with bounties, incentives, and shared infrastructure

• Coordination across DePIN alliances and open science DAOs

• A thriving, verifiable, and permissionless research landscape powered by compute-as-a-public-good

🔍 Explore PoscidonDAO: https://www.poscidondao.com

🌎 Deploy DeSci Compute on Lilypad: https://lilypad.tech

#DeSci #Lilypad #PoscidonDAO #weCura #VerifiableCompute #DecentralizedScience #AIForGood #DePIN #ComputeForScience

💸 1. Native Payment Rails

• Definition: Integrated crypto and fiat settlement mechanisms built into the protocol.

• Why it matters: Unlocks global, frictionless participation: whether by a scientist in Kenya or a GPU provider in Vietnam.

• Lilypad edge: Combines Web3 wallets, Stripe fiat integration, and automated smart contract payments.

🧬 2. Provenance Pipelines

• Definition: Track model and data lineage, ownership, and usage history.

• Why it matters: Enables auditability, royalty distribution, and bias inspection in remixed AI models.

• Lilypad edge: Cryptographic job verification + on-chain records provide traceable model provenance.

🌍 3. Permissionless Global Participation

• Definition: Anyone can host models, contribute compute, or run inference jobs.

• Why it matters: Opens up innovation to solopreneurs, SMEs, and underserved regions.

• Lilypad edge: Full-stack platform (marketplace, job runner, monetization) with open interfaces (CLI/API/GUI).

⚖️ 4. Fair Creator Economics

• Definition: Transparent, automated revenue sharing for model creators and compute providers.

• Why it matters: Avoids exploitative, opaque compensation models seen in centralized platforms.

• Lilypad edge: Model owners set pricing and earn per use; rewards flow directly to wallets, on-chain.

🛠 5. Composable Infrastructure

• Definition: Easily integrates with agents, storage, data lakes, and other Web3 systems.

• Why it matters: Enables dynamic pipelines, collaborative AI stacks, and network effects.

• Lilypad edge: Designed for plug-and-play interoperability with agent frameworks, Filecoin, Vana, and more.

🔐 6. Censorship Resistance

• Definition: No centralized authority can restrict model deployment, data use, or job execution.

• Why it matters: Protects open scientific research, politically sensitive tools, and grassroots innovation.

• Lilypad edge: Fully on-chain execution and settlement ensures verifiable, tamper-proof job provenance.

🧠 7. Designed for the Future

• Context: Proprietary AI moats are collapsing. The AI economy is shifting to: Custom, fine-tuned models Agentic workflows User-owned infrastructure

• Lilypad belief: Only open, verifiable, and economically aligned platforms can scale with this explosion.

Lilypad’s Core Philosophy

"AI should be a public good - not a corporate asset."

As a full stack AI services platform, Lilypad provides a model marketplace, MLops tooling, and a distributed, on-demand compute network for scaling AI inference for ML pipelines, agent workflows and more.

Let’s build (actually) open AI together.

Together, we’re unlocking what’s next in on-chain gameplay: adaptive NPCs, generative game content, and dynamic, intelligent player experiences.

🕹️ 2. Meet Our Partner: Uprising Labs

Uprising Labs is not just another Web3 gaming studio—it’s a full-stack platform for bootstrapping and accelerating Web3-native games. With the Dream Catalyst Accelerator, Uprising identifies and supports studios building the future of gaming, layered with AI, social gameplay, and economic primitives.

Built on the Somnia chain, Uprising is positioned to deliver ultra-performant, persistent game worlds with a thriving creator economy at their core. Their mission: empower studios to launch AI-infused, multiplayer-first experiences that scale.

🧭 3. Shared Vision: AI x Gaming x On-Chain Fun

Lilypad and Uprising Labs share a belief in the future of decentralized, intelligent games:

• Games should be dynamic, emergent, and player-shaped

• Infrastructure should be modular, permissionless, and scalable

• AI should power more than just characters—it should power creativity, commerce, and community

Lilypad offers decentralized GPU compute, model hosting, and AI APIs. Uprising delivers game development velocity, publishing infrastructure, and community reach.

Together, we’re building the stack for playable, intelligent, verifiable game worlds.

🛠️ 4. Synergistic Strengths

What Lilypad Brings:

• Permissionless AI compute infrastructure

• Model marketplace for inference, generation, and agent execution

• Job-based architecture for real-time and batch game AI tasks

What Uprising Brings:

• Network of top-tier game studios and builders

• Publishing stack and go-to-market support via Dream Catalyst

• On-chain gaming execution and infrastructure (via Somnia)

🔧 Short-Term Synergies

• Co-piloted AI NPC demos with Lilypad-hosted models and Uprising games

• AI tooling made easily available for Uprising game teams to use for for procedural generation, AI dialogue, or adaptive gameplay

• Tutorials and pilot programs for Lilypad model devs to plug into Uprising-supported studios

🚀 Mid-Term Roadmap

• AI Game Jam with co-hosted teams, prize pools, and launch paths via Dream Catalyst

• Lilypad integration into Uprising’s SDK for plug-and-play AI workflows

• Joint development of AI agents that evolve alongside players in persistent worlds

🧠 5. Why This Matters

This partnership expands the decentralized AI stack into one of its most important domains: entertainment.

• Gives developers new ways to build responsive, living game worlds

• Offers game studios new revenue models by embedding monetizable AI

• Powers creator-owned, player-shaped metaverses built on the Somnia chain

It also drives real demand for decentralized compute, reinforcing the flywheel of verifiable job execution, open infra, and on-chain intelligence.

🎮 6. AI for Gaming: New Adventures Begin

Here are just a few examples of what’s now possible:

• 🎭 Dynamic NPCs that remember, react, and grow with player interactions

• 🗺️ Procedural map and item generation for infinite replayability

• 🧠 Game Masters and narrative agents for emergent stories

• 🎮 Skill-adjusted difficulty tuned in real-time

• 👾 Voice and toxicity detection for fairer multiplayer

• 💰 AI monetization agents for in-game economies

Lilypad Modular Minds meet the Uprising dream: playable agents, generative fun, and infinitely remixable gameplay.

🌍 7. Long-Term Ecosystem Vision

AI is not just a back-end tool—it’s the future of how games will be designed, played, and evolved.

• Uprising powers the studios and launchpads

• Somnia delivers execution and economy rails

• Lilypad brings the compute, APIs, and agentic logic

This partnership sets the foundation for community-shaped, AI-native, on-chain games that think, adapt, and surprise.

📅 8. Looking Ahead

• AI NPC showcase launching soon with Uprising studio partner

• Co-hosted AI Game Jam to onboard new AI x game developers

• Uprising x Lilypad partner track in Dream Catalyst

🌐 Learn more: uprisinglabs.io🧠 Start building: lilypad.tech

Let’s build playable AI—modular, creative, and unstoppable.

#AIxGaming #Web3Games #Lilypad #UprisingLabs #Somnia #GameJam #ModularMinds

Together, we are connecting Swan’s compute leasing and community questing systems with Lilypad’s decentralized AI-first job architecture to grow supply, bootstrap usage, and ignite public awareness.

Details of Partnership - Synergistic Strengths

Lilypad provides:

• Decentralized compute infrastructure purpose-built for AI model hosting, inference, and agentic workflows

• A modular API-first job engine with blockchain-coordinated payments and provenance

• A growing network of builders deploying ML modules, AI agents, and custom applications

Swan brings:

• Global access to GPU supply through trusted relationships with compute providers

• Infrastructure orchestration tools optimized for Web3-native, demand-driven deployments

• A track record of supporting builders and compute-focused projects through technical and business support

Together, Lilypad and Swan create a pipeline from GPU liquidity to application-layer value, with integrated tooling for both compute provisioning and viral ecosystem growth.

Practical Synergies (Short-Term)

• Co-launch of marketing quest initiatives, allowing users to earn points across both Swan and Lilypad ecosystems

• AI model developers can deploy on Lilypad with guaranteed access to compute

• Compute providers participating in Swan can route idle GPU to real AI workloads on-chain

Use cases available now:

• AI developers can deploy models to Lilypad and rely on Swan-backed GPU supply

• Web3 users can earn incentives through cross-ecosystem campaign quests

• Both communities can co-earn rewards for cross-promotion and usage

Roadmap Collaboration (Mid-Term)

In the coming months, Lilypad and Swan will:

• Expand the integration of Swan-sourced GPU into Lilypad's verifiable compute network

• Launch joint case studies showcasing public infrastructure powering real AI workloads

• Provide builders with simplified onboarding documentation and real-time provider benchmarking dashboards

Together, we are building the connective tissue between decentralized compute sourcing and decentralized AI execution.

Strategic Value - Benefits for the Ecosystem

This partnership unlocks:

• Steady supply for AI workloads with global distribution

• Confidence for builders deploying latency-sensitive jobs

• A working model of decentralized coordination between compute sourcing and AI application layers

Benefits for the Web3 and OSS ecosystem:

• Demonstrates modular composability between infra providers

• Provides a blueprint for sustainable DePIN incentive alignment

Benefits for developers and users:

• Easier deployment of AI models without worrying about compute constraints

• Greater geographic availability of compute nodes

• Lower friction, cost, and wait time for AI job execution

Long-Term Vision - Open Compute + AI Collaboration

We believe infrastructure primitives like compute, storage, orchestration, and incentives should not be siloed.

Lilypad and Swan are demonstrating how aligned ecosystems can:

• Bootstrap liquidity across multiple layers: GPU, agent, and community

• Design public incentive systems that reward participation and usage

• Co-develop the playbook for next-generation decentralized infrastructure projects

Together, we are contributing to a future where compute is as composable, decentralized, and accessible as code.

Future Outlook

Immediate next steps:

• Announce partnership publicly across channels

• Launch first round of Lilypad x Swan quests and community incentive tracks

• Integrate Swan GPUs into the Lilypad provider onboarding flow

Long-term:

• Co-managed decentralized compute incentive systems

• Ongoing joint token programs and community campaigns

• Deeper protocol-level integration between Swan job leasing and Lilypad's verifiable execution layer

📍 Explore Swan: swanchain.io📍 Deploy on Lilypad: lilypad.tech

As Lilypad continues to evolve into the nexus of a decentralized AI cooperative, this alliance with Akave strengthens our ability to support verifiable workflows, secure model outputs, data provenance, and composable AI pipelines.

2. Meet Our Partner: Akave

Akave is a Filecoin Layer 2 decentralized data management network that enables secure, programmable data storage, access, and monetization. Designed to empower the next generation of data-driven applications and marketplaces, Akave delivers cost-effective and performant decentralized storage for AI, Web3, and DePIN ecosystems.

Akave’s architecture supports both public and permissioned data buckets, policy-enforced access, and full data provenance—making it the perfect partner for AI systems that require secure storage and traceable lineage.

3. Shared Vision: Infrastructure for Open AI

Akave and Lilypad are aligned by a clear and ambitious goal: building infrastructure for decentralized intelligence.

• Decentralization-first: Both platforms reduce dependency on opaque, centralized cloud providers

• Composable AI primitives: Compute and storage as modular services

• Data provenance and monetization: Transparent value flows and auditability baked into system design

• AI accessibility: Empower developers and creators with verifiable infrastructure at every layer

This partnership is more than integration—it’s the emergence of a decentralized foundation for building, training, and deploying AI applications.

4. Synergistic Strengths

What Lilypad Brings:

• Serverless decentralized GPU compute

• On-demand model hosting, inference APIs, and agent workflows

• Verifiable job execution and API-first architecture

What Akave Brings:

• Decentralized object storage with programmable data buckets

• Full support for on-chain provenance and usage policies

• Optimized infrastructure for large LLM and ML workloads

🔧 Short-Term Use Cases

• RAG Integration Pilot: Showcase a reference architecture for retrieval-augmented generation using Akave-stored data and Lilypad inference

• Model Caching: Use Akave to store fine-tuned models and intermediate outputs

• Job Output Storage: Enable users to preserve inference results and synthetic datasets with cryptographic traceability

🚀 Mid-Term Roadmap

• Plugin-like Integration: Build native ingestion and retrieval pipelines between Akave and Lilypad

• Co-hosted Agent Workflows: Empower developers to deploy agents that retrieve, compute, and store data using both networks

• Synthetic Data Provenance: Enable tracking and monetization of AI-generated data across the full pipeline

• Reputation Transparency: Store Lilypad job provider statistics and performance metadata using Akave’s provenance infrastructure

5. Strategic Impact

This collaboration delivers:

• A fully modular decentralized AI stack

• Real value for users: fast, flexible, censorship-resistant compute and storage

• Clear provenance for models and data outputs, a critical need for commercial and regulated AI

• Blueprints for the ecosystem: example architectures that others can replicate and build on

Together, Lilypad and Akave move the ecosystem beyond theory to execution, showing what a real decentralized AI infrastructure can look like.

6. Long-Term Ecosystem Vision

This is only the beginning. The long-term vision is a global, modular, permissionless infrastructure layer for AI:

• Lilypad powers verifiable computation and AI agent execution

• Akave anchors decentralized storage and data integrity

• Together, they offer an open foundation to train, fine-tune, and deploy models with full transparency and composability

With upcoming POCs such as Waterlily 2.0 (artist attribution via model fine-tuning) and data-to-agent reference architectures, the potential for future impact is vast.

7. Looking Ahead

This announcement is only the first beat of a new rhythm. The decentralized AI stack is forming.

• 🌐 Signup for Akave testnet: https://akave.ai/testnet

• 🧠Join Lilypad ecosystem to deploy, run, and monetize models: https://docs.lilypad.tech

Let’s build decentralized intelligence infrastructure - together.

This collaboration unites Lilypad's decentralized compute infrastructure with Chirper's autonomous agent ecosystem, paving the way for a new era of decentralized AI applications.

⚠️ Stay tuned: the next thing we launch together will be something truly special. We’re already working on a powerful proof-of-concept to showcase what Lilypad + Chirper unlocks.

💰 Want in? You can now buy $CHIRP on Raydium to join the agentic revolution.

🌟 Details of Partnership - Synergistic Strengths

Lilypad provides:

• Decentralised compute infrastructure tailored for AI model hosting, inference, and agentic workflows

• A modular, API-first job engine with blockchain-coordinated payments and on-chain provenance

• A permissionless platform for AI developers to deploy, monetize, and scale models without intermediaries

Chirper.ai brings:

• • A vibrant ecosystem of autonomous AI agents engaging in social interactions without human intervention

    • Innovative tokenomics through the $CHIRP token, enabling agent-based economies and value creation

    • A platform fostering the development of agentic DAOs and collaborative AI behaviours

Combined strengths:

• Integration of Lilypad's compute resources to power Chirper's AI agents, enhancing performance and scalability

• Collaboration on developing decentralized applications that leverage both compute and autonomous agent technologies

• Joint efforts to expand the AI and Web3 developer communities through shared tools and resources

🔧 Practical Synergies (Short-Term)

• Compute Integration: Chirper's AI agents will utilize Lilypad's decentralized compute network for enhanced processing capabilities

• Developer Tools: Launch of co-branded tools and SDKs to facilitate the creation and deployment of AI agents on the combined platform

• Community Engagement: Joint campaigns to engage developers and users in building and interacting with autonomous AI agents

Immediate benefits:

• Improved performance and scalability for Chirper's AI agents through access to Lilypad's compute resources

• Expanded opportunities for developers to create and monetize AI agents in a decentralized environment

• Enhanced user experiences through more responsive and capable AI interactions

🚀 Roadmap Collaboration (Mid-Term)

• Agentic DAOs: Development of decentralized autonomous organizations composed of AI agents, leveraging both platforms' technologies

• Tokenomics Integration: Alignment of Lilypad's and Chirper's token economies to incentivize participation and value creation

• Cross-Platform Applications: Creation of applications that utilize Chirper's AI agents and Lilypad's compute infrastructure for various use cases, including gaming, social networking, and decentralized finance

Upcoming milestones:

• Release of joint whitepapers and technical documentation outlining the integrated platform's capabilities

• Hosting of hackathons and developer events to foster innovation and collaboration within the community

• Expansion of the combined ecosystem through partnerships with other AI and Web3 projects

📈 Strategic Value - Benefits for the Ecosystem

Why this is strategic:

• Combines decentralized compute and autonomous AI agents to create a robust platform for AI application development

• Fosters innovation by providing developers with the tools and infrastructure needed to build next-generation AI solutions

• Strengthens the Web3 ecosystem by demonstrating the practical applications of decentralized technologies in AI

Benefits for Web3/OSS:

• Introduction of new use cases for decentralized technologies in AI and social networking

• Increased credibility and adoption of decentralized AI solutions through real-world applications

• Enhanced composability of infrastructure, enabling seamless integration with other Web3 projects

Benefits for developers/users:

• Access to a powerful platform for building, deploying, and monetizing AI agents

• Simplified integration of AI capabilities into decentralized applications

• Opportunities to participate in and benefit from the growth of the decentralized AI economy

🌍 Long-Term Vision – Broader Narrative & Ecosystem Thesis

This partnership represents a significant step toward a future where AI infrastructure is decentralized, modular, and accessible to all.

By combining Lilypad's compute network with Chirper's autonomous agent ecosystem, we are laying the foundation for a new paradigm in AI development and interaction.

Shared goals:

• Empower developers to create AI agents that operate independently and collaboratively in decentralized environments

• Promote the adoption of decentralized technologies in AI applications across various industries

• Foster a vibrant community of developers, users, and stakeholders committed to building the future of AI

📅 Future Outlook / Looking Ahead

Immediate next steps:

• Integration of Lilypad's compute resources into Chirper's platform

• Launch of co-branded developer tools and resources

• Initiation of community engagement campaigns to promote the partnership and its benefits

Long-term vision:

• Establishment of a decentralized ecosystem where AI agents can operate, collaborate, and evolve autonomously

• Expansion of the platform's capabilities to support a wide range of AI applications and use cases

• Continued collaboration with other projects and communities to drive innovation and adoption of decentralized AI solutions

Call to Action:

• Explore Chirper.ai: https://chirper.ai

• Deploy on Lilypad: https://lilypad.tech

• Buy $CHIRP on Raydium

• Join our communities and be part of the decentralized AI revolution

Together, Lilypad and Chirper.ai are redefining the boundaries of AI and decentralization. Join us as we build the future of autonomous AI economies.

This alliance is part of Lilypad’s broader ecosystem strategy to bring together every critical layer—compute, models, and now structured data—into an open innovation economy for AI.

2. Meet Baselight

Baselight is a decentralized platform for structured data discovery, querying, and monetization. With over 27 billion rows of data, 140,000 tables, and integrations across DeFi, DeSci, and Web3, Baselight enables developers and researchers to build insights, dashboards, and intelligent agents using high-quality, accessible datasets.

Built by Finisterra Labs and backed by Haun Ventures and Lightshift Capital, Baselight is laying the foundation for a globally distributed, transparent data layer for AI.

3. Shared Vision: Unlocking Open Intelligence

Lilypad and Baselight are deeply aligned in their mission to decentralize core infrastructure for artificial intelligence. Both teams believe in:

• Decentralization as a catalyst for innovation

• Open infrastructure as a public good

• Data and model provenance as critical primitives for trustworthy AI

Lilypad provides decentralized compute, AI Models and agent execution, while Baselight delivers the structured, queryable data needed to fuel model development, RAG systems, and real-time analytics. Together, the two platforms enable a vertically integrated decentralized AI pipeline.

4. Synergistic Strengths

Lilypad’s Capabilities:

• Distributed GPU compute network with job-based pricing

• Permissionless deployment of AI models with API endpoints

• Full-stack infrastructure for inference, RAG, MCP, fine-tuning, and agent workflows

Baselight’s Capabilities:

• Massive structured data catalog with 1-click query interface

• SQL-native analytics and soon-to-launch data APIs

• Transparent licensing, monetization, and versioned provenance

🔧 Short-Term Use Cases

• Immediate demos of Lilypad-hosted LLMs accessing Baselight data in RAG workflows

• Co-branded tutorials showcasing Baselight’s structured datasets as inputs for deployed models

• Co-marketing initiatives to raise awareness around structured data’s role in decentralized AI

🚀 Mid-Term Roadmap

• Native API integrations for streamlined Lilypad-Baselight developer pipelines

• Preprocessing models deployed on Lilypad to normalize public Baselight datasets

• Opt-in flow for pushing Baselight data into vector indexes for real-time agent querying

• Token-aligned revenue share and staking infrastructure tied to data and model contributions

5. Strategic Impact

This partnership creates a robust, composable stack for the decentralized AI economy:

• Model + Compute + Data in one programmable pipeline

• Greater accessibility for developers and researchers

• Verified provenance from data ingestion to inference outputs

• Cross-platform monetization opportunities for both data and model contributors

It also signals to the broader ecosystem that decentralization is not just viable—it’s operational and performant.

6. Long-Term Ecosystem Vision

This collaboration represents a foundational move toward an open-source intelligence stack. Structured data fuels the reasoning layer of intelligent systems. Compute makes it actionable. Together, Lilypad and Baselight unlock:

• Agentic pipelines powered by verifiable data

• Training pipelines that preserve IP and open-access distribution

• A new model for trust-aligned, modular infrastructure in the AI economy

Baselight will become the trusted repository for public and permissioned structured data. Lilypad will ensure this data can be processed, queried, and monetized through composable compute workflows.

7. Looking Ahead

Explore Baselight: baselight.aiExplore Lilypad: lilypad.tech

Join us as we help define the next era of AI—one built on open infrastructure, transparent coordination, and verifiable trust.

Let’s build decentralized intelligence infrastructure - together.

Lilypad is thrilled to announce a strategic partnership with Hive Intelligence, a project that shares our mission to decentralize AI from the ground up. This collaboration marks a pivotal step toward building composable, agentic ecosystems powered by open data, decentralized compute, and permissionless intelligence.

Together, we are setting a new standard for AI networks that are not only powerful, but modular, traceable, and self-evolving.

2. Meet Our Partner: Hive Intelligence

Hive Intelligence is a decentralized ecosystem for collective machine intelligence. By combining the power of individual agents with a reputation-based coordination layer, Hive enables a swarm of autonomous entities to work collaboratively across tasks, domains, and applications.

It’s not just about running an agent. It’s about coordinating thousands of them into purposeful, intelligent collectives—complete with memory, incentives, and composable structure.

3. Shared Vision: The Cooperative AI Stack

Lilypad and Hive Intelligence share a belief in open, collaborative intelligence infrastructure:

• AI should be modular and composable, not locked into black boxes

• Networks should reward contribution and cooperation, not centralize control

• Developers, researchers, and communities should own the tools of intelligence

Lilypad provides the decentralized compute substrate—hosting, executing, and monetizing models and agents. Hive brings the orchestration, collective reasoning, and agent-to-agent collaboration that turns those models into living systems.

Together, we enable a new category: decentralized cooperative AI.

4. Synergistic Strengths

What Lilypad Brings:

• Globally distributed GPU compute

• On-demand job execution for inference, fine-tuning, and agent workflows

• Modular, API-first architecture for hosting permissionless AI

What Hive Brings:

• Agent graph protocol for distributed collaboration

• On-chain reputation and decision layers

• Tooling to compose, spawn, and route between intelligent agents

🔧 Short-Term Synergies

• Co-hosted agents that utilize Lilypad for compute and Hive for logic and coordination

• Shared reference architecture for building decentralized AI swarms

• Joint community initiatives and cross-ecosystem tutorials for developers

🚀 Mid-Term Roadmap

• Native integration: deploy Hive agents directly to Lilypad via plug-and-play modules

• Decentralized agent marketplaces with Lilypad-backed compute execution

• Hive memory and reputation layers attached to Lilypad job metadata

5. Strategic Value for the Ecosystem

This partnership unlocks tangible benefits:

• A truly modular decentralized AI pipeline: Agent Coordination + Scalable Compute

• Support for long-lived, autonomous agents across use cases like DeSci, DePIN, and more

• Examples of collective memory, agent training, and inference all in one ecosystem

• Composable interfaces for researchers, builders, and institutions

It signals that open-source AI is no longer just possible—it’s here, growing, and collaborative by design.

6. Long-Term Ecosystem Vision

We believe the next evolution of AI is cooperative intelligence. Not one model to rule them all, but thousands of interconnected agents collaborating across ecosystems, each with their own incentives, provenance, and performance record.

Hive is building the brains. Lilypad is building the muscle. And together, we’re creating the nervous system of decentralized AI.

This partnership paves the way for:

• Decentralized cognition at scale

• Composable, swarm-native AI architectures

• Fair attribution, persistent memory, and cross-network coordination

7. Looking Ahead

• Co-branded reference examples and tutorials launching soon

• Exploratory research into decentralized agent marketplaces

• Hive x Lilypad developer integrations and pilot swarm deployments

🌐 Learn more: hiveintelligence.xyz🧠 Explore Lilypad: lilypad.tech

Let’s build the next generation of AI—modular, verifiable, and permissionless—together.

#CooperativeAI #Web3 #MultiAgentSystems #DePIN #LLMs #Lilypad #Hive

RPs selected for the beta will get a Discord role unlocking access to a channel for beta communications. Only RPs that have been accepted into the beta can post resource offers to the Lilypad solver to run jobs.

The beta aims to replicate job based revenue RPs will earn on Mainnet. Nodes running jobs consistently each day will earn rewards based on hardware contributed to the network.

Anyone can submit a request through this form to become a Resource Provider** in the beta program.**

Verification Process

To ensure Resource Providers admitted to the RP beta are operating as to be expected, test jobs will run on RPs at least once every hour. RP nodes must be able to process jobs successfully with a valid output. If your node has been removed from the RP beta and you’re not running jobs, please reach out to us (within the rp beta discord channel) if you haven't already been notified.

Nodes that don't meet our performance requirements will unfortunately be removed from the program and will not be eligible for rewards.

More information about our base daily reward calculation is found below.

Tracking your Resource Provider on Lilypad

To query the Solver for the current online nodes (over all resource offers)

curl https://solver-testnet.lilypad.tech/api/v1/resource_offers | jq '.[] .resource_provider'|sort|uniq

To query the Solver for current online nodes (not matched)

curl [https://solver-testnet.lilypad.tech/api/v1/resource_offers\\?not_matched\\=true](https://solver-testnet.lilypad.tech/api/v1/resource_offers%5C%5C?not_matched%5C%5C=true) | jq '.[] | .resource_provider'

To query the Solver for job offers in the queue

curl [https://solver-testnet.lilypad.tech/api/v1/job_offers\\?not_matched\\=true\\&cancelled\\=false](https://solver-testnet.lilypad.tech/api/v1/job_offers%5C%5C?not_matched%5C%5C=true%5C%5C&cancelled%5C%5C=false) | jq '.[] .job_offer.module.repo'

Rewards Information

Daily Resource Provider rewards are determined by the hardware specifications of the RP as well as reliability/uptime. Rewards every month are split up between all the rp's. Currently, a RTX 4090 earns approximately 2,200 Lilybits per day (as of March 2025). RP points can be tracked here.

It's important to note that during the beta program, RPs will not face slashing penalties regardless of whether they are accepted into or participate in the beta.

It is also possible for Resource Providers's to earn extra BONUS Lilybits in a few situations such as

• troubleshooting critical problems with a Lilypad RP OR a Lilypad module

• Tooling built to assist in management of a Lilypad RP

• Tooling built around Lilypad module testing

Looking Forward

While we may encounter some challenges along the way, these efforts are crucial to building a reliable network for our Job Creators (Lilypad network users). Your patience and dedication as we transition to the next phase of Lilypad are deeply appreciated. Thank you for your continued support!

In this guide, we will be building a simple yet functional chatbot using Next.js and Llama3, leveraging Anura's API to generate responses based on user input. By the end, you’ll have a working chatbot and a deeper understanding of how to integrate LLMs into your own applications.

Available models

Our API currently supports a variety of powerful AI models tailored for different tasks, from code generation to multimodal reasoning. Whether you're looking for high-performance text generation or efficient scaling, we have models suited to your needs. We are always exploring and deploying new models to expand our offerings, so if there's a specific model you'd like to see added, let us know!

• Qwen2.5 Coder (7B)

• DeepSeek R1 (7B)

• LLaVA (7B)

• OpenThinker (7B)

• Phi-4 (14B)

• Phi-4 Mini (3.8B)

• Qwen2.5 (7B)

• DeepScaler (1.5B)

• Llama 3.1 (8B)

• Mistral (7B)

Getting started

Run the following command to create a new Next.js application:

npx create-next-app lilypad-chatbot

Navigate into the project directory:

cd lilypad-chatbot

Before moving on, let’s generate Anura API keys. Head to the Anura site and sign up. Log in to your account and generate an API key.

Create a .env file in the project root and add your key to the LILYPAD_API_TOKEN variable:

LILYPAD_API_TOKEN=<API_TOKEN>

Client-side components

The Form component serves as the interface between the user and the selected LLM. It manages user input, maintains conversation history, sends requests to the inference API and updates the UI with AI-generated responses.

At the heart of this component is conversation state management. Since LLMs perform better with contextual input, we retain the last six messages (MAX_HISTORY = 6). As this is more of a basic illustrative example, setting a max history prevents excessive memory usage while guaranteeing that the AI has enough recent context to generate relevant responses. Every time a user submits a new message, it’s added to the conversation state and the oldest messages are discarded if necessary.

Once the message is ready, it is sent to the API via a POST request. This request includes the current conversation history, allowing the LLM to generate responses in context. The function extractContent() processes this stream, filtering out incomplete or malformed data and extracting the final AI-generated text.

After processing the response, the conversation state updates and the UI refreshes to show the latest interaction. The input field is also cleared, allowing the user to continue the conversation.

Create a directory named components inside of app. Next we can create the form component we will be using as the main chat section. Create a file named Form.js and add the following code:

"use client";
import { useState } from "react";

const MAX_HISTORY = 6; // Limits conversation history to the last 6 messages to avoid excessive memory usage.

export default function Form() {
  const [inputValue, setInputValue] = useState(""); 
  const [conversation, setConversation] = useState([]); // Stores the chat history between the user and the AI.
  const [loading, setLoading] = useState(false); // Tracks if the AI is currently generating a response.

  const handleSubmit = async (e) => {
    e.preventDefault();
    setLoading(true);

    // Keeps only the last MAX_HISTORY messages to maintain context but prevent unbounded growth.
    const updatedConversation = [
      ...conversation.slice(-MAX_HISTORY), // Trims conversation history before adding new input.
      { role: "user", content: inputValue }, // Appends the latest user message.
    ];

    try {
      await new Promise(resolve => setTimeout(resolve, 500)); // Simulates a short delay to mimic request latency.

      // Sends conversation history to the backend for inference.
      const res = await fetch("/api/run-inference", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ messages: updatedConversation }),
      });

      const data = await res.json();
      const result = extractContent(data); // Extracts the AI response from the streamed API output.

      if (!res.ok) throw new Error(data.error || "Failed to fetch response");

      // Updates conversation history, ensuring the user message and AI response stay within MAX_HISTORY.
      setConversation([...updatedConversation, { role: "assistant", content: result }]);
      setInputValue(""); // Clears input field after submission.
    } catch (error) {
      console.error("Error:", error.message);
      alert(`Error: ${error.message}`);
    }

    setLoading(false);
  };

  function extractContent(apiResponse) {
    const { text } = apiResponse;

    // Split response by "data: " but remove empty entries
    const jsonStrings = text.split("data: ").filter((entry) => {
      try {
        const jsonData = JSON.parse(entry.trim());
        // Ensure it's the assistant's message by checking for 'choices'
        return jsonData.choices?.[0]?.message?.content;
      } catch {
        return false; // Skip invalid JSON entries
      }
    });

    if (jsonStrings.length === 0) return null;

    // Get the last valid assistant response
    const finalData = JSON.parse(jsonStrings[jsonStrings.length - 1].trim());
    return finalData.choices[0].message.content;
  }

  return (
    <div className="flex flex-col mx-auto text-center items-center w-2/3 justify-center bg-black text-white">
      <p className="text-3xl mb-4">llama3.1:8b</p>

      <div className="w-full p-6 border border-white rounded-lg bg-gray-900 text-left">
        <p className="text-lg font-semibold mb-2">Conversation:</p>
        <div className="p-3 bg-gray-800 border border-gray-600 rounded-lg w-full text-white">
          {conversation.length === 0 ? (
            <p className="text-gray-400">No messages yet. Ask something!</p>
          ) : (
            conversation.map((msg, index) => (
              <div key={index} className={`mb-2 ${msg.role === "user" ? "text-blue-300" : "text-green-300"}`}>
                <strong>{msg.role === "user" ? "You:" : "AI:"}</strong> {msg.content}
              </div>
            ))
          )}
        </div>
      </div>

      <form onSubmit={handleSubmit} className="mx-auto w-full p-6 border border-white rounded-lg mt-4">
        {/* Input field for user messages */}
        {!loading ? (
          <input
            type="text"
            value={inputValue}
            onChange={(e) => setInputValue(e.target.value)}
            className="w-full p-3 bg-black border border-white rounded-lg text-white placeholder-gray-400 focus:outline-none focus:ring-2 focus:ring-white"
            placeholder="Ask me anything..."
            required
          />
        ) : (
          // Displays a loading animation while waiting for the response. You can use whatever animation you want
          <img src="lp-logo.svg" className="w-6 mx-auto animate-spin" />
        )}

        {/* Submit button */}
        <button
          type="submit"
          className="w-full mt-4 p-3 font-semibold border border-white rounded-lg transition-all duration-200 ease-in-out bg-white text-black hover:bg-gray-300 disabled:opacity-50 disabled:cursor-not-allowed"
          disabled={loading}
        >
          {loading ? "Thinking..." : "Submit"}
        </button>
      </form>

      {/* Button to clear conversation history */}
      {conversation.length > 0 && (
        <button
          className="w-full mt-4 p-3 font-semibold border border-white rounded-lg transition-all duration-200 ease-in-out bg-white text-black hover:bg-gray-300"
          onClick={() => {
            setConversation([]); // Resets conversation history.
          }}
        >
          Try Again
        </button>
      )}
    </div>
  );
}

The page.js file serves as the entry point for the application, rendering the main chat interface. It imports the Form component from the components directory and displays it inside a centered container.

Inside of page.js, add the code below:

import Form from "./components/Form";
export default function Home() {
  return (
    <div className="items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20 font-[family-name:var(--font-geist-sans)]">
      <Form />
    </div>
  );
}

Server-side component

The route.js file acts as the backend handler for processing user queries and interacting with the Lilypad API. It receives messages from the frontend, sends them to the LLM, processes the streamed response and then returns the final output to the client.

Unlike a standard API call that returns a complete response at once, the Lilypad API responds with a continuous stream of data. This means we need to handle incoming chunks incrementally, decoding them as they arrive. The reader.read() loop ensures that the entire response is collected piece by piece before returning it to the client.

Each request carries the current conversation history (context for the LLM), allowing the model to generate responses with relevant context. The temperature and max_tokens parameters control how the model behaves. The temperature adjusts randomness, while max_tokens ensures the response doesn’t exceed a set length. For more information on the valid parameters for the API, please refer to the Lilypad docs.

Once the response is fully received and processed, it is returned to the client. This allows the Form component to update the UI dynamically, creating a smooth and responsive chat experience.

Inside of the app directory, create an api folder, and within it, a run-inference directory. In this directory, create a route.js file. This file will define the server-side API endpoint responsible for handling chat requests and communicating with the API for AI inference.

The route.js function will:

• Extract the conversation history from the request.

• Construct the inference request with model parameters.

• Send the request to the Lilypad API for processing.

• Stream the response chunk by chunk, ensuring efficient handling of large responses.

• Return the processed response to the client.

import { NextResponse } from "next/server";

export async function POST(req) {
  try {
    const { messages } = await req.json();
    const API_URL = "https://anura-testnet.lilypad.tech/api/v1/chat/completions";
    const API_TOKEN = process.env.LILYPAD_API_TOKEN;

    const requestBody = {
      model: "llama3.1:8b", // Can use any available model on the API
      messages, // Passes the conversation history to maintain context
      max_tokens: 2048, // Caps response length to prevent runaway token usage
      temperature: 0.7, // Controls randomness—higher values make responses more diverse
    };

    const response = await fetch(API_URL, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Accept": "text/event-stream", // Enables streaming to return partial results as they are generated
        "Authorization": `Bearer ${API_TOKEN}`,
      },
      body: JSON.stringify(requestBody),
    });

    if (!response.ok) {
      throw new Error(`API request failed with status ${response.status}`);
    }

    const reader = response.body.getReader();
    let result = "";

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      result += new TextDecoder().decode(value); // Decodes streamed chunks as they arrive
    }

    return NextResponse.json({ text: result });

  } catch (error) {
    console.error("API Route Error:", error);
    return NextResponse.json({ error: error.message }, { status: 500 });
  }
}

Running the chatbot

Now that everything is set up, it's time to run the chatbot and test the interaction with the API. Follow these steps to start the application and begin chatting with the AI:

Start the Development Server

Run npm run dev to start your local server.

Interacting with the Chatbot

Open http://localhost:3000 in your browser and type a message in the input field and press Submit.

The chatbot will:

• Send your input to the API.

• Process the AI’s response and display it in the chat window.

• Maintain a conversation history, ensuring relevant context in responses.

Here is an example of how the chatbot interacts in a conversation:

What’s next?

That’s it! With this guide, you’ve successfully built a basic chatbot using Next.js and Lilypad’s Anura API, integrating real-time AI responses into your app. You’ve learned how to:

• Set up a Next.js project and configure Anura API keys.

• Build a client-side chat interface that maintains conversation history.

• Create a server-side API route to process user input and stream AI responses.

This is just the beginning! You can extend this chatbot by:

• Switching models to explore different capabilities.

• Adding UI enhancements, such as message streaming instead of displaying responses all at once.

• Improving memory handling, such as storing chat history in a database for long-term context.

For more details on available models and additional API features, check out the Lilypad API documentation. If you have any questions or ideas for improvements, feel free to reach out to the the in the Lilypad Discord.

You can check out the source code for this example here!

Typically, smaller startups, academic researchers, and indeed any organization without funding and resources to set up or purchase compute infrastructure. Demand for HPC often exceeds capacity by over 300% [1]. Lilypad will make it trivial to not only access these resources, but to also enable the flexibility and customizability to access resources on-demand, for any task. This includes certain High Performance Compute (HPC) tasks. Lilypad will take on specific types of tasks, such as large-scale batch inference, that require considerable infrastructure, but aren’t necessarily the best use of a typical HPC network’s resource. This type of task doesn’t require fast networking speeds between machines, and can be outsources to a decentralized system like Lilypad.

Traditional HPC Networks

High Performance Compute is typically a system where computer hardware is joined together in a network that has high bandwidth (400Gbps transfer), low latency, high efficiency, and has specialized hardware. Traditionally, high performance compute networks were a very specialized and coordinated set of hardware and configurations that were localized to one or a few geographical locations. Ten years ago, HPC networks were made up of tens or hundreds of computers networked together. Today, you can get the same GPU compute power one used to have to source from an HPC network from a single piece of hardware for less than $10,000.

HPC Networks enable a level of computation that isn’t possible on single machines. Use cases include genomic research (tasks such as protein folding), weather forecasting, complex scientific and engineering simulations, and AI/ML Model training that require massive parallel processing over what can amount to petabytes of data.

The Lilypad Approach

GPUs such as NVIDIA’s A100 and H100 or the AMD Instinct MI250 can handle high performance tasks like complex deep learning workloads. Lilypad empowers anyone with idle GPU capacity to participate in a global compute network, unlocking affordable high-performance resources for startups, researchers, and innovators—locking users into the fees and restrictions on models like traditional cloud providers.

The difference from traditional HPCs is in how Lilypad is tackling this problem by creating a decentralized, open network, meaning we aim to accommodate a wide range of different types of machines as providers, and build a platform that can coordinate and accommodate these in a way that makes it possible to do these compute- and data- intensive tasks. Using advances such as containerization and better distributed systems tooling, it is now possible to coordinate a worldwide high performance compute network.

The Lilypad Network

One of the unique things about the LIlypad network is that it is a decentralized and open network. Any compute provider, or node, at or above a defined performance threshold can join and be paid (In our native LILY currency) for running jobs sent to the network.

For our MVP, we are prioritizing computers with enough GPU (as well as CPU and memory) that can run one-shot inference jobs, AI agents that use chain-of-thought or sequential prompting, and customized high demand open source models.

Decentralizing Certain HPC Tasks

The Lilypad Network is uniquely suited to certain types of HPC tasks. Because it is a decentralized network, there are certain limitations in terms of latency. In other words, one shouldn’t expect the millisecond responses you get with AI chatbots, but that doesn’t mean there aren’t hundreds of applications that Lilypad is well suited for. Just a few examples of what our network can be used for:

• Provide resources for pharmaceutical and biological research for academics who are new to GPU processing and need access to the newest models

• Batch data processing for financial analysis, and large scale data processing

• RAG-driven model customization - create customized and secure modules that can be connected to business’ private documentation datasets to generate business documents

• Processing of edge and IoT device data

• Publish fine-tuned models for specific applications that can be quickly run via an API endpoint.

Enabling Small Project Growth

Many new initiatives , whether they are emerging startups, academic research groups, and innovative projects often face a choice: invest significant capital in building compute infrastructure or pay premium rates to cloud provider. Cloud providers enable a quick and easy setup of resources needed, and scalability for when a project’s scope and computing needs grow. The drawback here is the significant cost of these remote options, as well as vendor lock-in (the cost and difficulties that are designed into cloud systems to prevent users from switching to other services). By switching away from large, incumbent cloud providers, projects and companies can save tens to hundreds of thousands [2] on operating costs, depending on the size of their computing needs.

Because of the way that we are designing our Module Marketplace, it is possible for users who have custom workflows and jobs to include their job as a ‘module’ that can be run on Lilypad. This means even censored AI models, models unavailable elsewhere, or models that have been customized with fine tuning (or RAG workflows with custom datasets) can easily be accessed, on-demand, from an API endpoint, in a serverless manner. Traditionally jobs like this are only an option if you take on the cost and time of paying for and configuring your own hardware.

Meeting Specific Needs of the AI Era

What the Lilypad network is doing is enabling any user with needs for certain high performance compute tasks to access it at a much more competitive rate than major cloud providers offer. We also remove time commitments and obfuscate the overhead work of setting up infrastructure, which are real costs to any organzation accessing compute from a GPU rental marketplace [2]. Our platform delivers serverless, on-demand AI compute and model hosting, enabling rapid deployment and experimentation without the burdens of traditional infrastructure. Anyone can add, test, and run their model via an endpoint, so you aren’t restricted to a limited set of models or compute jobs in the way other similar services are, and you pay on-demand, for only the compute you use, instead of monthly for access to services.

There are certain latency limitations with Lilypad, and the network isn’t able to specify the exact hardware in the same way a single-owner HPC network can. It does, however, provide distributed container orchestration, job scheduling, and management with Bacalhau, and has the ability to support massive parallel processing in Docker containers across a peer-to-peer network of hardware. This is why Lilypad has started by targeting a few distinct use cases such as custom AI Inference tasks, and is exploring other uses such as RAG, Fine Tuning, and supporting Agentic AI workflows.

The Lilypad Value

The value of what Lilypad is creating lies in both the customizable, on-demand access to compute, but also the competitive marketplace that results in gains by parties on either end. The resource providers who would otherwise be unable to monetize idle compute power have the opportunity to make the most of their infrastructure investment, and those running jobs benefit from a marketplace where they pick from pre-configured jobs and can bid on lower priced resources. Our open market means job creators will benefit from competitive pricing, as compute providers compete to win jobs to monetize their idle compute. Moving from traditional cloud compute providers means end users can get much closer to on-prem costs, with savings of up to 25%-66% [2], depending on the scale of a project.

Plus, with the Lilypad Module Marketplace, users aren’t locked in to only using certain models. Module Creators can easily containerize, configure, test, and release any model they need on the Lilypad network, then access the job on-demand with an API endpoint. Other API-endpoint services give users and builders a limited selection, which inevitably forces a choice between building something customized to your needs, or, setting up or renting your own infrastructure.

We are also fostering the growth of a massive library of different useful models and compute jobs on our network, by adding in an incentive to our protocol that enables module creators to earn a small piece of the fee for a job each time their module is run. An incentivized open marketplace naturally will allow these creators in our ecosystem to build at the speed of open source.

Conclusion

Lilypad provides the best for all those in our network: Monetization of idle power for those who contribute compute, and a cost savings to end users, while maintaining the advantages of scalability and ease of use provided by cloud computing companies, as well as the ability of those who want to bring models to our marketplace to earn for their contribution.

Lilypad’s mission is to rapidly and affordably bring high-performance AI and ML capabilities to innovators worldwide, leveraging the power of decentralized compute. We are harnessing the power of open communities and crypto-incentivization to create network-effect growth, while meeting the constantly evolving AI and high performance compute landscape.

References

1. AWS Intel. Challenging the Barriers to High Performance Computing in the Cloud. October 2019. https://d1.awsstatic.com/HPC2019/Challenging-Barriers-to-HPC-in-the-cloud-Oct2019.pdf

2. Justin Garrison. The New Stack. Cloud vs. On-Prem: Comparing Long-Term Costs. November 2024. https://thenewstack.io/cloud-vs-on-prem-comparing-long-term-costs/

DeepSeek R1 on Lilypad is more than just a technical milestone—it’s a step toward making advanced, open source AI accessible to everyone, powered by a decentralized network.

Whether you’re building agent workflows, generating complex insights, or building AI-driven applications, DeepSeek R1 on Lilypad opens up a world of possibilities!

Why Choose Lilypad for DeepSeek-R1?

By running DeepSeek-R1 on Lilypad, you’re leveraging the power of decentralized compute for faster, more scalable AI workflows. With DeepSeek R1 on Lilypad, developers can scale to running large amounts of inference jobs at once, all while reducing reliance on costly centralized servers.

• Frictionless AI Access: From installation to execution, Lilypad makes it simple to deploy and manage AI models like DeepSeek R1.

• Cost-Effective Compute: Lilypad's decentralized network saves you money while delivering the speed and reliability you need.

• Developer-First Design: Whether you’re a seasoned AI engineer or just getting started, Lilypad’s tools and APIs are built to empower your workflow.

Get Started

Using the Lilypad CLI

Install the Lilypad CLI (directions below):

# Detect your machine's architecture and set it as $OSARCH
OSARCH=$(uname -m | awk '{if ($0 ~ /arm64|aarch64/) print "arm64"; else if ($0 ~ /x86_64|amd64/) print "amd64"; else print "unsupported_arch"}') && export OSARCH;
# Detect your operating system and set it as $OSNAME
OSNAME=$(uname -s | awk '{if ($1 == "Darwin") print "darwin"; else if ($1 == "Linux") print "linux"; else print "unsupported_os"}') && export OSNAME;
# Download the latest production build
curl https://api.github.com/repos/lilypad-tech/lilypad/releases/latest | grep "browser_download_url.*lilypad-$OSNAME-$OSARCH-cpu" | cut -d : -f 2,3 | tr -d \" | wget -i - -O lilypad

# Make Lilypad executable and install it
chmod +x lilypad
sudo mv lilypad /usr/local/bin/lilypad

Run the DeepSeek R1 Module (using the Lilypad DemoNet testing environment):

lilypad run --network demonet --web3-private-key b3994e7660abe5f65f729bb64163c6cd6b7d0b1a8c67881a7346e3e8c7f026f5 github.com/rhochmayr/ollama-deepseek-r1-7b:1.0.0 -i Prompt="What is the future of open-source AI"

Developer tooling for running inference jobs on Lilypad

• Build an Agent or App using the Local CLI Wrapper for Inference: Both DeepSeek modules can run with the JS-based CLI Wrapper, offering a streamlined way to integrate modules into your workflows. Although more technical overhead for developers, the local cli wrapper gives developers the option to run their own “Job Creator” api reducing reliance on a hosted API from Lilypad creating further decentralization in the AI workflow. See an example for building a front end on top of the JS CLI Wrapper here!

• Hosted API (Beta - coming soon!): For those who prefer a plug-and-play solution, our API is in beta and will be available for the community to use soon—run models effortlessly without additional setup.

Conclusion:

DeepSeek R1 on Lilypad is your gateway to running open source models with decentralized AI compute. Start building today and experience the freedom, scalability, and power of running AI on Lilypad.

Join the Lilypad Community

We’re committed to building a community of developers and innovators who want to push the boundaries of AI and decentralized compute. Join our Discord community to connect, share, and grow with others.

This isn’t just a bridge between networks — it’s an encrypted tunnel to the future. Together, we unlock programmable, verifiable, privacy-preserving AI compute at scale.

🌟 Details of Partnership - Synergistic Strengths

Lilypad provides:

• A decentralized GPU marketplace for running inference, model training, and agentic workflows

• Verifiable, modular AI-first compute layer with blockchain-coordinated payment rails and provenance

• Composable job architecture to plug into any system — agents, dApps, research pipelines, L2s

Gateway delivers:

• Encrypted compute powered by their MPC-based Shared Private State

• Programmable cryptography for developers through SDKs in Go, JavaScript, and Rust

• A full Privacy Enhancing Technologies (PETs) Marketplace including garbled circuits, proxy re-encryption, TEEs, and homomorphic encryption

Combined, we form a stack that makes confidential decentralized AI usable, scalable, and programmable.

🔧 Practical Synergies (Short-Term)

What’s possible today:

• AI models deployed on Lilypad can now run encrypted through Gateway’s Shared Private State

• PETs like proxy re-encryption and garbled circuits now plug into live GPU compute workflows

• Devs can integrate Gateway SDKs with Lilypad job endpoints to spin up fully encrypted training and inference pipelines

Use cases already underway:

• Federated healthcare AI where patient data never leaves encrypted state — powered by Gateway’s encryption and Lilypad’s GPUs

• Confidential financial model training — fraud detection and risk scoring across encrypted, multi-institution data

• Private enterprise AI — companies retain full IP privacy while accessing Lilypad’s distributed compute grid

🚀 Roadmap Collaboration (Mid-Term)

Over the next few months:

• We’ll co-launch a POC showing encrypted LLM inference on Lilypad using Gateway’s Garbled Circuit SDK

• Gateway’s PET marketplace will be integrated into Lilypad’s developer documentation and workflow guides

• Builders will get co-branded examples, tutorials, and grant support for privacy-preserving AI applications

Future milestones:

• Composable privacy primitives layered directly into Lilypad’s job architecture

• zk-like encrypted compute receipts for verifiability + confidentiality

• Gateway PET modules powering AI agents, simulations, and multi-party compute coordination

Together, we’re building the secure compute core of the decentralized AI stack.

📈 Strategic Value - Why It Matters

This is a strategic unlock for DeAI:

• Encryption + Compute = Confidential Coordination

• Gateway enables Lilypad jobs to run on sensitive data without leaking inputs, outputs, or model logic

• From healthcare to finance to agentic infrastructure, privacy is no longer a blocker — it’s now programmable

Benefits to the Web3 and OSS ecosystem:

• PETs + Compute workflows that devs can integrate without complex infra

• Launchpad for a new generation of DePIN x AI applications with built-in privacy

• Elevates Lilypad’s position from just verifiable compute to verifiable + confidential compute

For developers:

• One-click access to encrypted job execution

• Modular SDKs in the language of your choice

• Ability to deploy next-gen AI agents without exposing model logic or user data

🌍 Long-Term Vision – Infrastructure for Encrypted Autonomous Intelligence

Lilypad and Gateway are aligned in the belief that decentralized AI must be both scalable and secure.

This partnership advances:

• A Layer 0 for DeAI where encrypted state, compute liquidity, and model logic meet

• A framework for encrypted model marketplaces, agent networks, and shared inference layers

• A decentralized stack for programmable privacy, economic coordination, and agent autonomy

This sets a new precedent for ecosystem-aligned infrastructure: not just decentralized — encrypted, composable, and unstoppable.

📅 What’s Next

Immediate:

• Teams are co-building a proof-of-concept using Garbled Circuits + Lilypad compute

• Gateway SDKs now available for encrypted data vault and PET development

• Shared roadmap, dev documentation and example jobs publishing soon

Medium-term:

• PET Marketplace + Lilypad compute integrated via SDK and UI

• Partner developer campaigns to co-fund new private DeAI primitives

• Joint GTM for secure agent frameworks and confidential compute ecosystems

🔍 Explore Gateway: https://gateway.tech
🌐 Launch encrypted compute: https://lilypad.tech

This is where Lilypad Modules come in.

A Lilypad Module is a self-contained, task-specific computational unit designed specifically to run on the Lilypad network. It encapsulates everything needed to perform a specific job, such as input handling, model execution, workflow orchestration, and output generation. AI models are the backbone of most Lilypad Modules, enabling advanced computations such as natural language processing, image generation, and video synthesis. Lilypad modules leverage these models to deliver results efficiently and at scale.

Modules are structured as Git repositories, which makes them easy to manage, share and version. This structure makes sure that developers can organize their modules in a way that adheres to Lilypad’s standards while remaining flexible for customization.

So why are Lilypad Modules important? They allow users, researchers, developers and the like to add specific functionalities to the Lilypad Network, enabling access to decentralized compute resources that are capable of running AI inference jobs without requiring a high-performance GPU. Each module, tailored for specific tasks, serves as a unique building block to address the diverse needs across AI and computational workloads.

Core characteristics of a Lilypad module

Each Lilypad module orchestrates AI workflows or computations with standardized input, processing, and output pipelines. By encapsulating all dependencies, modules enable isolated, reproducible computations, making them ideal for scaling workloads, sharing within the community or even collaborating on module development.

Lilypad modules are built around several essential components that work together to ensure functionality and versatility:

1. Core Workflow Components

These elements define how a module processes jobs and delivers results:

• Input Handling: Manages data intake and preparation, adapting inputs to meet a module’s requirements.

• Task Logic: Encapsulates the computational process, including AI model execution, determining how jobs are processed.

• Output Generation: Formats and delivers results in a way that is actionable and accessible for users.

2. Operational Infrastructure

Modules require robust infrastructure to run efficiently and reliably:

• Workflow Orchestration: Coordinates data flow and computations within a module.

• Dependency Management: Specifies necessary libraries, frameworks, and runtime environments (e.g., requirements.txt or Docker).

• Module Configuration: Customizes behavior through settings defined in files like lilypad_module.json.tmpl.

3. Reliability and Scalability

To handle diverse environments and workloads, modules incorporate:

• Logging and Monitoring: Tracks performance and errors, aiding debugging and optimization.

• Error Handling: Safeguards against invalid inputs or unexpected failures with mechanisms like try-catch blocks.

• Scalability: Ensures a module runs efficiently across various environments, including GPUs, CPUs or decentralized nodes.

The most common files found in a Lilypad module include:

• Dockerfile: Defines the containerized environment for a module, specifying the runtime dependencies, such as system packages, libraries, and configurations needed to run a module on nodes on the Lilypad network.

• requirements.txt: Lists the Python dependencies required by a module, such as AI frameworks (e.g., TensorFlow, PyTorch) and utility libraries.

• lilypad_module.json.tmpl: This template file defines a module's metadata, including its name, description, required inputs, outputs and other configurations.

• Inference script: The core script (e.g., run_inference.py) that handles the execution of the AI model or task, including processing inputs, running computations and generating outputs. This is the entry point file for running modules.

• Model directory: A module must execute correctly at runtime. With the model stored in a model directory, the model is bundled within the container, making it readily accessible at runtime without requiring a separate download step.

Downloading the model

Downloading a model is an essential step to ensure it can be referenced and utilized offline at runtime. In general, this process involves retrieving both the model and its tokenizer or configuration files from a model hub or repository. The exact script used to download a model will vary depending on the type of model and the library it belongs to, such as Hugging Face Transformers or TensorFlow.

In transformers, different model classes are designed for specific tasks. AutoModelForSeq2SeqLM is used for sequence-to-sequence (Seq2Seq) models, which have both an encoder and a decoder, making them suitable for tasks like translation, summarization, and text-to-text generation (e.g., T5, BART). On the other hand, causal language models (CLMs), like Falcon and GPT, use AutoModelForCausalLM and generate text in an autoregressive manner, predicting one token at a time without an encoder. Choosing the right class ensures the model functions correctly within your AI module. The structure of the script and the methods for downloading and saving the model can differ between models and libraries, so it’s important to tailor the process to the specific requirements of the model you're working with.

In the example below, the model and tokenizer are fetched using a library-specific method, such as from_pretrained() provided by the AutoTokenizer utility, which downloads the necessary files and configurations to a local directory. This directory (/model) serves as the runtime reference for the model during execution. Once downloaded, the model and tokenizer are saved locally using save_pretrained(), guaranteeing that they are available for repeated use without needing to redownload them.

from transformers import AutoTokenizer, AutoModelForCausalLM

def download_model():
    model_name = "tiiuae/falcon-7b-instruct"

    # Load tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name)

    # Save the tokenizer and model
    tokenizer.save_pretrained('./model')
    model.save_pretrained('./model')

if __name__ == "__main__":
    download_model()

Run the script to begin the download. (Note: This may take a few minutes depending on the size of the model):

python download.py

Dependencies

The requirements.txt file defines the Python dependencies needed for a module to run. It ensures that all necessary libraries, frameworks, and tools are installed in a module’s runtime environment, enabling consistent execution across different nodes in the Lilypad network.

For example, in the Falcon-7B module we explore below, the following dependencies might be included in requirements.txt:

transformers==4.36.0
torch==2.1.0
numpy<2.0.0
accelerate==0.25.0
bitsandbytes>=0.41.1

These libraries support essential tasks such as loading models (transformers), running computations with hardware acceleration (torch) and defining configurations for generation workflows. However, the contents of requirements.txt will vary based on the specific requirements of your module. For instance:

• A module handling natural language processing (NLP) might include transformers for pre-trained models and sentencepiece for tokenization.

• A module designed for image processing could require torchvision or Pillow.

• A module for custom AI workflows might include scipy, numpy, or other task-specific libraries.

Creating the Dockerfile

The Dockerfile is a fundamental component of a Lilypad module, defining the containerized environment in which the module runs. It specifies everything needed to build and execute the module, from the base operating system to the libraries, runtime dependencies, and execution commands. This allows the module to operate consistently across diverse environments such as Lilypad.

By containerizing a module, the Dockerfile encapsulates all dependencies and configurations, eliminating compatibility issues that might arise from differences in operating systems, installed packages, or hardware. It also simplifies deployment, as nodes can pull and run the prebuilt container without additional setup.

Different modules may require different configurations, though here is an example of the Dockerfile used for the Falcon 7B module below:

# Specify architecture
FROM --platform=linux/amd64 python:3.9-slim as builder

WORKDIR /app

# Install build dependencies
RUN apt-get update && \\
    apt-get install -y --no-install-recommends \\
    build-essential \\
    && rm -rf /var/lib/apt/lists/*

# Copy and install requirements
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy installed packages from builder
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages

# Create outputs directory
RUN mkdir -p /outputs
RUN chmod 777 /outputs

# Copy the inference script
COPY run_inference.py .

# Copy the download script
COPY download_module.py .

RUN python3 download_module.py

# Set outputs directory as a volume
VOLUME /app/outputs

# Run the inference script
CMD ["python", "run_inference.py"]

Building your module

The inference script is the entry point for a Lilypad module, handling inputs, executing computations, and producing outputs. Designed for diverse environments, particularly Lilypad's infrastructure, it relies on dynamic configurations, such as environment variables for user data or model directories, to remain flexible and avoid hardcoded parameters.

While this guide demonstrates one approach to structuring a text-to-text inference script, the implementation will vary depending on your model and its requirements. Some models, like those using Hugging Face, support standard libraries, while others, such as the SDXL module, require custom initialization. For more examples and approaches, visit our module examples.

One important thing to note is that Lilypad modules operate within a controlled execution environment where network access is completely restricted. This design ensures security, reproducibility and prevents unintended data leaks or external dependencies. Since modules cannot fetch external resources or communicate over the internet, any required data must be provided as inputs at runtime.

The script’s core responsibility is to encapsulate task logic in reusable functions, processing inputs and generating outputs for tasks such as paraphrasing or image generation. This modularity allows it to adapt to various models and ensures compatibility with decentralized execution. The standard and expected output is required to be in JSON format.

Let’s examine the Falcon-7B module, which takes a text input, generates a response using a locally stored model, and saves the results in JSON format:

from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
import torch
import os
import json

def clean_response(text):
    # Find the start of Assistant's response
    assistant_start = text.find("Assistant: ")
    if assistant_start != -1:
        # Get everything after "Assistant: "
        response = text[assistant_start + len("Assistant: "):]
        # Find where the next "User: " starts (if it exists)
        user_start = response.find("\\nUser")
        if user_start != -1:
            # Only take the text up to the next "User: "
            response = response[:user_start]
        return response.strip()
    return text.strip()

def main():
    # Create outputs directory if it doesn't exist
    os.makedirs("outputs", exist_ok=True)

    # Get input from environment variable, or use default if not provided
    input_text = os.getenv("MODEL_INPUT", "Tell me a story about a giraffe.")

    local_path = "./local-falcon-7b-instruct"
    print(f"Loading model from {local_path}...")

    # Load tokenizer and model from local path
    tokenizer = AutoTokenizer.from_pretrained(local_path, local_files_only=True)
    # Set pad token to eos token if not set
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    model = AutoModelForCausalLM.from_pretrained(
        local_path,
        torch_dtype=torch.bfloat16,
        device_map="auto",  # This will use GPU if available, otherwise CPU
        local_files_only=True,
        pad_token_id=tokenizer.pad_token_id
    )

    # Get the device that the model is on
    device = model.device

    # Set up generation config
    generation_config = GenerationConfig(
        max_new_tokens=256,
        pad_token_id=tokenizer.pad_token_id,
        eos_token_id=tokenizer.eos_token_id,
        do_sample=True,
        temperature=0.7,
        top_p=0.9
    )
    model.generation_config = generation_config

    # We use the tokenizer's chat template to format each message
    messages = [
        {"role": "user", "content": input_text},  # Use the environment variable input
    ]

    input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    # Include attention mask in tokenization
    inputs = tokenizer(
        input_text, 
        return_tensors="pt",
        padding=True,
        truncation=True,
        max_length=2048,
        return_attention_mask=True
    )

    # Move input tensors to the same device as the model
    inputs = {k: v.to(device) for k, v in inputs.items()}

    outputs = model.generate(
        input_ids=inputs["input_ids"],
        attention_mask=inputs["attention_mask"]
    )
    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)

    # Clean up the response to get just the assistant's part
    clean_output = clean_response(generated_text)

    # Prepare output data
    output_data = {
        "prompt": input_text.strip(),
        "response": clean_output
    }

    print(f"Generated text: {clean_output}")
    print(f"Output data: {output_data}")

    output_path = f'/outputs/results.json'
    os.makedirs(os.path.dirname(output_path), exist_ok=True)

    # Save to JSON file
    with open(output_path, "w") as f:
        json.dump(output_data, f, indent=2)

    print(f"Results saved to {output_path}")

if __name__ == "__main__":
    main()

Testing your module locally

Once you’re happy with how your code looks for the inference script, we can build and containerize the module and start testing it by running a job.

Please note that if you’re building a module with a high-compute model, running jobs locally may fail or perform poorly if your system doesn’t have a GPU capable of handling the model's requirements. Using a GPU-enabled environment is strongly recommended for such cases.

To build the image, run the following:

docker build -t <MODULE_NAME>:<MODULE_TAG> .

Once the build has completed, to run it you will need to specify the inputs for the job, along with where the results are being stored (/outputs) and finally the module name and tag from the previous build step.

docker run -e INPUT_TEXT="Today was a good day." \\
-v $(pwd)/outputs:/outputs \\
<MODULE_NAME>:<MODULE_TAG>

If you run into any issues while testing locally, check your Docker logs. This will help you identify what part of the process is causing issues: docker logs <CONTAINER_ID>

Uploading Docker image

To make your Lilypad module accessible on the network, you'll need to upload your Docker image to a container registry, such as DockerHub.

This step is necessary because Lilypad resource providers will pull your module’s image to execute jobs. In this guide we will be using Docker Hub so please refer to the official Docker Hub guide to create your repository.

The approach for macOS differs because Mac systems typically use a different architecture (ARM64) compared to the Linux based environments (Linux/AMD64) where Lilypad modules are executed. To make the Docker image compatible with Linux resource providers, the docker buildx command is used on macOS, allowing the builder to specify the target platform using --platform linux/amd64.

For Linux: docker build -t <USERNAME>/<MODULE_NAME>:<MODULE_TAG> --push .

For macOS:

docker buildx build \\
--platform linux/amd64 \\
-t <USERNAME>/<MODULE_NAME>:<MODULE_TAG> \\
--push \\
.

Pushing your module to GitHub

The lilypad_module.json.tmpl file serves as the interface between a module and Lilypad, defining how jobs are executed and allowing users to customize inputs, outputs,and tunable parameters. This file is key to making your module functional and adaptable, because it provides the specifications needed for job execution and resource allocation. It defines the compute resources (e.g., GPU, CPU), job execution details such as the Docker image, entrypoint, and environment variables, output directories for results, resource requirements, job concurrency and timeouts.

Inputs vary from model to model, so declaring them in this file is crucial for handling user inputs for a module. The EnvironmentVariables sections centralizes all user inputs (including tunables like seeds, steps, batch size etc) and prepares them as environment variables for the containerized job environment.

Here is an example of the file for the Falcon 7B module:

{
    "machine": {
        "gpu": 1,
        "cpu": 1000,
        "ram": 8000
    },
    "job": {
        "APIVersion": "V1beta1",
        "Spec": {
            "Deal": {
                "Concurrency": 1
            },
            "Docker": {
                "Entrypoint": ["python", "/app/run_inference.py"],
                "WorkingDirectory": "/app",
                "EnvironmentVariables": [
                    {{ if .MODEL_INPUT }}"MODEL_INPUT={{ js .MODEL_INPUT }}"{{ else }}"MODEL_INPUT=Write a haiku about Lilypads"{{ end }},
                    "HF_HUB_OFFLINE=1"
                ],
                "Image": "narbs91/lilypad-falcon-7b-instruct-modulev8:latest"
            },
            "Engine": "Docker",
            "Network": {
                "Type": "None"
            },
            "Outputs": [
                {
                    "Name": "outputs",
                    "Path": "/outputs"
                }
            ],
            "PublisherSpec": {
                "Type": "ipfs"
            },
            "Resources": {
                "GPU": "1"
            },
            "Timeout": 600
        }
    }
}

Before pushing your changes to GitHub, you must change the image reference in the lilypad_module.json.tmpl file. Take note of the line in the code below for "Image": "narbs91/lilypad-falcon-7b-instruct-modulev8:latest". This points to the latest build for that image. You can specify it by using the same <USERNAME>/<MODULE_NAME>:<MODULE_TAG> structure we used when building and pushing the image.

Create a new repository and name it according to your desired module name. Push all your code to this repository. When running the module with the Lilypad CLI, you’ll need to either retrieve the commit hash or tag a specific version to use.

Testing module on Lilypad

To test your Lilypad module, you will need the following things before running the CLI command:

• Have the Lilypad CLI installed

• Module repo link (github.com/<USERNAME>/<REPO_NAME>)

• The desired commit hash (SHA) or tag

Once you have all of the above you can open your terminal and run your command. Note that your command will look different based on the inputs you’ve declared in the lilypad_module.json.tmpl file. For example, using the Falcon 7b module that was illustrated in the previous sections would look like:

lilypad run --network <NETWORK> github.com/<USERNAME>/<REPO_NAME>:<SHA_OR_TAG> --web3-private-key <PK> -i <INPUT_NAME>='<INPUT>'

lilypad run --network demonet github.com/narbs91/lilypad-falcon-7b-instruct-module:v1.8.0 --web3-private-key b3994e7660abe5f65f729bb64163c6cd6b7d0b1a8c67881a7346e3e8c7f026f5 -i MODEL_INPUT='Write me a haiku about Lilypads'

When running a Module on DemoNet, if the job run appears to be stuck after a few minutes (sometimes it takes time for a Module to download to the RP node), cancel the job and try again. Open a ticket in the Lilypad Discord with any issues that persist.

If your module is configured correctly, you should be able to run a job successfully! The CLI will return results and store them in a directory inside of your /tmp/lilypad/data/downloaded-files/.

Conclusion and next steps

Lilypad modules serve as the foundation for enabling decentralized AI workloads, providing a standardized yet flexible framework for running diverse computational tasks on the Lilypad network. By encapsulating input handling, task logic, and output generation into self-contained units, these modules empower developers, researchers and resource providers to contribute to a scalable and collaborative ecosystem.

As next steps, explore creating modules tailored to your specific AI tasks or computational workloads. Follow best practices for optimization, such as efficient dependency management, logging and error handling. You can also contribute to the growing Lilypad ecosystem by sharing your module, collaborating with the community and refining it based on real-world use cases.

Resources

• Lilypad module builder docs

• awesome-lilypad modules - A collection of modules available on Lilypad

• Falcon 7B Lilypad module code - The module used as an example in this guide

Help us improve! We’d love to hear about your experiences building modules. Please start a new discussion here and provide as much information as possible! Any feedback is very much appreciated.

Introducing the Lilypad Builder-verse

Today, we’re launching the Lilypad Builder-verse, a hub for developers, labs, and businesses to access with guides, workshops, and live streams centered around deploying LLM workflows! This includes creating containerized LLM programs as Lilypad (Modules) and using Lilypad Modules within LLM workflows like Agent pipelines! Community members can earn rewards for building on the network and growing the popularity of their projects.

Learn more in the docs about Lilypad Modules and MLops tooling provided to run inference on the network!

The Builder-verse & IncentiveNet Stage 2

As the second stage of IncentiveNet, the Builder-verse provides an opportunity to earn Lilybit rewards just by building on the network!

• Build and submit a Module to the Lilypad Module Marketplace.

• Build Agents and applications that use Lilypad Modules to scale parallel inference.

• Promote your work to the community!

The more usage your module or Agent gets from the ecosystem, the more rewards you earned! Check out the leaderboard to see the rewards community in action!

Join us each week for Builders Live, where we’ll host:

• Community demos of Lilypad Modules and LLM workflows (come demo your project!)

• Workshops on “How to Run LLMs on Lilypad with a Module,” “How to Build an Agent Workflow on Lilypad,” and more

Looking for inspiration? Our team put together a Request for Modules based on community input, plus a guide for Building a Front End on Lilypad!

Stay tuned for a full Module creation guide and an Agent cookbook with templates and best practices for deploying Agent workflows on Lilypad. For inspiration, check out the Agent projects we are working on with partners and will be deploying to Lilypad in production soon!

• Lilypad Support Agent

• AI Oncologist Research Agent

Build and Earn!

Our Module Creator Leaderboard launched recently, and we’re eager to see new submissions! Anyone who creates a working Module, Agent workflow, or Integration will be rewarded in Lilybits. Generate a lot of usage? Earn bonus Lilybits based on the demand your work creates!

To submit a Module or Agent workflow for rewards, follow the directions in this guide!

What’s a Lilypad Module?

A Lilypad Module is a Git repository that uses predefined templates and inputs to perform various tasks on the Lilypad Network. Once created, a Module can be called by any builder simply by using the Lilypad Inference API, CLI or other MLops tooling (hosted API endpoint coming soon!).

• Accelerate Open Source AI: Once a Module is built, anyone can build an Agent or application running that Module on Lilypad with instant load balancing and blockchain-verified compute jobs.

• Instant Deployment: Containerize your LLM in a Docker-based Lilypad module, and anyone on the network can call it in an Agent workflow or an application.

• Scalable Infrastructure: Tap into Lilypad’s inference network, where workloads are balanced automatically.

• Accessible Tooling: Use the Lilypad CLI and other developer resources (hosted API coming soon!) to streamline your AI deployments.

What can I build on Lilypad?

Once a Module is live on Lilypad, developers can build and deploy Agent workflows and LLM based applications easily! This unique offering allows developers to skip the tedious and costly process of deploying LLMs to infrastructure and load balancing the processes. Just choose a Lilypad module to run, then use our MLops tooling your apps backend.

Lilypad specializes at supporting large scale parallel processing for LLM workflows within a serverless-style environment. Lilypad is currently in Testnet and in order to support parallel processing at scale, our team is carefully scaling up the GPU supply on the network.

Check out the awesome-Lilypad repo for examples like the ML workbench, WaterLily.AI, and more!
We’re also collaborating with amazing partners on Agent workflows for market research, protein folding, and more stay tuned!

What about rewards for Resource Providers?

The Lilypad IncentiveNet (Testnet) continues with Rewards opportunities for both Builders and Resource Providers (GPUs)! For the RP community, our team has been hard at work re-architecting the IncentiveNet rewards system to align with Mainnet and will launch a RP beta program as soon as possible.

The RP Beta program will employ a verification system with our team vetting nodes that would like to join the network to ensure they can reliably run jobs when online. This involves many factors including meeting the hardware + internet speed requirements, keeping the node up to date, ensuring the full resources of the node are available to run jobs, etc. The proces will ensure high service quality for end users of the network!

Sign up for the RP Beta program here and stay tuned in the updates-RP discord channel for announcements on the next steps.

Stay Connected 🌐

We can’t wait to see what you build in the Lilypad Builder-verse! For more more details, check out our high level roadmap can be found on the Lilypad website.

Join the Lilypad Discord and follow us on socials to stay up to date with the action!

• Discord

• Twitter/X

• GitHub