The Problems Urbexium Solves

Urbexium tackles systemic failures in civic infrastructure management that plague governments and citizens alike. Here’s a breakdown of the critical pain points:

Bureaucratic Black Holes

Problem: Reports vanish into endless emails, spreadsheets, or unmonitored hotlines. Manual triage delays responses for weeks (or months), eroding public trust.

Example: A citizen reports a pothole, but the request gets buried under paperwork. No one knows who’s responsible, and repairs never happen.

Zero Accountability

Problem: No transparency in task assignment, budgeting, or progress tracking. Contractors face no penalties for missed deadlines or subpar work.

Example: A worker takes payment upfront but delays repairs indefinitely. The city lacks tools to enforce consequences.

Privacy Risks

Problem: Citizens fear reporting issues due to exposed personal data (e.g., names, addresses). Governments struggle to verify identities without invasive methods.

Example: A resident avoids reporting a broken streetlight to avoid spam or retaliation.

Slow, Opaque Payments

Problem: Workers wait months for payments due to manual invoicing and approvals. Citizens have no visibility into how tax dollars are spent.

Example: A contractor fixes a bridge but can’t pay bills while waiting for a check.

Crypto Complexity

Problem: Workers and citizens avoid blockchain solutions due to gas fees, wallets, and technical jargon. Governments can’t adopt crypto tools without simplified UX.

1. Citizen Reports an Issue

• Login: Citizen authenticates via Self.xyz’s ZK-proofs, proving residency without exposing personal data.
• Report: Types a natural language description (e.g., “Broken streetlight at Oak Park entrance”).

1. Self.xyz SDK generates a zero-knowledge proof to verify the citizen’s residency.
2. AgentKit’s LLM agent parses the grievance by analysing the image for situation Aware
   • Extracts GPS coordinates, issue type (e.g., "streetlight"), and severity.
   • Auto-generates a task budget and timeline.
3. A smart contract (deployed on Base Network) is created, storing task details onchain.

2. Task Assignment & Bidding

• Workers (contractors) view open tasks in their area and submit bids.

1. Task details (budget, deadline, location) are published to a public bidding dashboard.
2. Reactive Smart Contracts (RSCs) enforce rules:
   • Penalty clauses (e.g., “Miss deadline → lose $20/day”) are embedded in the contract.
   • Bids and worker reputations are stored onchain.

3. Work Execution & Verification

• Worker accepts the task, completes repairs, and submits proof (e.g., photos, IoT sensor data).

1. RSC pulls cross-chain data (e.g., Base → React) to update the DAO dashboard and Payments.
2. RSCs trigger milestone payments via Sablier streaming on Base Network on hold and pay basis - funds are realsed only after completion

4. Payment & Transparency

• Citizen receives a “Fixed!” notification with onchain proof.
• Worker claims payment in ETH via Reactive Network.

1. Base Network processes instant payments, recorded onchain.
2. Funds stream to the worker’s Smart Wallet; penalties (if any) auto-revert to the DAO.

5. DAO Governance

• Citizens vote on disputes, budget changes, or protocol upgrades.

1. RSCs auto-execute approved decisions.

Solution Overview

The Decentralized Grievance Resolution Portal is a blockchain-powered platform that combines AI-driven automation, community governance, and transparent fund management to resolve local civic issues. Built on a modular architecture, it integrates multiple sponsor technologies (Coinbase Base, Reactive Network, Self Protocol, etc.) to deliver a scalable, user-friendly solution.

Core Components

1. AI Agent (AgentKit): Processes grievances, assigns workers, and verifies milestones.
2. Smart Contracts (Base + Reactive Network): Manages funding, milestones, and penalties.
3. DAO Governance: Decentralized fund pool with quadratic voting.
4. Identity Layer (Self Protocol): Privacy-preserving user verification.

Core Functionality

1. Grievance Lifecycle

• Submission: Users report issues via web/mobile app (text, photos, location).
• AI Processing: NLP categorizes complaints; predictive analytics prioritizes urgency.
• Smart Contract Deployment: Assigns workers, funds, and milestones.
• Milestone Execution: Workers submit proof → AI/community verification → auto-payouts.
• Community Voting: Quadratic voting evaluates work quality.

2. Key Innovations

• Worker Reputation System: On-chain scores influence task assignments.
• Reactive Payments: RSCs automate penalties for delays.
• Gasless UX: Smart Wallets (Coinbase) abstract blockchain complexity.

