[DMP 2026]: Agentic Invoice Co-Pilot for Government Billing (PWA + iOS/Android + Web3 Payments)

[seetadev]

Ticket Contents

Description

The Agentic Web3 Invoice Co-Pilot is a cross-platform billing and invoicing system designed for government institutions and educational bodies, delivered as a PWA and native iOS/Android applications. It introduces an intelligent, agent-driven layer that assists users in creating, validating, managing, and exporting invoices with minimal manual effort.

Existing billing systems in public institutions are often manual, error-prone, and lack transparency. This feature addresses these gaps by integrating agentic AI workflows that can auto-generate invoices, detect inconsistencies, suggest corrections, and streamline compliance. The system also leverages Filecoin/IPFS for secure, tamper-proof storage and blockchain networks for verifiable recordkeeping.

A key innovation is the integration of agentic payment systems, including x402, MPP (Tempo), and ERC-8004, enabling programmable, automated, and conditional payments. This allows invoices to be settled through machine-driven workflows, supporting use cases such as milestone-based disbursements, streaming payments, and multi-party payment routing without manual intervention.

Additionally, the Invoice Co-Pilot will be designed for deployment on agentic marketplaces, making it a reusable and composable public-good service that other developers and institutions can adopt. By combining AI-driven automation, decentralized storage, agentic payments, and mobile-first deployment, the feature will significantly improve efficiency, transparency, and accessibility in government billing and procurement workflows.

Goals & Mid-Point Milestone

Goals

• [Build the Agentic Invoice Co-Pilot with AI-driven invoice generation, validation, and recommendation workflows]
• [Develop and deploy cross-platform applications (PWA + iOS + Android) using Ionic/Capacitor with deep linking support]
• [Integrate decentralized storage (Filecoin/IPFS) for secure, verifiable invoice persistence]
• [Implement agentic payment flows using x402, MPP (Tempo), and ERC-8004 for automated and programmable invoice settlement]
• [Goals Achieved By Mid-point Milestone: Functional Co-Pilot prototype, PWA deployed, basic agentic invoice generation + validation working, initial Filecoin storage integration, and demo agentic payment flow]

Setup/Installation

Setup/Installation

• Clone the repository:

  • https://github.com/seetadev/GovtInvoice

• Navigate to the project (choose one):

  • Ionic React:

    cd Govt-Billing-React

  • Ionic Angular:

    cd Govt-Billing-Angular

• Install dependencies:

  npm install

• Run the development server:

  npm run dev

  or

  ionic serve

• Configure environment variables:

  • Filecoin/IPFS (Lighthouse or Storacha API keys)
  • Blockchain RPC endpoints (Optimism, Ethereum, Starknet, Base)
  • Agentic payment configs (x402, MPP Tempo, ERC-8004)

• Build as PWA:

  ionic build

• Run on Android:

  npx cap add android
  npx cap open android

• Run on iOS (Mac only):

  npx cap add ios
  npx cap open ios

• Enable Capacitor plugins (e.g., email composer, file export, storage, deep linking):

  npx cap sync

• Optional integrations:

  • Configure Filecoin/IPFS upload workflows
  • Enable email export (HTML/CSV) via Capacitor Email Composer
  • Integrate at least 3 community plugins from Capacitor

• Refer to:

  • https://ionicframework.com/react
  • https://ionicframework.com/docs
  • Project README for module-specific setup instructions

Expected Outcome

Expected Outcome

The final product will be a production-ready Agentic Web3 Invoice Co-Pilot, available as a PWA and fully deployable iOS and Android applications, tailored for government institutions and educational systems.

The application will provide an intelligent, assistant-like interface where users can create and manage invoices with the help of agentic workflows. The Co-Pilot will be capable of auto-generating invoices from inputs (forms, files, or prompts), validating entries in real time, detecting anomalies, and suggesting corrections or optimizations, significantly reducing manual effort and human error.

All invoices and related records will be securely stored on Filecoin/IPFS, ensuring immutability, long-term persistence, and auditability. Users will be able to save, version (“Save As”), export (HTML/CSV/email), and print invoices, with every action aligned to verifiable records.

The system will support agentic payment flows, where invoices can be automatically settled using x402, MPP (Tempo), and ERC-8004 standards, enabling programmable payments such as milestone-based releases, streaming payments, and multi-party distribution. This allows billing workflows to move from manual approval processes to automated, machine-executed transactions.

From a platform perspective, the solution will:

• Run seamlessly as a Progressive Web App (PWA) for universal access
• Be deployable on iOS and Android devices with deep linking and native capabilities
• Integrate with agentic marketplaces, allowing the Invoice Co-Pilot to be discovered, reused, and extended as a composable service

