Skip to content
Pyrana

Platform

The platform stack, built once.

An agentic application is a full-stack business application in which people and agents work over the same pages, data, knowledge, and outputs, under one identity, one authorization model, and one audit record. The platform is built once. An application is configuration on top of it.

1cortIQ context engineSourcedevery statement citedConnectedrelated knowledge linkedVersionedhistory keptGovernedwho may change itcortIQ. The company's knowledge in one place, as small statements a person can check.cortIQ
2ConnectionsAPIsany REST or HTTP serviceDatabasesSQL and ODBC sourcesTool serversMCP, both directionsFilesdocuments and drivesIdentityas the person, or a serviceWrite-backresults where teams workConnections. Pyrana works on top of the systems the company already runs, and replaces none of them.
3AgentsSpecialistsown tools and skillsFinish checksdone means verifiedAgents. Specialists, each with one job, its own tools and a clear test for when it is done.Inside an agent4WorkflowsHierarchieslevel by level, to the topDurable runswait, resume, retryWorkflows. How many agents work together, in order, across a whole company tree.Inside a workflow5Human + AI applicationsPages and copilotone unit a business ownsRoles and scopeseach person sees their partApplications. The unit a business owns and uses: its pages, copilot, agents, data and roles in one place.Inside an App6Application statePlans and decisionswhere no system has a homeExtensionsadd what the business needsApplication state. A home for what no existing system holds: plans, decisions, reviews and exceptions.Extensions7Security and governance, around every blockCompany sign-inyour single sign-onFine-grained accessper App, entity, roleApproval by a personpolicy decides whenAudit trailwho, what, when, whyTenant isolationeach client separateSecurity and governance. Every block runs inside the same controls, set by the company.Security and trust8CodeTested codenamed data calls, scriptsNumbers by codeagents write wordsCode. A sandbox where numbers are computed, not written by a model.Numbers by code
9Models and hostingRight model per agentfrom approved providersRetries and failoverruns keep goingBudgets and limitssteps and calls cappedYour environmentprivate tenant, or your cloudPer-client deploymentown environment and dataSecure model access and hosting. The models, and the platform itself, run where the company decides.
10ObservabilityEvery run and tool callstep by stepCost and lineageof every resultObservability. Every run can be followed, step by step.One causal trace
11BuildBy conversationcopilot designs and testsIn codeSDKs and MCPVersioned configurationevery change a new versionBuild by conversation. A copilot that builds with the builder.
12Push, activate, deployVersioned releasesthe owner activates eachRelease. Changes reach each client in a controlled way.Push, activate, deploy

The Pyrana platform. Point at a block to see what it is. Blocks marked zoom open the inside view.

Built once. Configured per application.

The platform picture. Your systems of record stay the record; Pyrana works on top, reads and writes back. Point at a block for what it is; three blocks open an inside view.

00The short version

  • Built once. Configured per application.

    Ships asone App configurationimmutable versionactive pointer

  • Every door, one gate.

    DoorspagescopilotAPIMCPscheduleexternal event

  • Identity, authorization, audit, context: shared by every application.

    Shared viaaccess layersone execution recordcortIQ Context Units

00The stack

Seven layers, shared by every application.

the stack
seven layers, shared by every application
  1. Pyrana Harnessagent runtime: native tool calling · planning · subagents · checkpoints · resume
  2. Orchestrationdurable workflows that fan out, wait, retry, and finish · scheduled or on demand
  3. Tools and tool sourcesREST · ODBC · MCP and gateways · Databricks · Snowflake · Drive · OneDrive · client extensions. Each call authorized.
  4. Tool approval policiesconsequential actions queue for the right people before they execute · thresholds and named lanes
  5. Durable storageversioned resources · artifacts · the context engine's curated knowledge
  6. cortIQcompany knowledge as typed, classified, evidence-backed Context Units in a knowledge graph
  7. Surfacesthe App shell · declared pages · the copilot · pages people generate for themselves
Under all of itidentityauthorizationauditone execution record per call

01The gate

Every door. One gate. Eight steps.

