Glossary

Appigration

Appigration is the architectural pattern of building apps, agents, and integrations as unified components rather than separate, bolted-on tools. The term combines "App" + "Integration" to describe Woork's core design principle.

Traditional enterprise platforms require separate vendors for CRM, workflow automation, AI capabilities, and system integrations. Each tool connects via APIs, creating a "daisy chain" of dependencies. Appigration eliminates this integration tax by building all three capabilities into the same platform architecture.

In an Appigration architecture, a flow can invoke an agent, which can call an integration, which can update an app — all within a single execution context with shared security, audit trails, and data model.

Agent

An agent is an AI worker that executes tasks autonomously with persistent memory, configurable guardrails, and connections to external systems. Unlike chatbots that only respond to queries, agents take action.

Woork agents can be invoked within flows, build other flows, create integrations by reading API documentation, and even build other agents. They operate with human-in-the-loop oversight when configured, pausing for approval on high-stakes decisions.

Examples include: a Compliance Reviewer agent that validates transactions against regulations, an Invoice Processor that extracts data via OCR and codes to the general ledger, or an Email Triage agent that classifies, prioritizes, and drafts responses.

Agent Builder

Agent Builder is Woork's interface for creating AI agents with reusable skills, memory, and guardrails. Agents connect to external systems via MCP (Model Context Protocol).

Users can define agent capabilities in plain English. The Agent Builder configures tools, sets operational boundaries, and establishes the skills the agent can invoke. No machine learning expertise required.

Flow

A flow is an automated sequence of actions triggered by events, schedules, webhooks, or other flows. Flows provide deterministic, repeatable process automation with full observability.

Flows can include: real-time triggers, scheduled actions, CRUD operations, API calls, conditional logic, email and SMS notifications, document generation, and agent invocations.

Unlike pure AI agents, flows execute predictably. By combining flows with agents, Woork enables intelligent reasoning where needed and deterministic outcomes where required.

Flow Builder

Flow Builder is Woork's interface for creating automations. Users can build flows visually on a canvas or describe them in natural language and let an agent generate the flow.

Flow Builder supports real-time triggers, scheduled execution, webhook listeners, database operations, external API calls, email, SMS, document generation, and agent steps.

Integration

An integration is a connection between Woork and an external system — such as Salesforce, SAP, Snowflake, or any API. Integrations enable data to flow bidirectionally between Woork and enterprise systems.

Woork integrations are not bolted on; they live inside apps and flows as native components. This means security, permissions, and audit trails apply uniformly across all connected systems.

Integration Builder

Integration Builder is Woork's no-code interface for connecting to external systems. Pre-built connectors are available for major platforms; custom APIs can be connected without writing code.

Woork agents can also build integrations autonomously. Given an API endpoint and documentation, an agent can read the docs, create the connector, and map fields — reducing integration time from weeks to minutes.

MCP (Model Context Protocol)

MCP is the Model Context Protocol — an open standard for connecting AI agents to external tools, data sources, and systems. MCP enables agents to take actions beyond text generation.

In Woork, agents use MCP to invoke skills, query databases, call APIs, and interact with enterprise systems while maintaining security boundaries and audit trails.

Guardrails

Guardrails are constraints that keep AI agents operating within defined boundaries. They prevent agents from taking unauthorized actions, accessing restricted data, or exceeding operational limits.

Woork guardrails can include: spending limits, data access restrictions, required approvals for certain actions, prohibited operations, and escalation triggers that route decisions to humans.

Human-in-the-Loop

Human-in-the-loop is an operational pattern where AI agents handle routine decisions autonomously but pause for human approval on high-stakes or ambiguous cases.

In Woork, agents can be configured to escalate specific scenarios — such as transactions above a threshold, edge cases with low confidence scores, or any action flagged by guardrails. This balances automation efficiency with human judgment.

Audit Trail

An audit trail is a complete, immutable record of every action taken within Woork — including flow executions, agent decisions, data changes, and user activities.

Woork audit trails are built for regulated industries. Every decision is traceable, every action is logged, and every AI inference is explainable. This enables compliance with banking regulations, healthcare requirements, and legal standards.

Decision Trace

A decision trace is a detailed record of how an AI agent reached a specific conclusion or action. It includes the inputs, reasoning steps, tools invoked, and outputs.

Decision traces make AI explainable. When a regulator asks "why did the system approve this loan?" or "why was this claim flagged?", the decision trace provides a complete answer.

Multi-Tenant

Multi-tenant architecture means a single instance of Woork serves multiple customers (tenants) with complete data isolation between them. Each tenant's data, configurations, and customizations are separate and secure.

Multi-tenancy enables rapid deployment, shared infrastructure costs, and automatic updates — while maintaining enterprise-grade security and compliance for each customer.