For developers, the system will expose modular components, APIs, and templates, enabling easy customization and integration into other public sector or enterprise systems.

Overall, the product will function as a smart, autonomous billing infrastructure, delivering:

• Faster and error-free invoice generation
• Transparent and auditable recordkeeping
• Automated and programmable payments
• Mobile-first accessibility across devices
• A reusable public-good service for broader ecosystem adoption

Acceptance Criteria

Acceptance Criteria

• Agentic Invoice Co-Pilot successfully generates invoices from user inputs (forms/prompts/files)
• Real-time validation and anomaly detection for invoice data is functional
• Cross-platform support is complete: PWA, iOS, and Android apps run successfully
• Deep linking and native device capabilities (via Capacitor) are properly integrated
• Invoices can be saved, versioned (“Save As”), printed, and exported (HTML/CSV/email)
• Filecoin/IPFS integration is working for secure, immutable invoice storage
• Agentic payment flows (x402, MPP Tempo, ERC-8004) are implemented and demonstrable
• End-to-end workflow is functional: create → validate → store → export → pay
• At least 3 Capacitor community plugins are integrated and functional
• Application is deployable and testable on Android and iOS environments
• PWA build is optimized and accessible via browser with offline/basic support
• APIs/components are modular and reusable for external integrations
• Basic documentation is available for setup, usage, and developer onboarding
• Demo or deployment ready for showcasing on agentic marketplaces

Implementation Details

Implementation Details

The Agentic Web3 Invoice Co-Pilot will be implemented as a cross-platform, modular system combining hybrid mobile development, agentic AI workflows, decentralized storage, and programmable payment infrastructure.

Frontend & Cross-Platform Layer:

• Ionic (React or Angular) + Capacitor for building PWA, iOS, and Android apps from a single codebase
• Deep linking support for seamless navigation across mobile and web
• Integration of Capacitor community plugins (e.g., email composer, filesystem, share, network, push notifications)
• Responsive UI for invoice creation, Co-Pilot interaction, and dashboard views

Agentic Co-Pilot Layer:

• AI/agent framework (LLM-based orchestration) for:

  • Invoice generation from prompts, forms, or uploaded data
  • Validation, anomaly detection, and compliance suggestions
  • Automated workflows (save, export, trigger payments)

• Structured data pipelines for invoice parsing and normalization

• Optional integration with agent orchestration frameworks (e.g., AutoGen-style or tool-calling agents)

Storage Layer:

• Filecoin/IPFS (via Lighthouse or Storacha) for decentralized storage of invoices and metadata
• Optional fallback integrations with Firebase/AWS (with AWS-SDK components modularized/commented as required)
• Content addressing for verifiable and immutable invoice records

Blockchain & Payment Layer:

• EVM-compatible chains (Optimism, Ethereum, Base, Arbitrum) for transaction execution
• Starknet for advanced ZK or validation extensions (optional)
• PPT ERC-20 token integration for invoice actions (save, versioning, access)

Agentic Payments:

• Integration of:

  • x402 for programmable API-driven payments
  • MPP (Tempo) for multi-party and streaming payment flows
  • ERC-8004 for standardized agent-driven payment execution

• Smart contract or off-chain agent coordination for:

  • Milestone-based disbursements
  • Conditional invoice settlement
  • Multi-recipient payment routing

Export & Communication:

• Email export (HTML/CSV) using Capacitor Email Composer plugin
• File export using filesystem/share plugins
• Print-ready invoice generation aligned with stored records

Backend & APIs:

• Node.js / TypeScript services (optional lightweight backend)

• APIs for:

  • Invoice creation and retrieval
  • Storage interactions (IPFS/Filecoin)
  • Agent task execution
  • Payment orchestration

DevOps & Tooling:

• GitHub-based workflow with CI/CD for builds and testing
• Android Studio / Xcode for native builds
• Environment-based configuration for multi-chain and storage providers

This architecture ensures a scalable, mobile-first, and intelligent billing system that combines agentic automation, decentralized storage, and programmable payments into a unified public goods solution.

Mockups/Wireframes

No response

Product Name

Agentic Invoice Co-Pilot – Web3 Billing for Public Institutions

Organisation Name

NSUT x SEETA x AIC

Domain

Financial Inclusion

Tech Skills Needed

Chart.js, Bootstrap, TypeScript, Ionic, AWS, Artificial Intelligence, RESTful APIs, Express.js, Mobile, Docker, Electron

Mentor(s)