A call arrives from the App's own pages, the copilot, the API, MCP, a schedule, or an external event. Before anything runs, the gate performs eight steps: identity and idempotency key; active App version; target exists and the caller is allowed; page and resource references resolved to exact versions; one authorization check (membership, profile, entitlement on the entity); idempotency claimed and the execution row and audit record written in one transaction; dispatch to the native host; outcome recorded.

The gate fails closed. Unauthorized things read as absent, not denied. One desk serves the page, the schedule, the agent, the workflow, and the external system.

the gate
fail closed
one call refused at the gate · absent from results
App UI
Copilot
API
MCP
Schedules
admission
who · authority · data · approvalAgentic AppPyrana HarnesscortIQ
gate decision
exec_01J9Q4M7Z3
execution
exec_01J9Q4M7Z3 · idempotency key idem_7f2c…41aa
caller
maya.chen · sso:entra-id → agent:close-reviewer on her behalf
app version
finance-close@v14 · sha256:3f9a71c2…e08b · active pointer
target
ledger.journal.post · exists · door=copilot · caller allowed
page / resource refs
surface close/entries · journal-batch@v3 · policy jrnl-threshold@v3 · resolved to exact versions
authorization
App member · profile=controller · entitlement entity:US-01 · lane=controllers above 25,000 USD
idempotency
claimed · execution row written · one transaction
audit
record written before dispatch · outcome recorded on return
Go deeperHow it works, step 04: the gate2 min

02Three product layers

Agentic Apps hold the configuration. The Harness runs it. cortIQ carries the knowledge.

Agentic Apps

Surfaces, targets, one gate, versioned resources.

  • One App configuration compiled into an immutable version; activation moves one pointer, rollback moves it back
  • Declared surfaces hand exact page context to the agent; targets are reachable from every door through one gate
  • Client-owned extensions run as durable backend services in the same cluster, reachable only through the platform
Agentic Apps Inside an App

Pyrana Harness

Runtime, orchestration, fan-out, approval lanes.

  • Native tool calling, planning, subagents, checkpoints, and resume; a model assigned per agent
  • Durable workflows fan out to specialized agents per entity and group; every output publishes back to the App
  • Tool approval policies: thresholds and named lanes, frozen invocations, revalidation, dispatch once
Pyrana Harness Inside an agent

cortIQ

Typed, classified, evidence-backed context.

  • Documents and tacit knowledge become Context Units: a claim, its evidence with source and location, a knowledge type, a classification, a content-hash identity
  • Three retrieval modes, knowledge, facts, and search, with standing sets preloaded before the first turn
  • Every unit is accounted for per run: retrieved, injected, cited
cortIQ

03Foundation

Identity, authorization, audit, under every layer.

The foundation is not a final check. App compilation, the gate, execution, tool calls, and resource reads all use the same identity, the same authorization layers, and the same audit record.

foundation
SSO · tenant boundary · access layers · audit

  • Identity

    SSO through Entra ID or OAuth. A person, a service, a workflow, and an agent each carry their own identity: an agent with its own identity, an agent on behalf of a user, a workflow as a service principal. All take the same authorization path, and nothing is flattened into a shared account.

  • Authorization in layers

    Tenant boundary, App membership, access profile (read, run, approve), scope entitlement on an entity, a project, or a queue, and approval lanes for consequential actions. Every layer is decided on the backend; the page only reflects it. Unauthorized items are absent from results, not denied.

  • Deployment and scale

    Hosted as SaaS on a dedicated private tenant, or deployed into the client's own infrastructure for large enterprises. Temporal workers provide durability and horizontal scaling. Separate worker pools handle data fetching, file extraction, and the code interpreter.

  • Tool sources

    REST, ODBC, MCP and MCP gateways, Databricks, Snowflake, Google Drive, OneDrive. Agents query live through tools scoped to the job, so the platform does not need to store source data. Each call is authorized and audited.

  • Model per agent

    A model is assigned per agent through provider adapters (Azure OpenAI, OpenAI, Anthropic, Fireworks, Google Gemini, and others) and is not switched mid-run. The client brings its own keys. Client data never trains external models.

  • Audit before execution

    Every admitted call writes its execution row and audit record in one transaction before dispatch: caller, App version, target, resource versions, authorization outcome, approvals, effects with receipts, and the context cited.

Go deeperSecurity and trust6 min
For engineers and architects4 min

