DataChain

This project is a revolutionary decentralized data annotation platform that fundamentally reimagines how artificial intelligence training data is created, verified, and compensated. At its core, it addresses one of the most critical bottlenecks in modern AI development: the need for high-quality labeled data. Today, companies like Scale AI, Labelbox, and Amazon Mechanical Turk dominate this market, operating as centralized intermediaries that connect clients who need data labeled with a global workforce of annotators who perform the labeling work. However, these platforms extract significant fees, control payment systems, own annotator reputations, and provide little transparency into how data is handled. This project creates an alternative model—a decentralized protocol where clients, annotators, and AI services interact directly through smart contracts and autonomous agents, without a controlling intermediary taking a cut or dictating terms. The platform is built on three foundational technologies that work in concert to create a trust-minimized ecosystem. First, Hedera Hashgraph serves as the underlying blockchain infrastructure, chosen specifically for its exceptional performance characteristics: it can process over 10,000 transactions per second with finality in just 3-5 seconds, and each transaction costs only about $0.0001. This makes it economically viable to record every single micro-event in the annotation process—from task assignments to individual label submissions to quality reviews—creating an immutable audit trail that anyone can verify. Second, the Artificial Superintelligence (ASI) Alliance, which combines Fetch.ai's autonomous agent technology with SingularityNET's AI marketplace, provides the intelligence layer that automates workflows, performs quality checks using AI models, and manages complex multi-step processes without human intervention. Third, Lit Protocol replaces traditional centralized payment and access control systems with cryptographic guarantees, using Programmable Key Pairs (PKPs) and Lit Actions to enable conditional payments that execute automatically when predefined criteria are met, without requiring trust in any single party. The way the platform works in practice can be understood through a typical workflow scenario. Imagine a medical imaging company needs 10,000 X-ray images labeled with bounding boxes around abnormalities for training a diagnostic AI. The client creates a project by deploying a smart contract on Hedera that holds their payment in escrow—let's say 50,000 ASI tokens. They define their quality requirements: each image must be labeled by an annotator with a reputation score above 75, and 10% of submissions must be reviewed by a second annotator for quality control. All of these rules are encoded in smart contracts and Lit Actions, making them transparent and programmatically enforceable. Meanwhile, annotators on the platform have been building their reputation scores through past work, with every completed task, accuracy metric, and peer review recorded permanently on Hedera's Consensus Service. When this new project goes live, a Task Assignment Agent—an autonomous software agent built with Fetch.ai's uAgent framework—automatically queries the on-chain reputation contract, identifies qualified annotators, and assigns tasks to them based on their expertise, availability, and historical performance in medical imaging tasks. An annotator receives a task notification and opens the annotation interface, which provides professional-grade tools like polygon drawing, keypoint placement, and zoom/pan controls. They may also receive AI assistance—before they even start labeling, a pre-annotation agent may have already called an object detection model from SingularityNET's marketplace to generate suggested bounding boxes, which the annotator can then verify and refine. This "human-in-the-loop" approach dramatically speeds up the process while maintaining high quality. When the annotator submits their work, the submission is immediately recorded on Hedera's Consensus Service as an immutable message containing metadata like the task ID, annotator ID, submission timestamp, and an IPFS hash pointing to the actual annotation data stored off-chain. This HCS message serves as both a permanent record and an event trigger for the next stage of the workflow. A Quality Assurance Agent, which has been continuously monitoring the HCS topic for new submissions, detects this new annotation. Based on the project's rules, it determines that this particular annotator has a reputation score of 82, which is above the threshold, but the task has been randomly selected for the 10% quality review sample. The QA Agent automatically assigns the task to a peer reviewer with an even higher reputation score. The reviewer examines the work, makes a determination, and submits their review—which again is recorded to HCS. If the review is positive, a "REVIEW_APPROVED" message is published to the HCS reviews topic. This is where Lit Protocol's innovation becomes critical. Instead of requiring the client to manually authorize payment or trusting a centralized platform to handle disbursement, the client had previously minted a Programmable Key Pair (PKP) through Lit Protocol and defined a Lit Action—a JavaScript function that encodes the payment rules. This Lit Action specifies: "If a message appears on the HCS reviews topic with status 'APPROVED' for a given task, then sign a transaction to transfer the payment amount from the escrow contract to the annotator's wallet." When the Payment Agent detects the review approval on HCS, it calls this Lit Action. The Lit Protocol network—a decentralized network of nodes using threshold cryptography—collectively evaluates the conditions, verifies that the HCS message indeed shows approval, and if the conditions are met, the PKP cryptographically signs a transaction to release funds. This signed transaction is then submitted to Hedera, transferring ASI tokens from the project escrow directly to the annotator's wallet. The entire process happens in seconds, and the annotator receives payment in near real-time for their completed and verified work. Critically, at no point did the client have to trust a centralized payment processor, and at no point did the Payment Agent have unrestricted access to the escrow funds—the PKP only signs transactions when cryptographic conditions defined by the Lit Action are satisfied. Every step of this process—task creation, assignment, submission, review, approval, and payment—is recorded on Hedera's immutable ledger, creating a complete, verifiable audit trail. The reputation system is one of the platform's most powerful features and represents a fundamental shift in how data labor is valued. In traditional platforms, if an annotator works for Scale AI and builds a strong reputation with thousands of accurately completed tasks, that reputation is trapped within Scale AI's database. If they want to work on Labelbox or any other platform, they start from zero. This creates vendor lock-in and gives platforms enormous power over workers. In this decentralized system, reputation is recorded on-chain via Hedera's Consensus Service and calculated by a smart contract. Every time an annotation is submitted and verified, every time a peer review is completed, every accuracy metric is permanently added to the annotator's on-chain history. The Reputation Contract reads this history and calculates a weighted score based on factors like accuracy rate (40% weight), total tasks completed (30% weight), peer review feedback (20% weight), and stake amount (10% weight). This score is tied to the annotator's cryptographic wallet address, making it globally portable. An annotator can take their reputation score to any other platform that integrates with Hedera, or even display it on their professional profile as a verifiable credential. High-reputation annotators gain access to higher-paying projects, and clients can filter for annotators by expertise domain and score, ensuring quality work. The integration with SingularityNET's AI marketplace creates a sophisticated feedback loop that continuously improves both the annotation process and the AI models being trained. SingularityNET is a decentralized marketplace where AI developers publish their models as services that can be called via API. The platform leverages this in multiple ways. For pre-annotation, an agent can send a batch of unlabeled images to a SingularityNET object detection model, receive bounding box predictions, and present these to human annotators as starting points rather than requiring manual labeling from scratch. For quality control, a QA Agent can send completed annotations to a classification model that checks for consistency—for example, verifying that all labels in a medical imaging project use the correct anatomical terminology. For anomaly detection, the agent can use an outlier detection model to flag annotations that are statistically unusual, which might indicate errors or malicious behavior. In an advanced implementation, the platform could even automate the entire data-to-model pipeline: once a project accumulates enough verified annotations, a Training Agent could package the labeled dataset, call a model training service on SingularityNET, train a custom model for that specific domain, and then deploy that model back into the platform for pre-annotation on future similar projects. This creates a self-improving ecosystem where the act of annotation directly fuels the creation of better AI tools. The dispute resolution mechanism addresses one of the most contentious aspects of data annotation work: disagreements over quality and payment. In centralized platforms, if an annotator's work is rejected, they often have no recourse—the platform's decision is final, and there's no transparent process. This decentralized system implements an on-chain arbitration protocol. If an annotator believes a negative review was unfair, they can trigger a dispute by calling a function on the Dispute Resolution Contract. This contract immediately locks the disputed payment in escrow and initiates a jury selection process. High-reputation community members who have staked ASI tokens can serve as jurors. The contract randomly selects a panel—say, five jurors—and presents them with the original task requirements, the annotator's submission, the reviewer's assessment, and both parties' arguments. Each juror votes, and their votes are recorded on-chain. The majority decision is binding and automatically executed by the smart contract: if the jury sides with the annotator, the payment is released to them and the reviewer's reputation is adjusted downward; if the jury sides with the reviewer, the payment is released to the project refund pool and the annotator's reputation is adjusted. Jurors who vote with the majority receive a small reward from their staked tokens, while those who vote with the minority may have a portion of their stake slashed, creating economic incentives for honest, careful evaluation. The economic model of the platform is designed to create a sustainable, circular economy powered by the ASI token. The ASI token is the native utility token of the Artificial Superintelligence Alliance, resulting from a merger between Fetch.ai's FET token and SingularityNET's AGIX token. Every transaction on the platform is denominated in ASI: clients pay for annotation services in ASI, annotators receive compensation in ASI, reviewers earn fees in ASI, AI models on SingularityNET are paid in ASI, and even dispute resolution jurors receive rewards in ASI. The token also serves a staking function—annotators and reviewers who want to access higher-tier projects must stake a minimum amount of ASI as a security deposit, which can be slashed if they're found to have submitted fraudulent work or acted maliciously. This staking mechanism aligns incentives: participants with "skin in the game" are economically motivated to maintain high quality. In the future, ASI token holders will also participate in governance, voting on protocol upgrades like changes to the reputation algorithm, fee structures, the introduction of new annotation types, or the parameters of the dispute resolution system. The platform's technical architecture is specifically designed to minimize reliance on centralized infrastructure and maximize verifiability. Data storage uses a hybrid approach: large files like images, videos, and raw datasets are stored on decentralized networks like IPFS (InterPlanetary File System) or Filecoin, with only the content-addressed hash (a unique cryptographic fingerprint of the file) stored on-chain. This keeps blockchain storage costs low while maintaining data integrity—if even one bit of the file changes, the hash changes, so any tampering is immediately detectable. Smart contracts on Hedera are written in Solidity, the same language used by Ethereum, making them familiar to a large developer community. These contracts handle core logic like escrow management, reputation calculation, and dispute resolution. The Hedera Consensus Service (HCS) functions as a decentralized message queue and event log, replacing centralized systems like RabbitMQ or Kafka. The autonomous agents built with Fetch.ai's uAgent framework are stateless, horizontally scalable services that can be deployed on any cloud infrastructure or even run by community members, eliminating single points of failure. The choice of Hedera Hashgraph over other blockchains is deliberate and critical to the platform's viability. Most blockchains like Ethereum have high transaction costs (often several dollars per transaction) and limited throughput (15-30 transactions per second for Ethereum), making them unsuitable for an application that needs to record millions of micro-events. Even Layer 2 solutions, while cheaper, introduce additional complexity and potential points of failure. Hedera's hashgraph consensus algorithm achieves asynchronous Byzantine Fault Tolerance (aBFT), which is mathematically proven to be the highest possible level of security for a distributed system. It processes transactions with predictable finality in 3-5 seconds, meaning once a transaction is confirmed, it cannot be reversed—there are no blockchain reorganizations or probabilistic finality concerns. The network's governance model, overseen by a council of 32 globally recognized organizations including Google, IBM, Boeing, Deutsche Telekom, and major universities, provides institutional credibility and long-term stability that crypto-native projects often lack. For an enterprise client considering whether to trust their sensitive medical imaging data or financial documents to this platform, Hedera's enterprise-grade governance and security model provides essential confidence. The integration with Lit Protocol represents a philosophical shift from "trust but verify" to "don't trust, cryptographically enforce." In traditional systems, even decentralized ones, there's often a need to trust that an off-chain payment processor or oracle is behaving honestly. Lit Protocol eliminates this trust assumption through threshold cryptography. When a client mints a PKP (Programmable Key Pair), they're creating a wallet address that isn't controlled by any single private key—instead, it's controlled by a distributed network of Lit nodes. To sign a transaction, a threshold number of these nodes (say, two-thirds) must collectively agree that the conditions specified in the Lit Action have been met. The Lit Action itself is a JavaScript function that can read blockchain state (like Hedera's Consensus Service messages), call external APIs (like checking a reputation score), and perform arbitrary logic. Only if all conditions evaluate to true will the Lit network sign the transaction. This means a client can encode arbitrarily complex payment rules—"pay the annotator only if their work was approved by two reviewers AND their reputation score is above 70 AND the submission was made before the deadline"—and have mathematical certainty that payment will only occur if those conditions are satisfied, without trusting any single entity. The platform's go-to-market strategy targets specific niches where its unique advantages provide maximum value. Medical imaging AI is a prime target: hospitals and research institutions training diagnostic models need absolute certainty about data provenance and handling due to HIPAA regulations and liability concerns. The immutable audit trail provided by Hedera's Consensus Service, combined with Lit Protocol's access controls (which can gate dataset access based on compliance credentials stored on-chain), makes this platform uniquely suited to regulated industries. Autonomous vehicle development is another target vertical—when a self-driving car makes a decision that leads to an accident, the ability to trace back through an immutable ledger to see exactly how the training data was labeled, by whom, with what quality scores, and under what review process becomes legally crucial. Web3-native projects building decentralized AI applications are natural early adopters since they already operate in cryptocurrency and understand the value proposition of decentralized infrastructure. The platform can bootstrap network effects by partnering with these projects, creating a circular economy where Web3 AI projects pay for annotation services using crypto, and annotators earn crypto they can spend within the broader Web3 ecosystem. The long-term vision extends beyond being merely a better annotation tool to becoming fundamental infrastructure for the decentralized AI economy. As datasets become tokenized as NFTs on Hedera Token Service, with ownership, provenance, and access rights clearly established on-chain, a secondary market for training data emerges. A research team that spent months carefully curating and annotating a specialized medical imaging dataset can mint it as an NFT and sell or license access to pharmaceutical companies or hospital networks, with Lit Protocol enforcing access controls and royalty payments. AI models trained on these datasets can be published to SingularityNET with cryptographic proof of their training data provenance, allowing users to verify the quality and ethical sourcing of the data behind the model. Annotators with strong reputations can stake their reputation to vouch for new annotators, creating a web-of-trust reputation system. The entire ecosystem becomes a decentralized, autonomous market for the production, verification, and exchange of the fundamental resource that powers artificial intelligence: high-quality labeled data. The social impact dimension is equally important. The global data annotation workforce, estimated at over 5 million people and growing rapidly, is largely based in developing economies and faces issues like payment delays, arbitrary account suspensions, non-transparent quality rejections, and platform fees that can take 30-50% of project budgets. By disintermediating the centralized platform, this protocol can dramatically increase annotator earnings—that 30-50% platform fee is eliminated, going directly to the workers instead. Near-instant micropayments improve cash flow for workers who often operate on thin margins. Portable, verifiable reputation gives workers leverage and dignity, transforming them from interchangeable, anonymous "crowd workers" into skilled professionals with provable track records. The transparent, on-chain dispute resolution system provides due process that's currently lacking. The programmable nature of Lit Actions even enables creative compensation models like streaming payments (getting paid continuously as you work rather than in batches) or performance bonuses (automatically receiving extra payment if your accuracy on a batch exceeds 95%). This represents a more equitable model of AI development, where the humans doing the essential but often invisible work of training AI systems receive fair compensation, recognition, and agency. From a technical innovation perspective, this project represents one of the most sophisticated integrations of multiple decentralized technologies to date. The orchestration of Hedera for ledger operations, Fetch.ai for autonomous agents, SingularityNET for AI services, and Lit Protocol for conditional execution creates an architecture where the blockchain actively orchestrates the AI layer, and AI services actively optimize the blockchain interactions. An autonomous agent subscribing to HCS topics and triggering Lit Actions based on consensus-stamped events creates a fully decentralized, reactive system with no centralized orchestration server. The composability of these technologies—where agents can dynamically call different AI services from the marketplace based on performance metrics, or where payment rules can be updated by governance votes—enables a level of adaptability impossible in monolithic centralized platforms. This becomes a protocol, not a platform: anyone can build their own frontend interface, deploy their own specialized agents, or integrate their own AI models, all interacting with the same underlying decentralized infrastructure according to shared, transparent rules. In summary, this project is building a complete economic operating system for data annotation work, implemented as a decentralized protocol that replaces centralized intermediaries with smart contracts, autonomous agents, and cryptographic guarantees. It solves real problems facing both the supply side (annotators lack portable reputation, face payment delays and arbitrary decisions) and demand side (clients lack transparency into data handling and quality assurance) of the annotation market. It leverages Hedera's performance to make blockchain-based micropayments economically viable, uses ASI Alliance's autonomous agents to automate complex workflows without central control, and employs Lit Protocol to provide trustless conditional execution of payments and access controls. The result is a more efficient, transparent, fair, and scalable system for creating the labeled training data that powers the AI revolution.

