> ## Documentation Index
> Fetch the complete documentation index at: https://parabola.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# How Prowork works under the hood
> Prowork is a code-generation harness, live calculation environment, operational-data runtime, and managed-agent platform purpose-built for finance and operations.
Prowork by Parabola is a code-generation harness, live calculation environment, operational-data runtime, and managed-agent platform purpose-built for finance and operations.
This page is for the engineers, data teams, and IT leaders who evaluate, connect, and govern Prowork. It explains what is actually running when a finance analyst builds a Flow, and why that matters for the stack you already own.
## If you build software, this will look familiar
Prowork has the shape of an AI coding environment. The difference is who the developer is and what the program does.
| In an AI coding environment | In Prowork |
| --------------------------- | -------------------------------------------------------------------------------------------- |
| AI coding harness | Prowork agent, which explores data, asks clarifying questions, and creates or edits the Flow |
| Codebase | Flow |
| IDE and debugger | Visual canvas with live intermediate data at every step |
| Runtime | Prowork execution infrastructure |
| Application preview | Live data and Artifact preview |
| Deployment | Scheduled or event-triggered Flow |
| Observability | Run history, monitoring, alerts, and lineage |
| Developer | Finance or operations process owner |
The people building are not engineers, and they never need to think of themselves that way. What they produce is still an inspectable, versioned implementation of how the work gets done, not a prompt and a hope.
## The four layers
**Prowork writes the logic the process requires.** When a process owner talks through a reconciliation, a match, or an accrual, the Prowork agent explores the connected data, asks clarifying questions, and generates the code underneath. Each source, rule, calculation, decision, and exception becomes a visible, editable step on the canvas.
Steps are generated for the exact logic the process needs rather than selected only from a fixed catalog. Flows are deterministic wherever possible: the agent's build-time reasoning becomes explicit steps that run the same way every time. Agentic decision making runs at runtime only where it is necessary, such as extracting standardized fields from messy inputs like vendor PDFs or inconsistent files, through [AI steps](/docs/product/security/using-ai-steps) scoped to the columns the builder selects. [Documentation](/docs/product/overview/documents-your-flow) is generated alongside the steps and stays aligned with the implementation as it changes.
**Every step runs against real data while the Flow is being built.** The canvas shows intermediate results at each step, so the builder can inspect a join, a filter, or a calculation before moving on. [Data tracing](/docs/product/canvas/data-tracing) walks a single row or result upstream to the inputs that produced it and downstream to everything it affects.
This is the debugger. It is how a process owner proves the Flow across real examples and adds the edge cases only the team knows, without waiting for a test cycle.
**Prowork processes whole datasets, not samples.** Flows pull from ERPs, warehouses, spreadsheets, PDFs, inbound email, APIs, and partner systems, then match, calculate, and reshape across the full data. Matching, calculations, and lineage are preserved behind every result.
Structured and unstructured inputs live in the same Flow. A Flow can extract fields from an invoice PDF, join them to open POs from the ERP, apply the team's tolerance rules, and write exceptions to a queue in one pass.
**A deployed Flow is a managed agent.** It runs [on demand, on a schedule, or when a webhook or inbound email arrives](/docs/product/canvas/run-and-schedule). Prowork handles execution, [run history, failure handling, and alerting](/docs/product/canvas/monitor-and-troubleshoot), including auto-pausing a Flow after consecutive failures. Permissions, lineage, and [version history](/docs/product/canvas/draft-and-version-history) are part of the deployment, not add-ons.
## How it fits your stack
Prowork sits alongside your systems of record rather than replacing them.
Native integrations for ERPs, warehouses, file storage, email, and business apps, plus a generic [API step](/docs/product/integration/api) for anything with an HTTP interface.
Parabola Tables let one Flow write results that other Flows read, so an end-to-end process can be composed from smaller, owned pieces.
Start a Flow from your own systems with a webhook, or by forwarding an email with an attachment.
Query workspace, Flow, and run metadata from Claude, ChatGPT, or other MCP clients, scoped to the caller's existing Prowork permissions.
## Governed throughout
Business-led development only works if IT can trust the environment it happens in. The controls are built into the platform, not bolted onto individual Flows.
* **Permissions:** [Admin, Editor, and Viewer roles](/docs/product/account/team-and-permissions), scoped admin permissions, and per-Flow collaborators.
* **Identity:** [SSO through your identity provider](/docs/product/security/sso-configuration).
* **Version history:** Separate live and draft versions of every Flow, with the ability to restore an earlier version.
* **Lineage:** Row-level tracing from any result back to its source.
* **Audit:** [Audit log streaming](/docs/product/security/audit-log-streaming) to your SIEM.
* **AI data handling:** Parabola does not train models on customer data, and its model providers are contractually prohibited from doing so. [How Parabola uses AI](/docs/product/security/how-parabola-uses-ai) has the details.
## What this means for your team
The long tail of finance and operations is too bespoke for packaged software and too small or changeable to justify an engineering ticket. Without a governed place for it, that work ends up in spreadsheets, personal scripts, and one-off agents that IT eventually inherits.
Prowork gives that work a home you can inspect. Process owners build and maintain the implementation. Your team governs the environment: who can connect what, who can see what, what ran, and what changed.
Certifications, data handling, and the answers your security review will ask for.