04Configuration

One App configuration. One immutable version.

A client authors one App configuration: surfaces, targets, agents, workflows, tool sources, resources, access, knowledge. Everything the configuration names already exists in the platform. Push compiles it into an immutable version and registers the App identity. Activate moves the active pointer, is audited, and requires an App owner. Rollback is an activation of a prior version.

finance-close · App configuration
compile → version → activate
# Illustrative App configuration (excerpt). Pyrana Capital is a synthetic portfolio.
app_key: finance-close
version: v14                 # compiled, content-digested: sha256:3f9a71c2…e08b
surfaces:
  monthly-analysis: { path: /close/monthly, reads: [close.summary, variance.report] }
targets:
  monthly_analysis: { publishes: [close.summary, variance.report], doors: [page, copilot, api, mcp, schedule] }
  ledger.journal.post: { doors: [page, copilot, mcp], approval: approval.journal.amount }
agents:
  close-reviewer: { model: provider/model, tools: [ledger.accruals.list, ledger.journal.post] }
workflows:
  monthly-close: { schedule: "0 2 * * 1-5", fan_out: { agent: close-reviewer, per: entity } }
tool_sources:
  ledger: { kind: odbc, binding: erp-finance }
resources:
  close.summary: { versioned: true, stale_publish: refuse }
access:
  profiles: { controller: [read, run, approve] }
  entitlements: { controller: [entity:US-01] }
  approval:
    approval.journal.amount: { when: "amount >= 25000 USD", lane: controller-approval }
knowledge:
  standing_sets: [close-policy, entity-calendars]   # cortIQ, preloaded before the first turn
activation: v14              # one pointer; rollback moves it back

Versions

Activation moves one pointer. Rollback moves it back. The version itself never changes.

Go deeperAgentic Apps6 min
See it working

See it working

Agentic Apps on client processes.

Evaluate the platform

Evaluate the platform

The gate, tool approval policies, and the execution record, and how the platform compares.

Build on it

Build on it

The three product layers, mechanism by mechanism.

05Questions

Frequently asked

Is Pyrana a framework, a low-code builder, or an application platform?
An application platform. A framework produces an agent and leaves identity, authorization, and storage for the client to build and maintain. A flow builder produces a flow. Pyrana is a runtime and a system of record: identity, authorization, and audit on every call; durable storage and versioned resources; tool approval policies with named lanes; extensions for client-owned durable backends. An application is one App configuration plus the frontend experience.
Where is the platform deployed, and how does it scale?
Two hosting options: SaaS on a dedicated private tenant, or deployment into the client's own infrastructure for large enterprises. In both, Temporal workers provide durability and horizontal scaling. Separate worker pools handle data fetching, file extraction, and the code interpreter, so a heavy extraction job does not compete with an interactive run.
Does Pyrana need a copy of the client's data?
No. Agents query live through tool sources: ODBC, REST, MCP, Databricks, Snowflake, Google Drive, OneDrive. Tools are specific to the job: the agent passes the entity and the period, the tool holds the query. For cleansing, a code interpreter environment runs deterministic scripts inside the run, or an ETL layer upstream (for example serverless Databricks) exposes a catalog of clean views. A data quality check runs before an agent run starts.
Which models does the platform use?
A model is assigned per agent through provider adapters: Azure OpenAI, OpenAI, Anthropic, Fireworks, Google Gemini, and others. Models are not switched mid-run. The client brings its own keys, and client data never trains external models. Small, medium, and large routing for platform jobs such as summarization keeps cost in proportion to the task.
How are runs evaluated?
Every run's traces, tokens, and tool errors are captured and available as JSON. The eval pipeline runs deterministic checks first (token growth, tool error rates), then an LLM-as-judge stage in Agent Studio.
How long does an application take to stand up?
With clean data available, about a week. The App configuration, the agent configurations, and the tool bindings are configuration on primitives that already exist. The frontend experience is the main effort.
Is there an API?
A full administrative API: push and pull App configuration, start runs, read runs and traces. The same operations are reachable from the CLI, and any agent can work with an App over its MCP server as the user.

See an application admitted, run, and recorded.

One App configuration, every door, one execution record.

Book a demoHow it works