@seetadev , @aspiringsecurity, @prithagupta

Dr. MPS Bhatia (faculty adviser)

Category

AI

[ayushk687]

@seetadev please what is procedure and steps for this org means only have to write propsals ?

[Akshats-git]

Hello @seetadev @aspiringsecurity @prithagupta. I find the project idea very interesting and would like to work on it. It will take some time to properly understand what the project demands and how to implement it. Any suggestions on how to start or any general guidance are very much appreciated.

[prithagupta]

@seetadev please what is procedure and steps for this org means only have to write propsals ?

Dear Ayush, we’ll need to wait a bit as we are still in the process of defining the requirements and securing funding to begin the prototype phase. At this stage, no formal proposals are required yet. Meanwhile, please let us know if you would be interested in working on this once things move forward.

[utkarshgupta2804]

Hello @seetadev @prithagupta. I liked project idea. I am interested to work on this. I can work in backend development and docker work and if it will require ci/cd than I can work on that too.

[divyam-jha123]

hey @prithagupta I am really interested in contributing to GovtInvoice as I can see from the commits that the project is still in its early stage so would love to resolve bugs ,ship new features and work with the team of GovtInvoice.
please let me know if there is something I can work on in the repo right now

[kanCHI-Singhal]

Hi @seetadev @aspiringsecurity @prithagupta,

I'm Kanishka Singhal and I'm extremely excited about the Agentic Invoice Co-Pilot project! This is exactly the kind of cutting-edge, real-world impact project I've been looking to contribute to.

Why I'm Perfect for This Project

✅ Relevant Experience:

• Ionic/Capacitor: Built cross-platform PWAs and native apps with Ionic React + Capacitor
• Agentic AI: Implemented LLM orchestration workflows and tool-calling agents (AutoGen-style)
• Web3/DeFi: Integrated EVM chains (Optimism/Base), IPFS storage, and payment protocols
• TypeScript: Full-stack TS developer with Ionic/Angular/React experience
• Mobile Deployment: Experience with Android Studio/Xcode builds and Capacitor plugins

🚀 Quick Wins I Can Deliver:

• PWA + iOS/Android prototype with invoice generation UI
• Filecoin/IPFS integration for invoice storage
• Basic agentic validation workflows using LLM APIs
• Meet mid-point milestone ahead of schedule

This project combines many things I'm passionate about - agentic AI, cross-platform mobile, and public sector impact. I'm confident I can deliver a production-ready Co-Pilot that exceeds expectations.

Thank you
Kanishka Singhal

[Tgbjr2025]

Hi @seetadev — I'd like to propose delivering the full scope of this issue. I run dominusaxis.com and have built DOMINUS, an agentic platform whose core primitives map directly onto what #37 needs. Real numbers from the running system, not a pitch deck:

DOMINUS — what's already shipping

Capability	Scale
Python codebase (agent + signal engine + command center + store)	~154,000 LOC
Tool framework	1,026 tool functions across 258 files
Agent modes	47 (chat, audit, revenue, bounty, autopilot, agency, mlpipeline, etc.)
Command Center microservices	52
Trained ML models (LightGBM + XGBoost, calibrated)	128
Tiered-LLM cost router	4 tiers: Neural-DB cache → Haiku → Sonnet → Opus
Payments live in prod	Stripe + PayPal
Security scanner	Just ran on this repo — results in the reply to this comment
Multi-agent DAG orchestrator	763-LOC scheduler, swarm-execution ready

The 10-layer memory stack (core of the Co-Pilot)

This is what lets an agent maintain coherent state across long-running workflows — essential for an invoicing Co-Pilot that has to remember taxpayer history, reject past anomalies, and reason across versions of the same invoice.

Layer	Purpose	Invoice use-case
L1 — Chat history	Last N conversational turns	"What did the taxpayer ask last month?"
L2 — Action log	Last 50 tool invocations	Audit trail: who signed, what was pinned, when
L3 — Session / project context	Active project scope	Keeps multi-entity govt departments isolated
L4 — Neural DB	Semantic vector search over all prior artefacts	"Find invoices similar to this disputed one"
L5 — Intelligence registry	ML model metadata + routing	Anomaly classifier versioning, A/B routing
L6 — Pattern DB	Learned patterns (e.g. known fraud shapes)	Flag invoices matching prior anomaly signatures
L7 — Execution KB	Static + learned procedures	"How do we process a GST-exempt invoice?"
L8 — Compressor	Conversation digests for long contexts	Summarises 100-turn Co-Pilot sessions to 1 page
L9 — Failure bridge	Lessons from past failures	Won't repeat a mistake the Co-Pilot made before
L10 — Project state	Active goals, milestones, revenue	Tracks progress against billing cycles / targets