Development Phases

Phase 1: Smart Contracts & AI Models

1. Smart Contracts:
   • Grievance Handling: Deploy on Base for complaint submission/assignment.
   • Reactive RSCs: Code milestone-triggered payments (Reactive Network).
   • DAO Governance: Implement quadratic voting and fund management.
2. AI Agent:
   • Train NLP models (e.g., Hugging Face) for auto-categorization.
   • Build predictive analytics using historical data (Python/TensorFlow).

Core Integrations

1. Coinbase AgentKit

   • Role: AI agent for grievance categorization, urgency prediction, and worker assignment.
   • Implementation: Uses NLP models (e.g., Hugging Face) to auto-tag complaints like "pothole → Infrastructure".

2. Base Blockchain

   • Role: Hosts smart contracts for grievance submissions, quadratic voting, and DAO governance.
   • Implementation: Built with

     ethers.js

     ; integrates gasless transactions via Coinbase Agent cloud wallet.

3. Reactive Network (RSCs)

   • Role: Automates milestone payments and penalty redistribution.
   • Implementation: RSCs trigger payments when AI/Chainlink verifies work completion.

4. Self Protocol

   • Role: Privacy-preserving identity checks using ZKPs.
   • Implementation: Verifies residency/age during grievance submission and voting.

Supporting Services

• Coinbase Agent SDK: Situation aware data prediction.
• Base: Displays real-time on-chain grievance statuses.

Key Workflows

1. Grievance Submission

• User submits via CDP Agent Kit (gasless).
• AgentKit categorizes the issue (e.g., "Sanitation").
• CID stored on-chain.

2. Milestone Verification

• Reactive RSC releases payment or redistributes penalties.

Why These Integrations?

• Sponsor Alignment: Prioritizes Coinbase, Reactive, and Self Protocol for prize eligibility.
• User Experience: Gasless wallets + reactive payments reduce friction.
• Compliance: Self Protocol’s ZKPs meet GDPR/regional privacy laws.

Key Differentiators & Uniqueness

Core Innovations

1. AI-Driven Civic Problem-Solving

• Predictive Analytics: Proactively flags issues (e.g., potholes, floods) using IoT sensor data + historical patterns, before citizens report them.
• Auto-Verification: AI (AgentKit) validates work completion via image recognition (e.g., confirming a repaired road), reducing human bias.

2. Reactive Penalty System

• Funds are automatically redistributed to the community if workers miss deadlines, enforced by Reactive Smart Contracts (RSCs). No existing civic platform penalizes delays trustlessly.

3. Hybrid Voting Mechanism

• Combines quadratic voting (community sentiment) with AI scoring (objective metrics like repair durability) for fair, balanced assessments.

4. Privacy-Preserving Participation

• Self Protocol’s ZKPs let users prove residency/eligibility without exposing personal data—unlike centralized platforms that collect IDs.

5. Cross-Chain DAO Funding

• Accepts donations/payments across chains (ETH, MATIC, BTC) via ZetaChain, enabling global participation in local governance.

Improvements Over Similar Projects

1. vs. FixMyStreet (Gov’t Portals):

   • Transparency: All workflows (funding, worker assignments) are on-chain.
   • Speed: AI auto-processes complaints in minutes vs. days/weeks.
   • Incentives: Token rewards for reporting/voting drive participation.

2. vs. DAO Governance Tools (e.g., Aragon):

   • Civic Focus: Tailored for public grievances, not generic governance.
   • AI Integration: Automates resource allocation, unlike manual DAO proposals.

3. vs. DeFi Penalty Systems:

   • Real-World Impact: Penalties fund community airdrops, not just protocol treasuries.

Why These Choices?

• Hackathon Constraints: Prioritized sponsor tech (Coinbase, Reactive) over perfection.
• User First: Sacrificed decentralization temporarily for usability (gasless logins).
• Scalability: Mocked IoT/AI to validate core workflows before scaling.

Planned Improvements

1. Cross-Chain DAO

• Integrate ZetaChain for omnichain governance (ETH, MATIC, SOL support).

2. On-Chain Quadratic Voting

• Migrate voting to Base with gas optimizations (EIP-4844 blobs).

3. Dynamic Reputation System

• Train ML models to score workers based on historical performance + community sentiment.