ParviGov is the governance layer for any application, not only AI agents. One API call produces a cryptographic fingerprint of what was done, by whom (human, AI, or both), and when. This page details how to plug real systems in — and where data lives.
Every governed action becomes an immutable, ordered, independently verifiable record on the LAG chain — with AWP witness and optional PayBotFin receipt.
Filed a petition, approved a tax package, opened a portal, ran a model, signed a contract — structured events, not vague logs.
Human, AI agent, automation, or a delegation chain (human authorized → AI executed). Accountability stays clear.
Cryptographic order. Tamper fails the signature. Deletion breaks the chain. Auditors rebuild the full timeline.
When something goes wrong — or a regulator asks — you need more than “we used AI carefully.” You need a cryptographic answer to what happened, who did it (human, AI, or both), and when.
Show a verifiable chain instead of screenshots and email threads. Independent AWP receipts can be checked offline — even by a third party who does not trust your internal logs.
When AI drafts and humans approve, responsibility blurs. ParviGov keeps the delegation chain explicit: who authorized, who executed, who signed off — sealed in order.
Automatic logging, human oversight traces, and robustness evidence are not optional for high-risk systems. ParviGov produces that trail as actions happen — not as a reconstruction project months later.
ERP, practice management, tax software, browsers, agents — one governance layer. Without it, every tool invents its own weak audit log that nobody can prove under attack.
Space to go deep: not a slogan — the sequence of human and AI actions, what gets fingerprinted, and what auditors can prove later.
Litigation, corporate, or boutique — prove the full path from review to filing when humans and AI work the same matter.
The pain today: Who changed the draft? Did the partner actually approve the version that was filed? When AI suggests clauses, can you show a regulator or the bar which human remained accountable? Email and Word “Track Changes” do not produce cryptographic evidence.
Associate opens case file #4821 in the practice system (or via a governed browser session). ParviGov records: actor = human, action = open_matter, matter_id, timestamp.
An AI agent (or plugin in the document suite) generates a petition draft or extracts deadlines from PDFs. ParviGov records: actor = agent, action = draft_petition, inputs hash, model/tool id if provided, result = success.
Partner edits and clicks approve. Actor = human (partner), action = approve_filing, links to the same engagement_id as the draft. Delegation is visible: AI produced, human authorized.
Filing portal submission (human or agentic browser under policy). Governed action: file_to_court with outcome. Full chain is now sealed.
| Fingerprint field | Example value |
|---|---|
| What | open_matter → draft_petition → approve_filing → file_to_court |
| Who | human:associate → agent:draft-bot → human:partner → agent:browser-filer |
| When | Ordered chain positions + timestamps; delete any step → chain break |
| Proof | LAG entry + AWP receipt (offline verify) + optional PayBotFin if billed work unit |
Bookkeeping, tax close, and advisory — seal imports, classifications, and who signed off the package.
The pain today: CSV imports, AI categorization, last-minute journal fixes, and a senior “OK” on WhatsApp. When tax authority asks who approved the close, Excel history is not a cryptographic proof.
Bookkeeper uploads bank CSV or syncs ERP. Governed action: import_transactions with file hash and row count.
Model assigns accounts, flags anomalies. Action: classify_transactions + anomaly_flags. Actor = AI; still bound to the same engagement (client month-close).
Human accepts/rejects AI categories, posts adjustments. Each material change is a governed action with actor = human.
Approve close package; submit tax declaration via portal (manual or agent). Final actions: approve_close + submit_declaration with outcome.
| Fingerprint field | Example value |
|---|---|
| What | import → classify → adjust → approve_close → submit |
| Who | human:bookkeeper → agent:classifier → human:senior → system:tax-portal |
| When | Month-close window, fully ordered; late changes leave new chain entries |
| Proof | Tamper-evident ledger + independent witness for submission event |
Payments, KYC, trading bots, policy gates — prove the authorization path end to end.
How it works: Policy engine or human checker runs first (governed). AI recommends approve/deny. Human override is a first-class actor event. Settlement/payment issues optional PayBotFin receipt. SOC 2 and internal audit get one timeline: policy → decision → money move.
| Fingerprint | Detail |
|---|---|
| What | kyc_check → risk_score → human_override? → authorize_payment → receipt |
| Who | system/agent + human compliance officer when required |
| When | Millisecond-ordered chain for automated paths; human steps explicit |
Access, coding suggestions, and confirmations — accountability without replacing your clinical system.
How it works: Staff access a record (human). AI suggests ICD/coding (agent). Doctor confirms (human). Each step is a governed action under the same engagement (patient visit / episode). You are not storing the full medical record in ParviGov — you store the proof of who did what when on critical operations your integration chooses to send.
| Fingerprint | Detail |
|---|---|
| What | access_record → suggest_codes → confirm_codes |
| Who | human:nurse → agent:coding → human:physician |
| When | Visit timeline sealed; overrides leave new entries |
ParviSight or any browser agent — every open, click, and extract is a governed step.
How it works: Human (or scheduler) starts a session. AI navigates portals, fills forms, captures evidence. ParviGov (when enabled) records each critical action with actor chain. Policy can fail-closed: disallowed URL never becomes a silent success. Witness proves result independently of the agent’s self-report.
| Fingerprint | Detail |
|---|---|
| What | browser_open → browser_act → browser_screenshot / extract |
| Who | human:operator + agent:parvisight (delegated_by human) |
| When | Full session engagement_id; ordered steps |
ERP, CRM, helpdesk, custom portals, CI/CD — if it can call HTTP or MCP, it is governed.
How it works: You pick the critical events (create invoice, change salary, deploy production, delete customer). Your app sends one govern-action (or SDK call) with actor type human | agent | both. ParviGov does not replace your app — it seals the proof plane beside it. Same fingerprint model everywhere.
| Fingerprint | Detail |
|---|---|
| What | Your event name + payload summary / hash |
| Who | Logged-in user, service account, or AI copilot |
| When | Chain order across microservices and UIs |
ParviGov does not replace your practice software, accounting suite, ERP, or AI tools. Those systems keep doing the job. They call ParviGov when an action must be proven.
Law practice management, document systems, tax/ERP software, ParviSight browser agents, ParviClaw control plane, custom apps, CI/CD, chatbots — anything that can call HTTP or MCP.
At each critical step: govern-action with what happened, who (human / AI / both), result, and case/session id. Your app keeps the full business record.
A governance bundle: LAG chain entry (ordered, signed) + AWP witness receipt (offline-verifiable) + optional PayBotFin commercial receipt.
Your business data stays in your systems (cases, ledgers, clients). ParviGov does not become your operational database of record. It holds the governance proof plane.
| Data | Where it lives |
|---|---|
| Matters, invoices, tax files, CRM records | Customer systems (Clio, ERP, Excel export, custom app) — not inside ParviGov |
| Cryptographic chain (who/what/when order) | LAG (its own Postgres/store) — bundled in full Docker or our SaaS |
| Independent witness receipts | AWP (library + keys; offline verifiable) |
| Commercial / authorization receipts | PayBotFin (its own store when used) |
| ParviGov itself | Bridge API/MCP on port 8740 — talks to LAG + AWP + PayBotFin |
Three ways to deploy: SaaS (we host the hub) · On-prem Docker (you run ParviGov + LAG + PayBotFin) · Hybrid (sensitive chain on-prem, witness/receipt in our cloud).
Whether SaaS, on-prem Docker, or hybrid — the integration path stays simple.
HTTP API or MCP tools. Any language. Point to your ParviGov hub (:8740) with a token. Wire LAG + PayBotFin (or use our packaged stack).
At each important step, call govern-action with what / who / result. Humans, AI, and systems share the same engagement timeline.
Verify chain offline. Export the governance bundle. Show what was done, by whom, and when — without reconstructing chat history.
ParviGov is built by FriendlyAI, a Finnish high-tech company founded by Renata Baldissara-Kunnela — a senior software testing expert with over 15 years of experience in QA and security testing, now building AI agent governance systems. The company combines deep quality assurance expertise with cutting-edge agentic AI technology.