Every LLM call gets a compact slice of these injected. That's how the Co-Pilot stays useful beyond a single turn.

Fit with the 13 acceptance criteria

Criterion	How I deliver it
Agentic Co-Pilot (gen / validate / anomaly)	Tiered-LLM router + LightGBM anomaly classifier (same infra as my 128 trained models) + the 10-layer memory above
PWA + iOS + Android	Fork Govt-Billing-React, upgrade Ionic, Capacitor wrap, sign → TestFlight + Play Internal
Filecoin / IPFS / Storacha	CID registry + dual-pin (IPFS hot, Filecoin cold); PDF/CSV bundled at finalize
Multi-chain (Optimism / Base / Ethereum / Starknet)	viem + wagmi behind a chain-agnostic interface
x402 + MPP (Tempo) + ERC-8004	Adapters behind one PaymentProtocol interface — swappable as specs finalise
3× Capacitor plugins	@capacitor/filesystem, @capacitor-community/email-composer, @capacitor/share
Deep linking	Universal Links + App Links + PWA install prompts
Versioning / Save As	Event-sourced invoice store (same pattern as my action log)
Docs + deploy guide	/docs, Docker Compose for self-host, Railway/Vercel for managed

Pre-audit (free)

I ran my security scanner over the repo before writing this comment. Triaged findings in the reply below — posted separately because raw scanner output is ~95% false positives (regex .exec() in vendored jQuery, not code injection) and I don't want to flood the thread. The 8 real findings plus the structural observations are in the reply.

Full triage + fixes are M0 of the engagement.

Proposed plan — 10 weeks, 5 milestones, $48,000 USD

M	Weeks	Deliverable	Payment
M0	0–1	Pre-audit triage, SOW, architecture doc, env setup	$6,000
M1	1–3	Co-Pilot core: schema, validation, anomaly detector, NL endpoint, 10-layer memory wired	$10,000
M2	3–5	PWA live on staging + signed iOS/Android Capacitor builds	$10,000
M3	5–7	Filecoin/IPFS write path + CID registry + 3 Capacitor plugins + deep linking	$8,000
M4	7–9	x402 + MPP + ERC-8004 adapters, multi-chain viem client, e2e pay → pin → receipt	$10,000
M5	9–10	Security audit (my scanner), Playwright e2e, 4× walkthroughs, 2× handovers	$4,000

Includes 30-day post-launch support + 2 bugfix rounds.

Happy to restructure for a stipend-based DMP 2026 track, or T&M at $150/hr if preferred.

What I need from the org

• Repo access (or a fork I can PR into)
• Testnet funding on Optimism Sepolia, Base Sepolia, Starknet Sepolia
• Apple Developer + Google Play Console seats
• A single decision-maker mentor for ~30 min/week syncs
• 50–200 anonymised sample invoices (or permission to synthesise)

Why me, briefly

• Live platform, not a pitch deck — dominusaxis.com is running this stack today
• 154k LOC already battle-tested — not a greenfield learning exercise
• 10-layer memory + 47 agent modes + 1,026 tool functions — the Co-Pilot inherits all of it on day 1
• Security-first — every merge goes through my scanner; you get the scanner itself as a deliverable
• Full-stack operator — I run the infra (nginx, systemd, SSL, monitoring); no "works on my laptop" gap
• Zero LLM marginal cost to the project — my Max subscription absorbs all Claude spend

SOW signed within 24h of go-ahead. M0 kicks off the following Monday.

— Thomas Bateman
DOMINUS AXIS · dominusaxis.com · admin@dominusaxis.com

[Tgbjr2025]

Pre-audit — triaged findings (free)

I ran my DOMINUS security scanner over the repo (DeveloperAdoption, Govt-Billing-React, Govt-Billing-React-Ad-Subscriptions, Govt-Billing-Angular, Website). Hunt time: 2.8 seconds.

Raw output: 189 findings (134 CRITICAL + 55 HIGH).
Real findings after triage: ~8.

The rest are false positives from the scanner matching JavaScript regex.exec() calls against its generic eval|exec|os.system code-injection pattern — those hits come entirely from vendored copies of jQuery, Highcharts, SocialCalc, jFlot, Cordova 1.7, and jsOAuth, none of which are actual code injection. Posting them raw would be misleading. Here's the real signal:

🔴 Real CRITICAL findings

1. Hardcoded Firebase API key

