Jobblify
Jobblify is a decentralized freelancing platform that combines autonomous AI agents with blockchain-based escrow to solve three connected problems in remote work: finding the right talent, verifying the work, and ensuring payment.
The core idea is simple:
$$ \boxed{\text{AI coordinates work} + \text{Blockchain coordinates trust}} $$
A client creates a task and locks the budget in PYUSD escrow on Ethereum. A Client Agent and a Freelancer Agent then conduct an agent-to-agent qualification process based on the task requirements and the freelancer's profile. After the freelancer completes the task, the submitted work is evaluated by the AI verification layer against the original requirements. Once approved, the escrowed payment can be released to the freelancer's wallet.
Jobblify is therefore not simply a freelance marketplace with AI features. It is an attempt to turn the freelance lifecycle into a programmable, verifiable workflow.
Inspiration
The internet made talent global. Trust did not.
Remote work has fundamentally changed how organizations access talent. According to Upwork's 2025 Future Workforce Index, 28% of U.S. skilled knowledge workers were working as freelancers or independent professionals, representing more than 20 million people and $1.5 trillion in earnings in 2024. The same research found that 36% of full-time knowledge workers were considering freelancing.
The opportunity is clearly growing, but the trust mechanisms surrounding that opportunity are still fragmented.
A client looking for a freelancer has to answer:
Does this person really have the skills required?
Then:
How do I know the submitted work actually satisfies the requirements?
And finally:
How do I make sure the freelancer gets paid and that the money is protected while the work is happening?
The freelancer faces the other side of the problem:
How can I prove my capabilities beyond a self-written profile?
How do I reduce the uncertainty around payment?
How can verified work become part of a professional reputation that can travel with me?
These are not hypothetical concerns. The ILO's research on digital labour platforms continues to identify financial insecurity, gaps in worker protection, and other challenges associated with the growth of platform work. Its 2026 work also emphasizes that digital labour platforms are expanding while governance and measurement frameworks continue to evolve.
That led us to a different question:
What if the trust problem itself could be decomposed into programmable components?
We realized that the technologies we were exploring were naturally suited to different parts of the problem.
Blockchain is good at creating verifiable financial state.
AI is good at interpreting unstructured information.
Databases are good at storing application state.
Wallets provide a cryptographic identity primitive.
So instead of trying to make one technology solve everything, we designed Jobblify around these distinct responsibilities.
What it does
1. A client creates a task
A client can define:
- task title
- description
- category
- requirements
- budget
- deadline
The requirements are particularly important because they become the reference point for the downstream AI evaluation.
2. The payment is secured before work begins
When a client posts a task, Jobblify checks the client's PYUSD balance and allowance.
If required, the client first authorizes the escrow contract to spend the required amount.
The budget is then deposited into the TaskEscrow smart contract on Ethereum Sepolia.
This changes the meaning of the task.
The budget is no longer just a value displayed in a web interface. It is backed by an on-chain escrow state.
The resulting flow is:
$$ \text{Client Wallet} \rightarrow \text{PYUSD Approval} \rightarrow \text{Escrow Contract} $$
The smart contract stores the task identifier, client address, amount, deadline, deposit state, and assigned freelancer address. It also emits events for task creation, deposits, and payment release.
3. Freelancers are evaluated by AI agents
When a freelancer applies, their wallet-linked profile is sent to the AI backend together with the task description and requirements.
The important difference is that we do not simply send everything to one LLM and ask:
"Should this freelancer be hired?"
Instead, Jobblify uses two distinct Fetch.ai uAgents with separate responsibilities.
Client Agent
The Client Agent represents the client's side of the evaluation.
It:
- receives the job requirements
- generates targeted questions
- sends those questions to the Freelancer Agent
- receives the responses
- evaluates whether the candidate satisfies the requirements
- returns an approval decision
Freelancer Agent
The Freelancer Agent represents the candidate.
It receives the freelancer's profile and uses:
- skills
- work experience
- education
- professional description
to answer the Client Agent's questions.
The interaction therefore becomes:
Task Requirements ↓ Client Agent ↓ Questions ↓ Freelancer Agent ↓ Profile-based Answers ↓ Client Agent ↓ Qualification Decision
The agents communicate using structured message models rather than arbitrary text, including EvaluationIntroduction, IntroductionAcknowledgment, ProfileDataMessage, QuestionMessage, and QuestionResponse.
This is one of the central ideas behind Jobblify: AI is not merely an assistant inside the UI. It participates as an actor in the workflow.
4. Work is verified separately from hiring
Being qualified for a task and actually completing that task correctly are two different problems.
We therefore created a second AI verification workflow.
The verification layer receives:
Original Task Description
+
Original Requirements
+
Submitted Work
The AI evaluates the submission against the actual task requirements and produces a decision with feedback.
This gives Jobblify two distinct verification stages:
$$ \text{Stage 1: Can this freelancer do the task?} $$
$$ \text{Stage 2: Did the submitted work satisfy the task?} $$
That separation is important because a strong profile is not proof of a strong deliverable.
5. Approved work can trigger blockchain settlement
Once the work is approved, the payment flow moves back to the blockchain layer.
The frontend verifies the escrow state and freelancer assignment, then invokes:
releasePayment(taskId)
The smart contract transfers the escrowed PYUSD to the assigned freelancer.
The complete workflow becomes:
Create Task
↓
Lock PYUSD in Escrow
↓
Freelancer Applies
↓
AI Agent Qualification
↓
Freelancer Selected
↓
Work Completed
↓
AI Work Verification
↓
Approved
↓
Blockchain Payment Release
How we built it
Jobblify is deliberately a hybrid Web2 + Web3 + AI architecture.
We did not put everything on-chain because that would make the system expensive and unnecessarily difficult to query.
Instead:
$$ \boxed{ \text{Supabase} = \text{Application State} } $$
$$ \boxed{ \text{Ethereum} = \text{Financial State} } $$
$$ \boxed{ \text{AI Agents} = \text{Evaluation and Verification} } $$
$$ \boxed{ \text{Wallet} = \text{Identity and Transaction Authorization} } $$
Frontend
The frontend is built with:
- React 19
- TypeScript
- Vite
- Tailwind CSS
- shadcn/ui
- Framer Motion
- React Router
- Ethers.js
The interface has distinct client and freelancer workflows.
The client can create tasks and manage engagements.
The freelancer can browse tasks, inspect requirements, apply, submit work, and follow the AI verification process.
We also created an interactive Agent Drawer that exposes the AI conversation and processing state to the user instead of hiding everything behind a generic loading spinner.
Wallet-based identity
Wallets are used as the primary identity anchor.
The wallet service handles:
- wallet detection
- account connection
- network checking
- Sepolia network switching
- balance retrieval
- PYUSD interaction
- disconnection
The wallet address is then linked to the user's profile and task participation.
This allows a user's application identity and financial identity to reference the same underlying address.
Supabase
Supabase/PostgreSQL stores application-level information such as:
Users
Tasks
Applications
Submissions
Payments
This gives us the queryability and flexibility expected from a conventional web application without sacrificing blockchain-based financial verification.
Smart contract
The core escrow logic is implemented in Solidity using the TaskEscrow contract.
It handles:
- PYUSD deposits
- task creation
- deadline storage
- freelancer assignment
- escrow state
- payment release
- blockchain events
The contract uses OpenZeppelin's ReentrancyGuard for payment-related state-changing functions.
AI backend
The AI layer is implemented in Python.
A Flask API acts as the bridge between the React frontend and the Fetch.ai agent environment.
The architecture is:
React Frontend
↓
Flask API
↓
Fetch.ai Bureau
↓
Client Agent ↔ Freelancer Agent
↓
ASI-1
Because agent interactions are asynchronous, Jobblify uses interaction IDs, queues, agent state, and frontend polling to track an evaluation from initiation through completion.
Technical Architecture & MVP Feasibility
One of our priorities was making the concept implementable as an MVP rather than designing a system that would require years of infrastructure before anything could work.
The prototype already demonstrates the major components required for the core loop:
┌───────────────────┐
│ React Frontend │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
↓ ↓ ↓
Supabase Flask API Ethereum
│ │ │
App State Agent System Escrow Contract
│
┌──────┴──────┐
↓ ↓
Client Agent Freelancer Agent
└──────┬──────┘
↓
ASI-1
This architecture also gives us clean boundaries.
If the AI system changes, the escrow contract does not need to change.
If the database schema changes, the wallet layer does not need to change.
If a different AI model is introduced, the agent protocol can remain largely unchanged.
That modularity is important for scaling beyond the prototype.
Innovation & Value Proposition
There are already decentralized talent and freelance platforms.
For example, LaborX uses Ethereum-based smart contracts, escrow, and decentralized work infrastructure, while Braintrust operates a decentralized talent network with screening and AI-powered matching capabilities.
Our innovation is therefore not simply "a decentralized freelance marketplace."
Our differentiating proposition is the combination of:
$$ \boxed{ \text{Agent-to-Agent Qualification} + \text{AI Work Verification} + \text{Stablecoin Escrow} } $$
in a single workflow.
Instead of AI only recommending candidates, the agents actively participate in the qualification process.
Instead of blockchain simply being used for a token or wallet login, the smart contract is responsible for the financial settlement layer.
Instead of verifying only the candidate, we also verify the deliverable.
The result is a different model:
Traditional Marketplace
Find Talent → Hire → Work → Human Review → Payment
Jobblify
Find Talent
↓
Agent Qualification
↓
Programmable Escrow
↓
Work
↓
AI Verification
↓
On-chain Settlement
The unique value therefore comes from the interaction between the technologies, rather than from any individual component.
Market & Impact Viability
The market opportunity is directly connected to the continued growth of independent and platform-based knowledge work.
Upwork's 2025 research estimated that more than 20 million U.S. skilled knowledge workers were working independently, generating $1.5 trillion in earnings in 2024. It also found that 78% of businesses in an October 2025 hiring survey planned to hire independent talent in the following three months.
The initial target users for Jobblify are:
Freelancers
Particularly:
- software developers
- designers
- writers
- analysts
- technical specialists
- independent consultants
They gain a structured way to prove their capabilities, complete verified work, and receive programmable payments.
Startups and SMBs
These organizations often need specialized talent without maintaining large permanent teams.
Jobblify can reduce manual work around screening, verification, and payment coordination.
Global clients and remote teams
Cross-border work increases the complexity of identity, trust, and payments.
A wallet-native payment layer and stablecoin escrow provide an alternative settlement mechanism for digitally native participants.
The long-term impact is potentially larger than freelancing alone.
As AI agents become increasingly capable, software agents may become participants in economic workflows rather than simply tools controlled by humans.
Jobblify explores what happens when the labor marketplace itself becomes agent-native.
Challenges we ran into
The biggest challenge was integrating systems with fundamentally different properties.
React is event-driven.
Flask follows request-response semantics.
uAgents communicate asynchronously.
AI models are probabilistic.
Supabase is database-driven.
Ethereum transactions are state-changing and externally confirmed.
Making them behave like one application required us to reason carefully about state synchronization.
Another major challenge was handling asynchronous agent conversations.
A single evaluation could look like:
HTTP Request
↓
Queue
↓
Client Agent
↓
Freelancer Agent
↓
Question
↓
Answer
↓
Question
↓
Answer
↓
Decision
We solved this with interaction IDs, queues, background agent processing, status endpoints, and frontend polling.
We also faced the challenge of making probabilistic AI behavior fit into deterministic financial infrastructure.
This led to a core architectural rule:
AI may evaluate and recommend a workflow transition, but blockchain is responsible for enforcing the financial state.
That separation allowed us to combine the flexibility of AI with the deterministic behavior required for payment settlement.
Accomplishments we're proud of
The accomplishment we are most proud of is that Jobblify is not just a concept diagram.
We built the major components required to demonstrate the idea end-to-end.
We implemented:
- wallet-based identity
- client and freelancer workflows
- task creation and management
- PYUSD balance and allowance handling
- Ethereum escrow
- agent-to-agent candidate evaluation
- AI-powered work verification
- asynchronous agent communication
- on-chain payment release
- an interface that exposes the AI process to users
More importantly, we were able to connect all of these components into one coherent lifecycle.
We also built the project incrementally rather than attempting to implement everything at once. The repository history shows the evolution from the initial application and landing page through Supabase services, wallet functionality, task management, Hardhat integration, escrow, submission workflows, agent integration, verification, and UI refinement.
That incremental process helped us understand each layer before connecting it to the next.
What we learned
We learned that architecture matters more than individual technologies.
It is easy to say:
"Let's use blockchain and AI."
It is much harder to decide exactly where each technology belongs.
Jobblify taught us to design around responsibilities:
$$ \text{AI} \rightarrow \text{Interpret} $$
$$ \text{Database} \rightarrow \text{Store} $$
$$ \text{Blockchain} \rightarrow \text{Enforce} $$
$$ \text{Wallet} \rightarrow \text{Authenticate and Sign} $$
We learned that an AI agent is fundamentally different from a chatbot.
Giving an AI system an identity, role, state, protocol, and relationship with another agent creates a new architectural abstraction.
This changed how we think about AI applications.
We learned that decentralization should be selective.
The best architecture is not necessarily the one with the most blockchain.
It is the one where blockchain is used precisely where trust and verification matter most.
We learned that UX is part of the system design.
For autonomous systems, users need to understand what is happening.
That is why the Agent Drawer shows the evaluation process rather than simply displaying "Processing."
The interface itself becomes part of the transparency layer.
What's next for Jobblify
The current version proves the core concept, but our long-term vision goes much further.
1. Verifiable professional reputation
A freelancer's completed and verified work could eventually become part of a portable reputation layer.
Instead of a profile saying:
"I am good at React."
the system could show:
"This wallet has completed and verified 27 React projects."
That creates a very different model of professional credibility.
2. Richer AI verification
The current prototype primarily works with structured profiles and task submissions.
Future versions could incorporate:
- portfolio analysis
- GitHub repositories
- technical assessments
- certifications
- previous verified work
- project-specific testing
This would shift evaluation from self-reported credentials toward evidence-based capability verification.
3. Multi-agent hiring
The current system has a Client Agent and Freelancer Agent.
The future architecture could introduce specialized agents:
Client Agent
↓
Matching Agent
↓
Freelancer Agent
↓
Verification Agent
↓
Dispute Agent
↓
Settlement Layer
This would allow different parts of the hiring lifecycle to become autonomous services.
4. Decentralized dispute resolution
A production marketplace needs a robust way to handle disagreements.
We want to explore systems involving multiple independent verification agents, cryptographic evidence, programmable escrow conditions, and decentralized arbitration.
5. Persistent professional agents
The biggest long-term idea is to give freelancers their own professional AI agents.
Instead of manually:
Search → Apply → Explain Skills → Answer Questions
a freelancer could eventually have an agent that:
Discovers Opportunities
↓
Understands Requirements
↓
Represents the Freelancer
↓
Answers Qualification Questions
↓
Coordinates with Client Agents
That would move Jobblify beyond a traditional freelance platform toward an agent-native labor protocol.
Why Jobblify matters
The freelance marketplace is evolving from a world where humans manually coordinate every part of work toward a world where software agents increasingly participate in those workflows.
Jobblify explores one possible architecture for that transition.
The idea is not:
"Put freelancing on blockchain."
The idea is:
"Separate the trust problem into components that can be verified, automated, and programmed."
AI can determine whether a profile appears to satisfy the requirements.
AI can evaluate whether submitted work addresses the task.
Blockchain can hold and settle the payment.
The database can maintain application state.
The wallet can provide a persistent cryptographic identity.
Together, these components create:
$$ \boxed{ \text{Identity} + \text{Evaluation} + \text{Verification} + \text{Escrow} + \text{Settlement} } $$
That is the core vision of Jobblify: a freelance marketplace where trust is not concentrated in one platform, but distributed across transparent protocols and autonomous software.
The current implementation is an MVP prototype, not a production-ready financial or arbitration system. Before production deployment, we would further strengthen contract security, access control, dispute handling, persistent agent state, privacy, and scalability.
But the prototype demonstrates the central thesis:
Freelancing does not have to treat hiring, verification, and payment as three separate problems. They can be one programmable workflow.
Built With
- asi-1-via-an-openai-compatible-client
- ethereum-sepolia
- ethers.js
- fetch.ai-uagents
- flask
- framer
- hardhat
- openzeppelin
- python
- pyusd
- react
- solidity
- supabase
- tailwind
- typescript
- vite
Log in or sign up for Devpost to join the conversation.