Building this decentralized data annotation platform required orchestrating multiple cutting-edge technologies into a cohesive system where blockchain, autonomous agents, AI services, and cryptographic execution engines work in concert. The architecture follows a layered approach with clear separation of concerns: Hedera Hashgraph handles the ledger and consensus layer, the ASI Alliance (Fetch.ai and SingularityNET) manages the intelligence and automation layer, and Lit Protocol provides the trustless execution and access control layer. Each technology was chosen not just for its individual capabilities but for how it complements and integrates with the others. The foundation starts with Hedera Hashgraph, which we integrated using the official Hedera SDK available in JavaScript, Python, and Java. For the JavaScript frontend and Node.js backend services, we used the @hashgraph/sdk package to interact with Hedera's services. The Hedera Consensus Service (HCS) became our decentralized event backbone—we created five separate topic IDs for different event streams: project lifecycle events, annotator screening results, task assignments, task completions, and payment records. Each topic acts like a specialized message queue. When an annotator submits work, our application constructs a JSON message containing the annotator ID, task ID, timestamp, and IPFS content hash of the annotation data, then submits it to the appropriate HCS topic using TopicMessageSubmitTransaction. The beauty of HCS is that it provides cryptographic ordering and consensus timestamps for every message, creating an immutable log that serves as ground truth for the entire system. To read from these HCS topics, we integrated with Hedera Mirror Nodes, which are REST API servers that index and serve the transaction history of the Hedera network. We built a message polling service using the Mirror Node REST API endpoint /api/v1/topics/{topicId}/messages with query parameters for pagination and filtering. This service continuously polls for new messages, deserializes them from base64 encoding, parses the JSON payload, and emits events to our autonomous agent layer. One particularly hacky but effective solution we implemented was creating a local caching layer using Redis to track which HCS messages we've already processed—since Mirror Node queries can sometimes return duplicate messages during network reorgs or high load, the cache acts as an idempotency filter ensuring each message triggers downstream logic exactly once. For payments and tokenization, we leveraged Hedera Token Service (HTS) to create and manage the ASI token representation on Hedera. While ASI exists on multiple chains, we needed a Hedera-native version for our micropayment flows. Using the TokenCreateTransaction API, we minted a fungible token with appropriate supply and treasury configurations. Every payment operation—whether escrow deposits from clients or micropayments to annotators—is executed using TransferTransaction with the token ID parameter. The transaction costs on Hedera are remarkably low (typically $0.0001 per transaction), making it economically viable to pay annotators per individual task rather than batching payments weekly or monthly. We implemented a payment agent that listens for review approval events on HCS and triggers near-instant ASI transfers, dramatically improving annotator cash flow compared to traditional platforms. The smart contract layer is implemented in Solidity and deployed on Hedera's EVM-compatible environment. We wrote three core contracts: the Project Contract for escrow management, the Reputation Contract for calculating and storing on-chain reputation scores, and the Dispute Resolution Contract for arbitration. Deploying Solidity to Hedera required some adaptation—while Hedera supports EVM bytecode, certain opcodes behave slightly differently, and we had to be mindful of gas optimization since Hedera charges in HBAR rather than traditional gas units. We used Hardhat as our development framework with a custom Hedera provider configuration pointing to testnet initially, then mainnet for production. One notable challenge was handling the mapping between Hedera's native account ID format (like 0.0.123456) and EVM-style addresses (0x...). We built converter utilities that translate between these formats since our smart contracts operate on EVM addresses while HCS messages often reference Hedera account IDs. The reputation calculation algorithm in our smart contract was particularly interesting to implement. We wanted a weighted scoring system that considers accuracy rate (40%), total tasks completed (30%), peer review scores (20%), and stake amount (10%). The challenge was that smart contracts can't natively read HCS messages—HCS is a separate service from the smart contract runtime. Our solution was to build an oracle pattern: a trusted off-chain agent (more on this later) subscribes to HCS topics, aggregates reputation-relevant events (task completions, reviews, accuracy metrics), and periodically calls the updateReputationScore(address annotator, uint256 newScore) function on the Reputation Contract. This function is permissioned—only whitelisted agent addresses can call it—and it updates the on-chain score that other contracts and agents query. We emit events from these updates so the entire history of reputation changes is auditable on the Hedera ledger. The intelligence layer leverages Fetch.ai's uAgents framework, which we found to be an elegant solution for building autonomous, goal-oriented agents. The uAgents library is Python-based, and we built five specialized agents: Screening Agent, Task Manager Agent, Task Assignment Agent, Quality Assurance Agent, and Payment Agent. Each agent is a Python class inheriting from the Agent base class provided by the uagents package. Agents communicate using a peer-to-peer protocol where each agent has a unique address and can send messages to other agents or subscribe to external event sources. The particularly powerful feature is the agent's ability to maintain state across invocations—we used this to build stateful annotator agents that remember user preferences, track personal statistics, and learn optimal task selection strategies over time. The Screening Agent was our most AI-intensive component. When a new annotator applies to work on a medical imaging project, they need to prove domain expertise. We integrated OpenAI's GPT-4 API to dynamically generate domain-specific screening questions. The agent sends a prompt like "Generate 10 multiple-choice questions to test expertise in identifying lung nodules in CT scans, with varying difficulty levels from basic anatomy to advanced pathology recognition." GPT-4 returns structured questions, which we present to the annotator. Their answers are sent back to GPT-4 with the prompt "Evaluate these answers and provide a score from 0-100 with justification." The resulting score and assessment are published to the HCS screening topic, creating a permanent record of the annotator's qualification. This AI-powered screening dramatically improves quality control compared to static quizzes that annotators can memorize or share. The Task Manager Agent uses the Hedera Agent Kit, a specialized library that provides natural language interfaces to blockchain operations. We integrated LangChain to create a conversational interface where clients can describe projects in plain English. A client might say "Create a medical imaging project with 1000 chest X-rays that need lung nodule detection, paying 5 ASI per task, requiring annotators with reputation above 80." The agent parses this using LangChain's structured output parsing, extracts the parameters (dataset size, task type, payment amount, reputation threshold), deploys a new Project Contract to Hedera using the Hedera SDK, funds the escrow with ASI tokens, and publishes project metadata to the appropriate HCS topic. The entire project setup that might take 20 minutes of manual form-filling happens in seconds through natural language interaction. The Task Assignment Agent implements an event-driven architecture that's one of the most technically sophisticated parts of the system. It maintains a WebSocket connection to our HCS polling service, receiving real-time notifications when new tasks are published or annotator availability changes. When a new task appears, the agent queries the Reputation Contract (via a Hedera smart contract call) to get a list of all annotators with scores above the project's threshold. It then checks availability by querying each annotator's agent (peer-to-peer message asking "are you available?"), considers their specialization (tracked in an off-chain database indexed by wallet address), and assigns the task to the optimal candidate. The assignment is published to HCS, and the annotator's agent receives a notification. This all happens in under 5 seconds from task creation to assignment notification—effectively real-time task distribution with on-chain provenance. The Quality Assurance Agent integrates with SingularityNET's AI marketplace in a particularly innovative way. SingularityNET provides a registry of AI services accessible via GRPC or REST APIs. When an annotation is submitted, the QA Agent can optionally send it to a SingularityNET model for automated quality scoring before or in addition to human review. For image annotations, we integrated with a semantic segmentation model that checks if bounding boxes align with actual object boundaries. For text annotations, we used a named entity recognition model to verify consistency of entity labels. The integration required handling SingularityNET's payment protocol (paying in AGI tokens, now merged into ASI) and their authentication system. We built a thin wrapper service that maintains a funded AGI balance, handles authentication, and provides a simplified async/await interface for our agents to call AI services. One hacky optimization we implemented: we batch multiple annotations into a single SingularityNET request when possible, significantly reducing API overhead and costs. The Lit Protocol integration was perhaps the most novel and challenging component. Lit Protocol's documentation is still evolving, and integrating threshold cryptography with Hedera's account model required some creative solutions. We used the @lit-protocol/lit-node-client package to interact with Lit's Cayenne testnet (their production-grade test environment). The first step was minting PKPs (Programmable Key Pairs) for each project. When a client creates a project, we call litNodeClient.mintWithAuth() which uses their authentication method (we support both wallet signatures and WebAuthn) to mint a PKP. The PKP has an Ethereum-style address, but Hedera also accepts ECDSA signatures, so the PKP can sign Hedera transactions—this cross-chain compatibility was crucial. Writing Lit Actions (the JavaScript code that controls PKPs) required understanding their execution environment. Lit Actions run in a sandboxed JavaScript runtime across Lit's decentralized node network. The challenge was that Lit Actions can't directly import Node.js packages—they need to use browser-compatible code. To read Hedera HCS messages, we had to make fetch requests to the Mirror Node REST API from within the Lit Action, which works because fetch is available in the browser environment. Our Lit Action looks something like this: it fetches the latest message from the HCS reviews topic, parses the JSON to check if the status is "APPROVED" and the task ID matches, and if so, constructs a Hedera transaction object and signs it using the PKP's private key shares (which never exist in full in any one location—threshold signature magic). We store these Lit Actions on IPFS and reference them by IPFS hash when executing, ensuring the code itself is immutable and verifiable. The Payment Agent orchestrates the Lit Protocol payment flow. It subscribes to HCS review topics, and when an approval message appears, it calls litNodeClient.executeJs() with the IPFS hash of the payment Lit Action and parameters like task ID, annotator address, and payment amount. The Lit network nodes collectively execute the Lit Action, evaluate the conditions, and if satisfied, each node generates a signature share. These shares are combined using threshold cryptography into a full signature that's valid for the PKP. The Payment Agent then takes this signature and submits the signed transaction to Hedera using the standard SDK. The entire process—from review approval to funds transferred—typically completes in 8-12 seconds. One particularly hacky solution we implemented: since Lit Actions have a 30-second timeout, and sometimes Mirror Node API can be slow, we implemented a caching proxy that pre-fetches recent HCS messages so the Lit Action can query our fast cache rather than the Mirror Node directly. For access control, we leveraged Lit Protocol's Access Control Conditions (ACCs) to gate dataset access based on on-chain reputation. When a client uploads a dataset, we encrypt the IPFS hash using Lit's encryption function with conditions like "reputation score >= 75." The encrypted hash is stored on-chain in the Project Contract. When an annotator wants to access the dataset, they request decryption through the Lit Protocol. Lit nodes check the Hedera Reputation Contract by calling a smart contract read function, verify the annotator's score meets the threshold, and only then do they collectively decrypt the IPFS hash. The annotator's client receives the hash and can fetch the dataset from IPFS. This creates cryptographically enforced access control without any centralized gatekeeper—the rules are encoded in the ACC, verified on-chain, and enforced by threshold cryptography. The frontend was built using React with TypeScript, using Tailwind CSS for styling and Recharts for data visualization. We integrated WalletConnect and MetaMask for wallet connections, with a custom adapter to support Hedera wallet formats like HashPack and Blade. One UX challenge was onboarding non-crypto users—requiring users to install a wallet extension, create an account, and fund it with HBAR is a significant barrier. Our solution was integrating with a social login provider (Magic.link) that generates a wallet in the background when users sign in with Google or email. We then partnered with a fiat on-ramp (Moonpay) so users can buy HBAR and ASI with credit cards directly in our interface. For the annotation interface itself, we built custom React components using Canvas API for image annotation (bounding boxes, polygons, keypoints) with smooth zoom/pan using react-zoom-pan-pinch library and hotkey support via react-hotkeys-hook. The off-chain infrastructure runs on AWS, though we designed it to be cloud-agnostic. The HCS polling service runs as a containerized ECS task with autoscaling based on the number of active projects. The autonomous agents run as separate Lambda functions triggered by EventBridge schedules or SQS messages. We use DynamoDB for storing application state that doesn't need to be on-chain (user preferences, UI configurations, cached API responses) and S3 for temporary storage of large annotation files before they're pinned to IPFS via Pinata's API. One architectural decision we debated was whether to run agents as always-on services or serverless functions—we chose serverless for cost efficiency since many agents only need to react to occasional events, but we kept the Task Assignment Agent as an always-on service because it needs to maintain WebSocket connections and sub-second response times. For IPFS integration, we used Pinata as our pinning service rather than running our own IPFS nodes. When an annotator uploads their work, it's sent to our backend API which uploads to Pinata, receives back the IPFS CID (content identifier), and that CID is what gets published to HCS. We implemented a verification mechanism where before accepting an annotation submission, we fetch the IPFS content and compute its hash locally to ensure it matches the CID—this prevents annotators from claiming they submitted work but actually providing invalid or empty files. For dataset storage, we support both IPFS and traditional cloud storage (S3, Google Cloud Storage), with the storage location specified in the project metadata. Filecoin integration for archival storage is on our roadmap but not yet implemented. Testing this distributed system was a significant challenge. We built a comprehensive test suite using Jest for unit tests, but integration testing required spinning up mock services. We created a local Hedera testnet using Hedera's solo Docker image, which runs a single-node network for development. For Lit Protocol, we used their testnet but also built mock implementations of the Lit client that simulate threshold signature generation without actual network calls, allowing us to test the payment flow logic in isolation. For the autonomous agents, we built a testing framework that injects mock HCS messages and asserts on the resulting agent actions. One particularly useful testing tool we built was an HCS message replayer—it can capture a sequence of real testnet HCS messages and replay them against a local development environment, allowing us to reproduce and debug complex multi-agent interaction scenarios. Security was paramount given we're handling financial transactions. All agent-to-smart-contract interactions require signed transactions, with private keys stored in AWS Secrets Manager and accessed via IAM roles. The oracle pattern where agents update the Reputation Contract uses a whitelisting mechanism—only specific agent addresses pre-authorized by the contract deployer can submit reputation updates. We implemented rate limiting on all API endpoints to prevent denial-of-service attacks. The Lit Actions are stored on IPFS, making them immutable once deployed—clients can verify the IPFS hash matches the expected code before trusting the payment logic. We conducted extensive testing of edge cases like what happens if an HCS message is malformed, if a Lit Action times out, if an agent crashes mid-transaction—building in automatic retry logic with exponential backoff and dead-letter queues for failed operations. One particularly notable hack was solving the "cold start" problem for new annotators. In a reputation-based system, how do new users with zero reputation get their first tasks? We implemented a bootstrapping mechanism using staking: new annotators can stake ASI tokens (like a security deposit) which temporarily boosts their reputation score, allowing them to access entry-level tasks. As they complete work successfully, their organic reputation grows and eventually exceeds their stake bonus, at which point they can unstake their tokens. This stake is also at risk—if they submit fraudulent work, part of the stake gets slashed. The slashing logic is implemented in a smart contract that the Dispute Resolution Contract can call when an arbitration finds against an annotator. Performance optimization required careful consideration of what data goes on-chain versus off-chain. Raw annotation data (images with bounding box coordinates, text with entity labels) never goes on-chain—it would be prohibitively expensive and unnecessary. Instead, we compute a cryptographic hash of the annotation data and only store that hash on-chain via HCS. The actual data lives on IPFS or centralized storage, and anyone can verify integrity by downloading the data, computing its hash, and comparing against the on-chain hash. This keeps blockchain storage minimal while maintaining verifiability. For reputation calculations, we batch updates—rather than calling the smart contract after every single task completion, the oracle agent accumulates changes and submits batch updates every 10 minutes or when the accumulated change exceeds a threshold. The entire system is designed with progressive decentralization in mind. In the MVP phase, some components remain centralized (like the backend API that coordinates between different services), but the critical trust components—payment escrow, reputation scores, audit trails, and conditional payment execution—are fully decentralized from day one. As the platform matures, we plan to decentralize more components: running agents on community-operated infrastructure, transitioning to decentralized storage exclusively, and eventually implementing full on-chain governance where ASI token holders vote on protocol upgrades. The architecture uses clean interfaces and abstraction layers to make this transition smooth—for example, our storage layer has a pluggable interface that can swap between S3, IPFS, or Filecoin without changing application logic. The integration of these technologies—Hedera for the ledger, ASI Alliance for intelligence, and Lit Protocol for trustless execution—created something greater than the sum of its parts. Hedera's event log becomes the trigger for autonomous agents. Those agents call AI services to enhance quality. AI models generate training data that improves future AI services. Lit Protocol ensures payments flow automatically based on cryptographic conditions rather than trust. The entire system operates as a decentralized protocol where no single entity has control, yet coordination emerges through smart contracts, autonomous agents, and cryptographic guarantees. Building this required not just using each technology individually but understanding how to make them interoperate, handle edge cases across system boundaries, and create a seamless user experience despite the underlying complexity. The result is a platform that genuinely demonstrates the potential of decentralized technologies to create more fair, transparent, and efficient systems for coordinating human and machine intelligence.