• File: DeveloperAdoption/lib/firebaseConfig.js:8
• Key: AIzaSyCqal3ZlyEa0_CEu0CRmDNfkIRrZO7wfqE
• Risk: If Firestore security rules are permissive, this is a full database compromise. Even if rules are strict, the key should be rotated + moved to env vars.
• Fix: Rotate the key, read it from import.meta.env.VITE_FIREBASE_API_KEY, add a guard in deployment scripts to block commits of AIza* patterns.

2. Hardcoded secret in Angular login modal

• File: Govt-Billing-Angular/src/app/login-modal/login-modal.page.ts:67
• Risk: Depends on what's hardcoded (likely an auth credential or endpoint token). Needs manual inspection before public disclosure.
• Fix: Move to Angular's environment.ts / environment.prod.ts, never commit the prod variant.

🟠 Real HIGH findings

3. XSS surface in SocialCalc spreadsheet editors

• Files: socialcalctableeditor.js:237, socialcalcworkbookcontrol.js:135, socialcalctableeditor.js:511
• Present in all four sub-projects (DeveloperAdoption, Govt-Billing-React, Govt-Billing-Angular, Website) — duplicated code.
• Risk: User-entered cell content flows into DOM via innerHTML equivalents. An invoice line item could deliver stored XSS to the taxpayer-side viewer.
• Fix: Either (a) patch SocialCalc to route through a sanitiser (DOMPurify), (b) replace SocialCalc with a modern headless spreadsheet engine (HyperFormula + a custom renderer), or (c) enforce a strict CSP. Option (b) is what I'd recommend — SocialCalc is abandoned.

4. Open-redirect patterns in Flask route handlers

• Files: Website/route_handlers/SaveHandler.py, UserSheetHandler.py, Auth/PWResetHandler.py, Auth/UserLoginHandler.py
• Needs manual confirmation (the scanner flags line 1 which is usually an import, but the pattern appears repeatedly across auth handlers — likely genuine on the actual redirect line).
• Risk: Phishing vector — redirect user to an attacker-controlled URL after login/password reset.
• Fix: Allowlist internal paths only; reject http://, //, and absolute URLs in next parameters.

⚠️ Structural observation (the real issue)

The entire codebase leans heavily on ancient, abandoned JS libraries:

Library	Year	Status
jQuery 1.x minified	~2011	14 years old
Cordova 1.7.0	2012	Superseded by Capacitor ×10 major versions
Highcharts 2	~2012	Current stable is v11
SocialCalc	~2010, WikiCalc lineage	Unmaintained
Highslide JS	~2011	Abandoned, non-free licence since 2018
jFlot	~2011	Unmaintained

This is why the scanner lit up — these libs have known CVE clusters going back a decade, and their minified single-line bundles trip every generic pattern. The right answer isn't patching line 645 of socialcalcviewer.js — it's a planned deprecation of that stack as part of the Ionic/Capacitor upgrade in M2.

Not flagged but worth noting

• No dependency pinning visible at a glance (package.json files need package-lock.json / npm ci in CI)
• Four parallel implementations (React / Angular / React-Ad-Subs / Website) share copy-pasted vendored JS — fixes have to be made in 4 places today. Consolidating is part of M1.

---

What's next

This was a 2.8-second surface scan. M0 of the engagement includes:

1. Deep scan with Slither/Semgrep/Mythril on Solidity + Semgrep/Bandit on Python/TS + npm audit on each package.json
2. Dependency audit with CVE cross-reference
3. Triage session (I come back with the ~50–100 real issues and a remediation priority list)
4. A committed fix plan with time estimates per issue

The scanner script itself is part of the final deliverable — you keep running it on every PR after handover.

Full commercial terms in the parent comment.

— Thomas / DOMINUS AXIS

[shashankiitbhu]

Hey @seetadev @aspiringsecurity @prithagupta, I’ve worked on backend-integrated systems and some LLM-driven workflows before, so this agentic co-pilot approach for invoices looked interesting.

From the description, feels like the tricky part is not just generating invoices with AI but keeping the system deterministic and auditable, especially once storage (IPFS/Filecoin) and payment flows are involved. Since invoices are financial records, even small inconsistencies between AI-generated output and stored/paid state can cause issues.

Thinking it might be important to keep a clear separation between “AI suggestions” and “finalized invoice state” (with structured validation + normalization before persistence/payment), instead of letting agent workflows directly mutate state.

Also curious how agentic payment flows are expected to be orchestrated — fully autonomous or with some checkpoint/approval layer before execution.

Planning to explore the current repo to understand how invoice data is structured before going deeper.