# Introduction

GLIK breathes new life into old systems: transforms static, arcane infrastructure into adaptable intelligence.

## Platform Overview

**GLIK is an** [**enterprise AI orchestration**](/system-architecture/enterprise-orchestration) **platform purpose-built to agentify complex, aging enterprise systems — unlocking trapped value from legacy software infrastructure.**

Modern enterprises operate on decades of accumulated technical debt — ERP stacks built in the 1990s, PDF-based workflows from the early 2000s, and brittle backend logic deeply embedded in organizational risk. These systems are too large to migrate, too expensive to rebuild, and too rigid to adapt. GLIK resolves this impasse.

{% embed url="<https://www.mermaidchart.com/raw/9a4bc99c-3dbe-4404-8d70-25ece055f163?theme=light&version=v0.1&format=svg>" %}
How GLIK wraps around legacy enterprise systems — converting vendor sprawl into orchestrated intelligence using plug-and-play agents. With each deployment, the enterprise compounds efficiency and extends the life of its infrastructure.
{% endembed %}

GLIK overlays these systems with intelligent agents that [**enforce policy**](/templates/policy-automation)**,** [**automate decisions**](/templates/process-automation)**, and integrate memory** — enabling immediate functionality upgrades without requiring any code changes to the legacy software underneath. Rather than replacing existing systems, GLIK **wraps around them**, transforming them into living systems ready for AI-driven operations.

> **GLIK breathes new life into old systems.**\
> It transforms static, arcane infrastructure into adaptable intelligence.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

## Why Enterprises Choose GLIK

GLIK isn’t just a new tool — it’s a strategic unlock:

* **Reduce Costs Immediately**\
  Automate high-friction decision workflows (approvals, compliance checks, routing) — eliminating manual handling and accelerating throughput
* **Compound Efficiency Over Time**\
  Each deployed agent adds compounding operational leverage — enabling economies of scale across departments, systems, and org-wide processes
* **Extend the Life of Legacy Systems**\
  Deploy AI capabilities into systems you can’t replace — SAP, NetSuite, homegrown CRM, document-based approvals — without touching the underlying code
* **Accelerate Transformation Without Risk**\
  Use GLIK to bridge your current system stack with AI-native tools — no replatforming required

GLIK enables organizations to move faster, reduce costs, and expand AI capabilities without disrupting existing architecture.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

## Enterprise Use Cases and Agent Architectures

With GLIK, you can create:

* [**Policy Enforcement Agents**](/templates/policy-automation) – Automate reviews of expenses, overtime, or access requests
* [**Knowledge Companions**](/templates/knowledge-systems) – Operationalize internal SOPs, compliance documentation, and procedural logic
* [**Forecasting & Planning Agents**](/templates/sales-and-forecasting-agents) – Use historical data to generate forward-looking decisions
* [**Internal & External Applications**](/templates/plugin-based-agent-platforms) – Deploy memory-enabled agent workflows to support internal operations or extend functionality to external business units and stakeholders.

## Enterprise Stakeholders & Usage Profiles

GLIK was designed with a variety of enterprise users in mind:

| Role                                                   | What GLIK Enables                                                 |
| ------------------------------------------------------ | ----------------------------------------------------------------- |
| **Enterprise Teams**                                   | Build secure, role-based apps with scoped memory and access rules |
| **Solutions Providers**                                | Launch and resell SaaS apps with white-label capabilities         |
| [**Developers**](/developers/overview)                 | Extend apps via plugins, tools, and OpenAPI support               |
| [**Knowledge Managers**](/templates/knowledge-systems) | Transform static documents into persistent, queryable memory      |

## Platform Architecture & Deployment Components

* [**GLIK Cloud**](/glik-cloud): A fully managed, no-code visual builder and runtime environment
* [**GLIK Knowledge**](/system-architecture/glik-knowledge): Memory system for storing, tagging, and retrieving insights
* [**Templates**](/templates/overview): Production-ready apps built for real-world enterprise use cases
* [**Blocks & Nodes**](/system-architecture/blocks-and-nodes): Modular components like LLM, Variable Assigner, Data Enrichment, etc.
* [**Cloud + Open Core**](/developers/glik-open-core): Use GLIK in the cloud, or self-host using our open core stack

{% hint style="info" %}

### Templates as Prepackaged Enterprise AI Services

[GLIK Templates](/templates/overview) aren’t mere examples — they are **prebuilt orchestration blueprints** designed to be:

* **Deployed immediately as functional** [**enterprise AI agents**](/introduction/what-is-an-agent-application)
* **Extended or white-labeled by** [**partners and developers**](/developers/overview)
* **Connected to real backend logic, memory, and data sources**

Each template represents a **targeted enterprise use case** — like expense approvals, audit workflows, logistics forecasting — and can be **rebranded or resold** as SaaS services via GLIK Cloud or partner integrations.

{% endhint %}

## What’s in This Documentation

This documentation will guide you through:

* Understanding the [core concepts](/introduction/core-concepts) that power GLIK
* Creating your first [apps](/introduction/what-is-an-agent-application) and [workflows](/glik-cloud/what-is-a-workflow) in [GLIK Cloud](/glik-cloud)
* Customizing and deploying [partner-ready templates](/templates/overview)
* Managing [knowledge](/system-architecture/glik-knowledge), roles, and session memory
* Integrating [plugins](/templates/plugin-based-agent-platforms) and external [tools](/system-architecture/blocks-and-nodes/input-and-extraction/tool-node)

> If you're just getting started, we recommend beginning with the [Getting Started](/introduction/getting-started) guide or exploring the [Core Concepts](/introduction/core-concepts) page.


# What Is an Agent Application?

Agent applications are the backbone of intelligent automation in GLIK. They go beyond chatbots or scripts — orchestrating memory, logic, policy, and decision-making across enterprise workflows.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FztiXd1Sa44B5uyThnXuT%2Fimage.png?alt=media&amp;token=a1007fc4-92a6-4b3f-ad51-922b60152054" alt=""><figcaption><p>A live GLIK agent application that automates policy evaluation. Upon receiving a user-uploaded receipt, the agent fetches the applicable policy (with retry logic), applies rule checks, and appends fallback logic if no match is found — all without human oversight.</p></figcaption></figure>

An [**agent application**](/app-types/agent) is a structured, intelligent software workflow that performs tasks on behalf of users or systems — using [logic](/system-architecture/blocks-and-nodes/logic-blocks), memory, and [automation](/templates/process-automation) to drive outcomes. In modern enterprises, agent applications are transforming how work is executed by automating [decision-making](/system-architecture/decision-routing), enforcing rules, and surfacing [knowledge](/templates/knowledge-systems) in real time.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

GLIK introduces a new operational standard for agent applications: modular, memory-aware, policy-aligned, and enterprise-ready. GLIK agent applications transform isolated workflows into intelligent systems that:

* Reduce manual effort
* Strengthen compliance
* Extend legacy systems
* Improve cross-team coordination

***

### Why Agent Applications Matter

Unlike traditional scripts or chatbots, agent applications in GLIK are designed for enterprise orchestration:

* They coordinate multiple [blocks of logic](/system-architecture/blocks-and-nodes), memory, and input/output
* They operate across [workflows](/glik-cloud/what-is-a-workflow), not just conversations
* They run with observability, structured output, and scoped access controls

Agent applications help organizations **automate judgment-based decisions**, reduce friction between departments, and ensure consistency in operational policy execution.

{% hint style="info" %}

## What “Workflow” Means&#x20;

The word **“workflow”** is used in three different contexts within GLIK:

1. [**Workflow (App Type)**](/app-types/workflow) — A specific GLIK execution model designed for automating logic using a block-based interface. It’s one of the four foundational app types alongside [Chatbot](/app-types/chatbot), [Agent](/app-types/agent), and [Advanced Chat](/app-types/advanced-chat).
2. [**Workflow (Architecture)**](/system-architecture/execution-model/workflow-architecture) — A broader concept referring to the high-level orchestration of tasks, inputs, tools, and decisions across [GLIK apps](/app-types/overview). This includes how agents interact, how memory is passed, and how execution flows are triggered across systems.
3. [**Workflow (Editor View)**](/glik-cloud/workflow-editor) — The visual interface where you arrange blocks and nodes (like Variable Assigners, Tool Nodes, LLM Blocks, etc.) to construct executable logic paths. This is where low-code users build and configure the logic of any GLIK app, even outside the Workflow App Type.

> In short: the **Workflow App Type** is one way to execute workflows — but **“workflow”** as a term also describes how logic flows and systems connect across all App Types.
> {% endhint %}

### Agentifying Enterprise Systems

One of the most powerful outcomes of agent applications is the ability to **extend the life and value of legacy systems**.

With GLIK, teams can overlay intelligent workflows on top of outdated, siloed, or inflexible systems — such as ERPs, internal portals, document workflows, or compliance checklists — without replacing the underlying infrastructure.

> GLIK agent applications "wrap" these systems in orchestration layers — bringing real-time logic, adaptive memory, and decision routing to environments that were never designed to be intelligent.

This capability unifies disparate tools and departments into **a more cohesive, traceable, and intelligent enterprise operating environment.**

***

## Characteristics of a GLIK Agent Application

| Capability           | Description                                                              |
| -------------------- | ------------------------------------------------------------------------ |
| **Autonomous**       | Executes multi-step tasks without requiring user input after initiation  |
| **Memory-Aware**     | Tracks state, context, and past actions across sessions                  |
| **Composable**       | Built from reusable building blocks (LLM, tools, logic, memory, inputs)  |
| **Policy-Driven**    | Evaluates rules, thresholds, or policy documents as part of execution    |
| **Auditable**        | Logs inputs, decisions, and escalations for review or compliance         |
| **Enterprise-Ready** | Secure, multi-tenant, deployable via cloud or self-hosted infrastructure |

## From Templates to Intelligent Agents

GLIK provides system templates that can be quickly configured and deployed as agent applications. Once live, agents can:

* Accept structured inputs (documents, variables, policy rules)
* Trigger external APIs or tools
* Return decisions, classifications, or actionable insights

{% embed url="<https://www.mermaidchart.com/raw/6116895a-80c8-4a7e-ba77-f1a604b561dd?theme=light&version=v0.1&format=svg>" %}
End-to-end user experience with a GLIK agent application — from discovering and deploying a system template, to triggering the agent for output, and iterating based on log review. It highlights the structured workflow users follow when transforming templates into intelligent, operational agents.
{% endembed %}

#### Examples include:

* Expense Policy Decision Engines
* SOP Compliance Agents
* Procurement Approval Assistants
* Knowledge Routing Agents

<details>

<summary>🛒 GLIK Marketplace (Coming June 2025)</summary>

> **The fastest way to deploy enterprise solutions.**

The [**GLIK Marketplace**](/marketplace/overview) is launching in **June 2025** as the central destination for discovering, deploying, and customizing prebuilt AI agent templates. It will allow users to:

* 🔍 **Browse production-ready templates** across industries and workflows
* ⚙️ **Deploy instantly into** [**GLIK Studio**](/glik-cloud/getting-started/glik-cloud-vs.-glik-studio) with minimal setup
* 🧠 **Explore** [**logic**](/system-architecture/blocks-and-nodes/logic-blocks)**,** [**memory**](/system-architecture/memory-and-variable-scope/memory-slot-injection)**, and orchestration patterns** by example
* 🤝 Empowers **partners and service providers** to publish white-labeled templates
* 💼 **Access solutions for real enterprise scenarios**, including SAP integration, expense automation, compliance agents, and more

</details>


# Core Concepts

Learn how GLIK is structured under the hood. This section introduces key system layers that define how your apps, workflows, memory, and logic behave inside the GLIK platform.

## GLIK Cloud vs. GLIK Open Core

[**GLIK Cloud**](/glik-cloud) is the fully managed, no-code orchestration environment hosted by [Rivalz AI](/legal/trademark-notice). It includes visual app building, runtime execution, memory, plugin support, and usage metering — all accessible via browser.

[**GLIK Open Core**](/developers/glik-open-core) is the self-hosted version of GLIK, provided as an open core CLI and runtime engine. It’s designed for engineering teams that want to run workflows in private infrastructure or embed GLIK in enterprise DevOps pipelines.

{% embed url="<https://www.mermaidchart.com/raw/72723546-875b-4103-92d7-7a07f6393a63?theme=light&version=v0.1&format=svg>" %}
Typical developer experience when working with GLIK Open Core. From cloning the runtime and configuring a self-hosted setup, to customizing agent templates and deploying workflows via CLI or Docker, this path highlights GLIK’s support for open, developer-controlled environments.
{% endembed %}

| Feature             | GLIK Cloud                | GLIK Open Core                 |
| ------------------- | ------------------------- | ------------------------------ |
| Hosting             | Managed by Rivalz         | Self-hosted (user-managed)     |
| Setup               | No setup required         | Requires deployment            |
| Best for            | SaaS apps, partner resale | Custom infra, internal tooling |
| Access to Templates | Yes                       | Yes                            |
| Plugin Support      | Marketplace only          | Custom + Marketplace           |

## GLIK Knowledge

[GLIK Knowledge](/system-architecture/glik-knowledge) is GLIK's persistent memory system — a structured way to store, recall, and query information across user sessions and apps.

Key characteristics:

* Information is stored as structured memory objects, often auto-tagged
* Memories are scoped: `User`, `App`, and `Org`
* Retrieval is done via **Knowledge Retrieval** blocks using tags or full-text queries
* Writing is performed via **Data Enrichment** blocks

Example use cases:

* Uploading strategy documents and tagging summaries per company
* Persisting user queries or session history
* Creating multi-user agents with scoped knowledge for each organization

<details>

<summary>🛒 GLIK Marketplace (Coming June 2025)</summary>

> **The fastest way to deploy enterprise solutions.**

The [**GLIK Marketplace**](/marketplace/overview) is launching in **June 2025** as the central destination for discovering, deploying, and customizing prebuilt AI agent templates. It will allow users to:

* 🔍 **Browse production-ready templates** across industries and workflows
* ⚙️ **Deploy instantly into** [**GLIK Studio**](/glik-cloud/getting-started/glik-cloud-vs.-glik-studio) with minimal setup
* 🧠 **Explore** [**logic**](/system-architecture/blocks-and-nodes/logic-blocks)**,** [**memory**](/system-architecture/memory-and-variable-scope/memory-slot-injection)**, and orchestration patterns** by example
* 🤝 Empowers **partners and service providers** to publish white-labeled templates
* 💼 **Access solutions for real enterprise scenarios**, including SAP integration, expense automation, compliance agents, and more

</details>

{% embed url="<https://www.mermaidchart.com/raw/756eb34b-7996-4735-ba62-f8493f402158?theme=light&version=v0.1&format=svg>" %}
How a GLIK agent writes structured memory into the GLIK Knowledge system, tags it with metadata, and later retrieves relevant context on future queries. The agent uses this memory to generate decisions or outputs — enabling reusable, auditable, and context-aware automation across workflows.
{% endembed %}

## Variables and Scoping

GLIK uses a robust [**variable system**](/system-architecture/memory-and-variable-scope) that enables context-aware execution and dynamic branching throughout a workflow.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

### Variable Types

* **User Input (`user_input`)** – Captured from the UI or chat input
* **Assigned Variables** – Created via the Variable Assigner block
* [**System Variables**](/system-architecture/system-observability/variable-debugging) – Runtime-assigned values like `last_query`, `retrieved_tags`, etc.
* [**Conversation Variables**](/system-architecture/memory-and-variable-scope/conversation-variables) – Persist across back-and-forth interactions in a chat or agent context. Used to hold evolving memory or user state during a conversation thread

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2F5brwJSrLJKfdLvQRRU6W%2Fimage.png?alt=media&amp;token=b2f176df-2efc-4991-a2fb-30ca7c344695" alt=""><figcaption><p>Scoped Variable Usage in GLIK Workflows: how GLIK workflows leverage different variable types — including user inputs, assigned variables, and system-defined metadata. Variables are passed into decision blocks, enabling dynamic execution paths based on structured context.</p></figcaption></figure>

### Scoping Layers

| **Scope**        | **Description**                                                                                                        | **Example**                        |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
| **Local**        | Lives only within a single block during execution. Not accessible outside it.                                          | Temporary LLM response structure   |
| **Conversation** | Persists across back-and-forth messages in a chat or agent context. Useful for conversational memory within a session. | `user_goal`, `current_topic`       |
| **Session**      | Persists across all blocks within the same app session. Cleared on session end.                                        | `company_name`, `report_year`      |
| **Global**       | Accessible across apps, workflows, and users (admin-controlled).                                                       | Org-wide config flags, shared tags |

Variables are passed through the workflow using **bindings**, evaluated dynamically by the [**Value Resolver**](/system-architecture/execution-model/input-binding-and-value-resolution), and injected into prompts and tools.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>


# Getting Started

Learn how to build, customize, and deploy your first GLIK Cloud app using visual blocks and ready-made templates.

This section will walk you through the essential steps to build your first app in GLIK Cloud. Whether you're cloning a ready-made template or building from scratch, these fundamentals will help you get up and running fast.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

## How to Create Your First App

1. Visit [**app.glik.ai**](https://app.glik.ai) and log in.
2. From the dashboard, click **New App**.
3. Choose how you want to start:
   * **Create from Blank** – Build your app block-by-block from scratch
   * **Create from** [**Template**](/templates/overview) – Clone a prebuilt GLIK app with example workflows
   * **Import DSL file** – Upload a previously exported GLIK app using the DSL format
4. Select an app type:
   * [**Chatbot**](/app-types/chatbot) – Input/output-based logic
   * [**Agent** ](/app-types/agent)– Stateful workflows with memory
   * [**Advanced Chat**](/app-types/advanced-chat) – Multi-turn assistant
   * [**Workflow** ](/app-types/workflow)– Modular blocks connected in a visual graph
5. Name your app and assign it to a workspace.
6. Click **Create** to launch the visual builder.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2F94eDrfCKRUpqQgYqmRIq%2Fimage.png?alt=media&amp;token=f9e5bbec-1704-448a-9849-c51cd3a3360a" alt=""><figcaption><p>Create from Blank lets you choose the app type, name, and optional icon before launching the editor.</p></figcaption></figure>

## Understanding App Types

| App Type          | Description                                       | Best For                            |
| ----------------- | ------------------------------------------------- | ----------------------------------- |
| **Chatbot**       | Simple input-output flow                          | FAQ bots, basic Q\&A                |
| **Agent**         | Multi-step with memory and logic                  | Process automation, memory agents   |
| **Advanced Chat** | Rich, multi-turn assistant with persistent memory | Personalized assistants, copilots   |
| **Workflow**      | Visual flow of blocks (LLM, tool, assigner, etc.) | Complex orchestration, custom logic |

***

## [Blocks & Nodes](/system-architecture/blocks-and-nodes)

GLIK apps are composed of [**blocks and nodes**](/system-architecture/blocks-and-nodes). Each block or node performs a specific function in the flow.

Common block types:

* **Input Block** – Captures user prompts or system inputs
* **LLM Block** – Generates AI responses using models like GPT
* **Variable Assigner** – Creates or updates scoped variables
* **Data Enrichment** – Writes summaries or tags to Knowledge
* **Knowledge Retrieval** – Queries memory by tags or text
* **Tool Node** – Calls external APIs or plugins (via OpenAPI)
* **Answer Block** – Displays final response to the user

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2F6fNPlfpmrLPzk80L6IrC%2Fimage.png?alt=media&amp;token=bb10c3ed-e30b-4c36-a142-2c2e579fc448" alt=""><figcaption><p>Drag, connect, and configure blocks to build logic visually — no code needed.</p></figcaption></figure>

## Using Templates

You can launch production-ready apps in minutes using GLIK’s **template library**.

To use a [template](/templates/overview):

1. Go to the **Explore** tab at [app.glik.ai](https://app.glik.ai/)
2. Find a template by tag or category (e.g., “Knowledge Companion”)
3. Click **Clone**, then customize the blocks and variables
4. Save and run it as your own application

Templates come preconfigured with:

* Data built-in memory bindings and enrichment logic
* Predefined variable flows
* Strategic prompts and workflows

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

## Previewing and Publishing

* Use **“Run”** to test an app live with sample inputs
* Once you're ready:
  * Set app visibility (Private, Team, Public)
  * Assign permissions or credits if applicable
  * Click **Publish** to activate for end users

You can always return to make changes, version workflows, or add new blocks without breaking existing flows.


# GLIK Cloud

Visual no-code platform for orchestrating memory-enabled AI applications.

**GLIK Cloud** is the fully managed, hosted environment for building, deploying, and orchestrating AI-powered applications using the GLIK platform. It provides a visual no-code editor, built-in memory architecture, and enterprise-ready permission controls — all without requiring custom infrastructure.

Whether you're developing internal tools, knowledge assistants, or white-labeled SaaS apps, GLIK Cloud helps teams build fast, iterate flexibly, and scale securely.

***

### 🔧 What You Can Do with GLIK Cloud

* Build memory-enabled workflows using visual blocks
* Upload documents, enrich them into knowledge graphs
* Inject knowledge into LLM prompts with scoped variable control
* Invite teammates to collaborate via organization workspaces
* Deploy templates across multiple clients or verticals

***

### 📚 Explore the Docs

* [Getting Started](/glik-cloud/getting-started)
* [App Types (Overview)](/glik-cloud/app-types-overview)
* [Workspaces & Permissions](/glik-cloud/workspaces-and-permissions)
* [Security & Data Handling](/glik-cloud/security-and-data-handling)

> To access the app environment directly, visit [**app.glik.ai**](https://app.glik.ai/)


# Getting Started

Learn how to start a new GLIK app using visual blocks, templates, or DSL import.

This guide walks you through how to create, configure, and launch your first app in **GLIK Cloud** — whether you're starting from scratch, cloning a ready-made template, or importing a DSL file.

## How to Create Your First App

1. Visit [**app.glik.ai**](https://app.glik.ai/) and log in.
2. From the dashboard, click **New App**.
3. Choose how you want to start:
   * **Create from Blank** – Build your app block-by-block from scratch
   * **Create from Template** – Clone a prebuilt GLIK app with example workflows
   * **Import DSL File** – Upload a previously exported GLIK app using the DSL format
4. Select your **App Type**:
   * [**Chatbot**](/app-types/chatbot) – Input/output-based logic
   * [**Agent**](/app-types/agent) – Stateful workflows with memory
   * [**Advanced Chat**](/app-types/advanced-chat) – Multi-turn assistant
   * [**Workflow**](/app-types/workflow) – Modular blocks connected in a visual graph
5. Name your app and assign it to a workspace.
6. Click **Create** to launch the visual builder.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2Fc4BORsKaY3bBQLXJnG87%2Fimage.png?alt=media&amp;token=df5697b8-0484-4ff5-ae86-32c17b004bce" alt=""><figcaption><p>What you'll see when selecting an app type and configuring basic details.</p></figcaption></figure>

## What You Can Build

Inside the visual builder, apps are composed using **modular blocks**:

* `Input Block` – Captures user input or system prompts
* `LLM Block` – Uses a language model to generate responses
* `Variable Assigner` – Sets and transforms scoped variables
* `Knowledge Retrieval` – Queries memory for contextually relevant data
* `Data Enrichment` – Writes information into GLIK Knowledge
* `Tool Node` – Calls APIs or plugins via OpenAPI
* `Answer Block` – Displays output to the user

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2F0kBN9wnO4LpZs1U7hvcm%2Fimage.png?alt=media&amp;token=b6646589-ceb4-4782-8ab8-89614b433ae7" alt=""><figcaption><p>Drag, connect, and configure blocks to build logic visually — no code required.</p></figcaption></figure>

## Next Steps

* 🔒 Learn about [**Security & Data Handling**](/glik-cloud/security-and-data-handling) in GLIK Cloud
* 👥 Review [**Workspaces & Permissions**](/glik-cloud/workspaces-and-permissions) to manage roles
* 🧠 Explore [**Templates**](/templates/overview) to deploy production-ready apps faster


# GLIK Cloud vs. GLIK Studio

Compares the roles of GLIK Cloud and GLIK Studio, helping teams understand where orchestration logic is built, executed, and managed across the GLIK platform.

GLIK Cloud and GLIK Studio are closely integrated components of the GLIK platform, but they serve distinct purposes. Understanding the difference between them is important for users building, deploying, and managing AI agent applications.

This page provides a concise comparison between the two, clarifying how each fits into the broader orchestration environment.

***

### What Is GLIK Cloud?

**GLIK Cloud** is the fully managed, browser-accessible orchestration platform hosted by Rivalz. It includes:

* A secure environment for deploying and running agent workflows
* Managed orchestration engine and memory runtime
* Multi-tenant support for teams and clients
* Integrated access to usage monitoring, template deployment, and plugin systems
* Enterprise-ready security, access control, and audit logging

GLIK Cloud abstracts infrastructure complexity, allowing organizations to operationalize agents without deploying local runtime services.

***

### What Is GLIK Studio?

**GLIK Studio** is the **visual builder interface** within GLIK Cloud. It allows users to create orchestration flows using a low-code, drag-and-drop experience.

GLIK Studio provides:

* Access to system blocks such as LLM, IF/ELSE, Tool, Doc Extractor, and more
* Visual flow logic with structured memory control
* Ability to define input fields, assign variables, and configure decision logic
* A UI-first way to prototype, test, and refine orchestration apps

While GLIK Studio is hosted inside GLIK Cloud, it is just one of several user interfaces supported by the platform (others include the CLI and DSL editor).

***

### Summary Comparison

| Feature               | GLIK Cloud                         | GLIK Studio                      |
| --------------------- | ---------------------------------- | -------------------------------- |
| Role                  | Runtime environment                | Visual builder inside GLIK Cloud |
| Access                | Platform-wide                      | App editor module                |
| Primary Audience      | Admins, architects, solution teams | Designers, builders, analysts    |
| Deployment Capability | Yes (cloud runtime + memory)       | No (outputs configuration only)  |
| Interface Type        | Web platform                       | Visual drag-and-drop             |

***

### Developer Notes

* Apps created in Studio are compiled into execution graphs within GLIK Cloud.
* The Studio uses a block-based editor that compiles into runtime nodes.
* Templates built in Studio can be versioned, published, and reused within GLIK Cloud environments or exported for use in Open Core.


# Prompt Orchestration Interface

A fast, instruction-first interface for building lightweight AI agents using prompts, tools, and context — without requiring visual workflow design. Ideal for rapid prototyping.

The **Prompt Orchestration Interface** is GLIK’s streamlined environment for designing lightweight, single-instruction agents. It allows users to rapidly build apps like chatbots, form assistants, or tool-driven prompt chains by entering structured instructions, attaching tools, and referencing memory or documents — all without needing to compose logic block by block.

This is the default interface presented when creating **Chatbot** or **Agent** apps in GLIK Studio, making it the starting point for most beginner and intermediate use cases.

{% hint style="info" %}

## What “Workflow” Means&#x20;

The word **“workflow”** is used in three different contexts within GLIK:

1. [**Workflow (App Type)**](/app-types/workflow) — A specific GLIK execution model designed for automating logic using a block-based interface. It’s one of the four foundational app types alongside [Chatbot](/app-types/chatbot), [Agent](/app-types/agent), and [Advanced Chat](/app-types/advanced-chat).
2. [**Workflow (Architecture)**](/system-architecture/execution-model/workflow-architecture) — A broader concept referring to the high-level orchestration of tasks, inputs, tools, and decisions across [GLIK apps](/app-types/overview). This includes how agents interact, how memory is passed, and how execution flows are triggered across systems.
3. [**Workflow (Editor View)**](/glik-cloud/workflow-editor) — The visual interface where you arrange blocks and nodes (like Variable Assigners, Tool Nodes, LLM Blocks, etc.) to construct executable logic paths. This is where low-code users build and configure the logic of any GLIK app, even outside the Workflow App Type.

> In short: the **Workflow App Type** is one way to execute workflows — but **“workflow”** as a term also describes how logic flows and systems connect across all App Types.
> {% endhint %}

## What is the Prompt Orchestration Interface?

This interface is a **form-based, instruction-first builder** for orchestrating AI behavior in GLIK. Instead of constructing a canvas of connected blocks, users enter:

* A main **instruction prompt**
* Optional **variables**, such as `{{user_question}}` or `{{invoice_total}}`
* Attached **tools** (e.g. Vision, Document parsing, Web Search)
* Context from **Knowledge** or uploaded content

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

Apps built in this interface execute as a **single-pass instruction pipeline**. This is ideal for:

* Quick support bots
* Verification tools (e.g. invoice checkers, policy retrievers)
* Document readers or summarizers
* Internal tool wrappers with minimal branching

***

## How It Compares to the Workflow Editor

| Feature                                                                 | Prompt Orchestration Interface | Workflow Editor                      |
| ----------------------------------------------------------------------- | ------------------------------ | ------------------------------------ |
| [Visual Canvas](/glik-cloud/getting-started/glik-cloud-vs.-glik-studio) | ❌ No                           | ✅ Yes                                |
| [Logic Branching](/system-architecture/blocks-and-nodes/logic-blocks)   | ❌ Limited                      | ✅ Full branching with nodes          |
| Memory Routing                                                          | 🔸 Basic variable use          | ✅ Scoped memory, save points         |
| Tool Integration                                                        | ✅ Supported (predefined tools) | ✅ Supported (with block logic)       |
| Multi-step Flow                                                         | ❌ Single prompt only           | ✅ Multi-block orchestration          |
| Ideal For                                                               | Fast setups, atomic tools      | Complex logic, conditional workflows |

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FvPT2WFyXiV2wGLci1ovd%2Fimage.png?alt=media&amp;token=2e37a24b-39b7-412c-823a-38579a4bf5ec" alt=""><figcaption><p>This screen shows the form-based interface used to configure a single-instruction GLIK Agent. The INSTRUCTIONS field contains the core prompt logic, while variables, tools, and knowledge can be added to enhance functionality. The live preview pane on the right displays example responses based on the configured logic, enabling fast iteration and testing without needing the full Workflow Editor.</p></figcaption></figure>

> The Prompt Orchestration Interface is optimized for **speed and simplicity**. The Workflow Editor is optimized for **custom orchestration and reusable logic structures**.

| App Type          | Default Editing Mode           | Notes                     |
| ----------------- | ------------------------------ | ------------------------- |
| **Chatbot**       | Prompt Orchestration Interface | Stateless logic           |
| **Agent**         | Prompt Orchestration Interface | Stateful, tool-using      |
| **Advanced Chat** | Workflow Editor                | Multi-turn, memory-driven |
| **Workflow**      | Workflow Editor                | Logic-first orchestration |

Apps created in Chatbot or Agent modes **begin in the Prompt Orchestration Interface**, but logic can be migrated to the **Workflow Editor** for more advanced customization when needed.

***

## Key Capabilities

* **Instruction chaining with variables**
* **Tool & plugin integration** (e.g. OCR, Web Search, Vision)
* **Knowledge referencing** (connect document or markdown)
* **Fast preview and deployment**
* **Single prompt memory and input binding**

***

## When to Use Prompt Orchestration

Use the Prompt Orchestration Interface when:

* You need to build fast, utility-style AI agents
* The logic fits into a single instruction or task
* You are wrapping existing tools or documents
* You’re building early-stage prototypes before scaling into orchestration

***

## Upgrade Path

As workflows evolve or grow in complexity, users can **transition from the Prompt Orchestration Interface into the Workflow Editor**, unlocking conditional branches, scoped memory, save points, and full orchestration logic.

> GLIK gives teams the flexibility to start fast and scale into complexity — without rewriting their apps.


# What Is a Workflow?

Explains how GLIK workflows deliver governed, reusable automation for enterprises, enabling scalable logic for both business teams and developers.

A **workflow** in GLIK is a modular, visualized execution graph that automates how tasks, tools, memory, and AI reasoning blocks are connected to complete a business objective.

Think of it as the **operating logic** behind any intelligent automation: from handling an invoice approval to triaging support tickets, surfacing knowledge from memory, or making policy decisions — the workflow is what determines what happens, in what order, and under what conditions.

<details>

<summary>Summary</summary>

In GLIK, a workflow is the bridge between business intent and system execution. It turns policy, memory, logic, and reasoning into a transparent and governable automation path — designed for enterprise-grade AI deployment.

It is the foundational structure for [intelligent agents](/introduction/what-is-an-agent-application), modular automation, and strategic reuse across the organization.

</details>

## Strategic Enterprise Value

GLIK workflows are designed not just for automation — but for **governed, explainable, and composable orchestration** at enterprise scale.

| **Value**                        | **Description**                                                                                                                              |
| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| ✅ **Business Continuity**        | Eliminates manual bottlenecks by formalizing business logic into repeatable structures — reducing operational overhead and human dependency. |
| 🔒 **Auditability & Governance** | Ensures workflows are visible, versioned, and fully traceable, enabling audit readiness and policy compliance across departments.            |
| 💰 **Cost Optimization**         | Automates routine or rules-driven decisions (e.g., approvals, routing, extraction), minimizing human workload and escalation risks.          |
| 🧱 **Enterprise Modularity**     | Each workflow block is a modular, interchangeable unit — enabling scalable orchestration patterns and cross-team reusability.                |

## How Workflows Work&#x20;

* Built visually in [**GLIK Studio**](/glik-cloud/getting-started/glik-cloud-vs.-glik-studio) using a drag-and-drop canvas
* Deployed and executed in **GLIK Cloud**, where memory, orchestration, and runtime conditions are managed
* Comprised of blocks like:
  * **Start/End Blocks** (entry + termination points)
  * [**LLM Blocks**](/system-architecture/blocks-and-nodes/input-and-extraction/llm-block) (reasoning)
  * [**Tool Nodes**](/system-architecture/blocks-and-nodes/input-and-extraction/tool-node) (external system actions)
  * [**Conditional Branches**](/system-architecture/blocks-and-nodes/logic-blocks) (logic flow)
  * [**Data & Memory Blocks**](/system-architecture/glik-knowledge) (variable assignment, enrichment, recall)

{% hint style="info" %}

* In [**GLIK Studio**](/glik-cloud/getting-started/glik-cloud-vs.-glik-studio), you configure and connect the [**LLM Block**](/system-architecture/blocks-and-nodes/input-and-extraction/llm-block) as a visual component. This is part of the front-end orchestration interface — it’s a block.
* When the app is **saved, deployed, or executed** in GLIK Cloud, that block is [**compiled into a node**](/system-architecture/blocks-and-nodes) that becomes part of the backend execution graph. This is what actually processes data, handles memory injection, and returns results.
  {% endhint %}

## For Enterprise Leaders & Decision Makers

Workflows are not just technical tools — they are:

* **Policy enforcement engines** (e.g., GLIK can encode thresholds, rules, escalation logic)
* **AI transformation blueprints** (showing exactly how and where AI decisions are made)
* **Reusable operational IP** (codifying best practices across departments)

They allow non-developers to visualize and reason about how intelligent systems are structured — without writing code.

***

### For Developers & Builders

While developers can dig into DSL and config layers, workflows in GLIK serve as the top-level executable unit.

* Every app ([Agent](/app-types/agent), [Workflow](/app-types/workflow), [Chatbot](/app-types/chatbot), etc.) is backed by a workflow
* Developers can inspect and debug each node in a flow
* Workflows can evolve over time as business logic changes — no rebuild required


# Workflow Editor

The Workflow Editor is GLIK’s visual logic builder for designing intelligent, reusable workflows across departments, systems, and tools — enabling enterprises to rapidly automate complex operations.

The **Workflow Editor** is GLIK's visual interface for designing app logic using modular blocks. Whether you're building a simple approval flow or a complex orchestration of memory, decision branches, and tool integrations, the Workflow Editor is where you structure, connect, and configure the logic behind every GLIK application.

This page explains how the Workflow Editor fits into the broader GLIK Cloud ecosystem, how it relates to core app types and execution models, and how it operates consistently across both GLIK Cloud and GLIK Open Core environments.

{% hint style="info" %}

## Not all Chatbot and Agent apps open the Workflow Editor

Some apps — especially those using the **Chatbot** or **Agent** App Types — may launch into a **Prompt Orchestration Interface** instead of the visual Workflow Editor.\
This prompt-based view supports **single-step agents** that operate from a single instruction box, using variables, tools, and memory, but **without canvas-based block chaining**.

If your use case requires conditional branching, memory-scoped flows, or agentic orchestration, use:

* [**Advanced Chat**](/app-types/advanced-chat) App Type for memory-aware conversations
* [**Workflow**](/app-types/workflow) App Type for full logic orchestration

> The visual Workflow Editor is always available — but must be accessed via App Types that support multi-step logic or by switching to canvas mode where supported.
> {% endhint %}

## What is the Workflow Editor?

The Workflow Editor is a **canvas-based design interface** that allows users to build logic visually. You arrange blocks such as `Variable Assigners`, `Tool Nodes`, `LLM Blocks`, `Conditional Branches`, and more — connecting them in sequence or through branching logic to form a complete workflow.

Every GLIK App — regardless of App Type (e.g. Chatbot, Agent, Advanced Chat, or Workflow) — uses the same Workflow Editor under the hood. The App Type determines **how the workflow is triggered and wrapped**, but the editor itself remains consistent.

***

## Where the Editor Fits in GLIK Cloud

The Workflow Editor connects to other core elements of GLIK Cloud:

* **What Is a Workflow?**\
  Introduces the conceptual definition of a workflow — a sequence of logic blocks.\
  → *The Editor is where you build and deploy that logic.*
* **App Types (Overview)**\
  Describes the differences between Chatbot, Agent, Advanced Chat, and Workflow app types.\
  → *All App Types are powered by logic designed in the Editor.*
* **Workspaces & Permissions**\
  Determines who can edit workflows, view logs, or deploy apps.\
  → *The Editor is scoped by workspace and role permissions.*
* **Security & Data Handling**\
  Defines how execution data and variable values are handled across blocks.\
  → *The Editor enables block-level memory control and secure data routing.*

***

## Also Available in GLIK Open Core

The **GLIK Open Core** version of the platform includes the same Workflow Editor interface. Whether running in GLIK Cloud or self-hosted Open Core, developers and enterprise users interact with the same visual logic designer — ensuring consistent experiences across deployment models.

This consistency allows partners and internal teams to:

* Prototype in Cloud, deploy on-prem
* Reuse workflows between hosted and self-managed environments
* Train contributors on one system and port across environments

***

## Use Cases for the Workflow Editor

| Use Case                  | Example                                                  |
| ------------------------- | -------------------------------------------------------- |
| Policy Enforcement Logic  | Expense approval workflows with scoped memory thresholds |
| Contextual Automation     | Email triage, CRM updates, or HR onboarding flows        |
| Embedded Agents           | Templates used in Advanced Chat or Agent App Types       |
| API & Tool Integration    | Executing tool nodes (e.g., external API calls)          |
| Orchestration of Subflows | Triggering nested logic paths across large organizations |

## Editor Behavior&#x20;

* **Drag-and-drop UI** with real-time logic validation
* **Input mapping and output variable assignment** per block
* **Error handling logic** and retry configuration
* **Integration with Save Point Agent**, variable scopes, and memory blocks
* **Preview mode and execution logs** (if permissions allow)


# App Types (Overview)

Outlines the available app types in GLIK Cloud and their suitability for different orchestration needs.

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>

[GLIK Cloud](/glik-cloud) supports multiple app types, each optimized for specific orchestration needs. Whether building lightweight assistants, autonomous agents, or complex enterprise flows with persistent memory, GLIK provides flexible [app types](/app-types/overview) that align with a wide range of enterprise use cases.

This guide introduces each app type available in **GLIK Cloud** and outlines when to use them in the context of a managed, browser-based environment.

{% embed url="<https://www.mermaidchart.com/raw/21d5603e-7b4d-41bb-b3d2-82bfd2af9ab2?theme=light&version=v0.1&format=svg>" %}
How different apps rely on a structured combination of uploaded documents, memory modules, and policy logic to function. Each agent pulls from a configurable set of requirements — enabling modular deployment across enterprise domains.
{% endembed %}

### App Type Comparison

| App Type                                      | Description                                                                   | Best For                                           |
| --------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------- |
| [**Chatbot**](/app-types/chatbot)             | Simple, prompt-response interaction. No persistent memory.                    | Quick utilities, testing, FAQ bots                 |
| [**Agent**](/app-types/agent)                 | Autonomous agent with reasoning and tool invocation capabilities.             | Self-driven tasks, decision routing                |
| [**Advanced Chat**](/app-types/advanced-chat) | Multi-turn memory-enabled dialog with structured memory and escalation logic. | Internal workflows, document agents, approval bots |
| [**Workflow**](/app-types/workflow)           | Single-turn orchestration for automated API chains or tool calls.             | ETL-style logic, external automation               |

### Design Philosophy

Each app type runs on the same orchestration engine but is optimized for different levels of:

* **Session duration** (single turn vs. multi-turn)
* **Memory access** (stateless vs. scoped persistence)
* **Tool coordination** (LLM-only vs. hybrid with plugin calls)
* **Enterprise readiness** (compliance, logging, fallback paths)

### Choosing the Right App Type

* Use [**Chatbot** ](/app-types/chatbot)for basic assistants with no memory or tool logic
* Use [**Agent** ](/app-types/agent)when tools, autonomous execution, or goal-seeking behavior is required
* Use [**Advanced Chat**](/app-types/advanced-chat) to manage conversational memory, approvals, or fallback escalation
* Use [**Workflow** ](/app-types/workflow)to streamline deterministic pipelines (e.g., extract → transform → export)

### Other Deployment Environments

While this page focuses specifically on app types as they appear in **GLIK Cloud**, these same app types are available in other environments such as **GLIK Open Core**. Behavioral differences, configuration options, and deployment patterns for each app type within Open Core will be covered in that section of the documentation.

Refer to [GLIK Open Core > App Types](/developers/glik-open-core) for self-hosted implementation guidance.


# Workspaces & Permissions

Explains how GLIK Cloud uses organization-scoped workspaces to manage access, invite users, and configure role-based permissions across apps, templates, and memory.

[GLIK Cloud](/glik-cloud) uses **organization-scoped workspaces** to manage apps, users, and permissions. Each workspace is associated with a specific organization, and every app, template, or memory object is scoped within that org.

***

## Creating or Joining a Workspace

To start, you’ll either:

* Create a new organization from the workspace switcher
* Or join an existing one via an invite

### Create a New Org

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2F67518ragGoraTvDVlBrF%2Fimage.png?alt=media&amp;token=1466821f-7ce7-4717-addd-222c55ed85e7" alt=""><figcaption><p>Create an Organization</p></figcaption></figure>

> Organization slugs determine the subdomain used in your GLIK Cloud URL (e.g. `rivalz.glik.ai`)

***

### &#x20;Managing Members

Admins and Owners can manage users from the **Members** tab in the Organization Settings.

You can invite teammates via email and assign their role on invite.

### Invite a User

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FWloG5ib37Cwri7scUDyN%2Fimage.png?alt=media&amp;token=c8b88e90-5307-44b5-b42a-a72aa1590ad0" alt=""><figcaption><p>Invite Modal</p></figcaption></figure>

Roles available:

* **Normal** – Can use apps but not edit system settings
* **Admin** – Can manage users, apps, memory, and integrations
* **Owner** – Full access to everything in the workspace

> 🔐 Only Owners can transfer ownership or delete an organization.

***

## General Organization Settings

Each organization also has branding and identification settings:

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FgRWIklyh1QfeOUrwJwjM%2Fimage.png?alt=media&amp;token=0f95aec2-2390-4ab4-b1aa-b14f66d6f3be" alt=""><figcaption><p>Organization Settings </p></figcaption></figure>

You can:

* Upload a logo
* Set organization name and slug
* Specify country for compliance/auditing

<details>

<summary>🔒 Coming Soon: Role-Based Memory Scoping</summary>

GLIK is expanding its permission system to support **role-based access to memory**, variables, and Save Points.

This will allow:

* **Scoped memory zones** tied to user roles (e.g. editor-only memory, admin-visible analytics)
* **Variable-level visibility** (e.g. only Owners can view or modify `org_insights`)
* **Save Point access rules** to control who can persist or recall long-term memory states

> These enhancements will provide fine-grained control over how organizational knowledge is stored, queried, and shared — especially for enterprise clients with compliance or multi-team requirements.

Stay tuned — this capability is currently under development.

</details>


# Enterprise Readiness & Compatibility

Whether you’re modernizing SAP approvals, building composable services, or coordinating cross-agent networks, GLIK enables you to orchestrate intelligence across systems.

GLIK AI is built for enterprise environments that demand compatibility, control, and composability. This page summarizes how GLIK supports protocol-agnostic orchestration, secure enterprise deployments, and fast partner onboarding — while remaining flexible enough to support emerging ecosystems such as MCP and NLWeb.

<details>

<summary>Stakeholder Summary</summary>

GLIK is protocol-flexible, security-hardened, and integration-friendly. Enterprise adopters can expect:

* MCP and A2A-compatible message passing between agents and systems
* Full SOC2 compliance and auditable workflows
* Onboarding via no-code studio or pro-code GitHub SDK
* Future-aligned architecture supporting NLWeb and next-gen agent platforms
* Self-service Marketplace launching in June 2025

</details>

## Compatibility & Trust&#x20;

GLIK Cloud and GLIK Open Core support a range of interoperability signals for enterprise evaluation, partner trust, and technical integration:

| Capability                         | Status            | Notes                                                               |
| ---------------------------------- | ----------------- | ------------------------------------------------------------------- |
| ✅ Model Context Protocol (MCP)     | Full Support      | Standardized JSON for cross-agent message passing                   |
| ✅ Agent-to-Agent (A2A) Ready       | Protocol-Agnostic | Compatible with MCP, NLWeb, and proprietary JSON payloads           |
| ✅ SOC2 Type II Certified           | Complete          | Enforces controls for data security, availability, and auditability |
| ✅ Schema-Based API Integration     | Enabled           | Auto-generates schemas for SAP, HRIS, finance systems               |
| ✅ No-Code + Pro-Code Modes         | Dual Available    | Build in GLIK Studio or extend via open-core GitHub repo            |
| 🟡 Marketplace Template Deployment | June 2025         | One-click installs, versioned publishing, and partner monetization  |

> *For implementation-level architecture and protocol schematics, see* [*Execution Model*](/system-architecture/execution-model) *→* [*Protocol Compatibility & Schema Interoperability*](/system-architecture/execution-model/protocol-compatibility-and-schema-interoperability)*.*

***

## Why Protocol Compatibility Matters

Enterprises today face a growing landscape of agent-driven technologies and interfaces — from **multi-agent frameworks like Crew AI and Autogen**, to **platform-native ecosystems like Microsoft’s NLWeb**.

## **Interoperable by Design**

* **MCP-Compatible** for enterprises standardizing JSON-based agent protocols
* **NLWeb-Aware**, supporting web-native conversational interfaces via A2A-compatible workflows
* **Composable** with any agent system that speaks structured JSON or exposes RESTful endpoints

GLIK workflows treat protocol as a **plug layer**, not a lock-in. This means:

* Partners and clients can bring their own agent stacks or message protocols
* Templates and memory variables remain portable across orchestration surfaces
* GLIK agents can act as **translators, coordinators, or execution nodes** in broader agent networks

***

## Built for Enterprise Modernization

GLIK wraps around — not replaces — enterprise systems. Its orchestration layer enables:

* **Legacy workflow automation** (SAP, policy documents, paper forms)
* **Context-aware memory** across sessions, approvals, and agent handoffs
* **Role-based routing** for complex org charts or multi-tenant environments
* **Policy enforcement blocks** with built-in schema compliance and GRC triggers

This makes GLIK a trusted modernization bridge that integrates quickly and pays off immediately.

***

## Strategic Alignment with Industry Trends

GLIK anticipates the shift toward web-native and conversational agent platforms. Microsoft’s [NLWeb](https://news.microsoft.com/source/features/company-news/introducing-nlweb-bringing-conversational-interfaces-directly-to-the-web/) highlights the next frontier of embedded, standards-based AI assistants. GLIK aligns by:

* **Publishing templates that support front-end agent integration**
* **Routing actions and memory between browser-native, API-native, and file-native surfaces**
* **Future-proofing orchestration against protocol fragmentation**

GLIK doesn’t compete with NLWeb or any specific interface layer — it complements them by handling the underlying memory, logic, and orchestration.


# Security & Data Handling

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# Expense Policy Decision Engine

Real-time decisions. Zero guesswork. Scalable compliance across your enterprise.

#### Enterprise finance teams face critical bottlenecks in expense management

* 100+ expense reports submitted weekly via **SAP Concur**
* Justification notes scattered across **Salesforce**, **Slack**, and shared docs
* Policy thresholds vary by **region, department, and role**
* Exceptions logged in outdated Notion pages or spreadsheet trackers
* Audit prep requires **manual review and custom dashboarding** in **PowerBI**

{% hint style="info" %}

#### This results in delays, confusion, policy violations, and compliance risk — every quarter.

{% endhint %}

## Features

<table data-view="cards"><thead><tr><th>Feature</th><th>Description</th></tr></thead><tbody><tr><td><strong>Live policy memory</strong></td><td>Tracks caps, exceptions, and thresholds by region, role, and scenario</td></tr><tr><td><strong>Bidirectional integrations</strong></td><td>Connects with SAP Concur, Salesforce, Slack, and audit tools seamlessly</td></tr><tr><td><strong>Automatic expense triage</strong></td><td>Handles approval, denial, flagging, and escalation workflows automatically</td></tr><tr><td><strong>Audit log generation</strong></td><td>Creates machine-readable logs for every decision with full traceability</td></tr></tbody></table>

## Before & After

| **Before GLIK**                                                            | **After GLIK**                                                          |
| -------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| A $412 dinner expense from the Singapore team is submitted in SAP          | GLIK detects the region and applies the updated $450 threshold          |
| Policy tracker says $300 is the limit, but APAC leads emailed a new policy | Updated policy is already stored in memory and applied automatically    |
| Reviewer digs through Slack, Salesforce, and Google Docs for justification | GLIK cross-references Salesforce for justification (“Q3 client summit”) |
| Decision takes hours or is approved with uncertainty                       | Flags entry as within policy and logs full audit justification          |
| No clear traceability or audit readiness                                   | Reviewer is notified via Slack with one-click confirmation              |

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FuYUWwfms8NWRHT2YoWD2%2Fimage.png?alt=media&amp;token=a28391da-829e-40d2-ac26-702bf09a2f87" alt=""><figcaption><p>GLIK agents don’t just approve or reject — they interpret, classify, explain, and escalate based on live policy memory and enterprise-specific thresholds. The result: Consistent, compliant decisions — no manual bottlenecks, no audit guesswork.</p></figcaption></figure>

## Measurable Results

<table data-view="cards"><thead><tr><th>Metric</th><th>With GLIK</th></tr></thead><tbody><tr><td>Expense approval time</td><td>⬇️ 10x faster</td></tr><tr><td>Manual policy decisions</td><td>⬇️ 80% reduction</td></tr><tr><td>Policy violations per quarter</td><td>⬇️ 60–70%</td></tr><tr><td>Audit readiness time</td><td>⬇️ Days to real-time</td></tr><tr><td>Cost of preventable overages</td><td>⬇️ $100K–$500K saved annually</td></tr></tbody></table>


# Compliance & Audit Automation

Automate audit prep. Enforce compliance. Eliminate manual drift.

GLIK’s Compliance & Audit Automation service transforms complex, multi-framework regulatory requirements into intelligent workflows that continuously validate, document, and report — without waiting for audit season.

## Status Quo

Across regulated industries and geographies, compliance leaders face growing complexity:

* Dozens of controls spread across **SOC 2**, **ISO 27001**, **HIPAA**, **MiCA**, and internal policies
* Evidence scattered across **Google Drive**, **Jira**, **Notion**, and email threads
* Updates siloed in **Word documents**, **policy PDFs**, and hard-to-audit SharePoint folders
* Manual validation processes that break down under scale and pressure
* Audit readiness that depends on key individuals and undocumented workflows

> ⚠️ Compliance is reactive, fragmented, and high-risk.

***

## GLIK Changes the Model

The GLIK Compliance & Audit Automation engine operationalizes compliance through:

* **AI agents that read, validate, and annotate compliance documents**
* **Live rule engines** tuned to frameworks like SOC 2, MiCA, ISO, GDPR, and internal SOPs
* **Cross-referencing between controls, departments, and evidence sources**
* **Audit-grade outputs**: validation logs, escalation flags, and structured reporting
* **No-code compliance workflows** that can be adapted by policy teams without engineers

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FV2RdL7wdk0qUTneOyHKv%2Fimage.png?alt=media&amp;token=0a58f0d7-7cc8-44db-97f8-06d2b36de21a" alt=""><figcaption><p>GLIK agents validate disclosure reports in real time — identifying relevant clauses, applying regulatory rulesets (e.g., MiCA, SOC 2), and producing structured outputs for audit readiness.</p></figcaption></figure>

***

## Real-World Example: MiCA Report Review

| **Before GLIK**                                                 | **After GLIK**                                                           |
| --------------------------------------------------------------- | ------------------------------------------------------------------------ |
| Regulatory disclosure is uploaded as a PDF                      | GLIK reads the document and extracts relevant sections                   |
| Reviewer manually checks each section against MiCA requirements | Agent automatically maps sections to compliance rules                    |
| Policy gaps are tracked in Notion or email                      | Issues are flagged, annotated, and logged with reasoning                 |
| Compliance team meets to interpret ambiguous clauses            | GLIK suggests resolution steps and routes unclear items for review       |
| Manual summary is built in Word for executive signoff           | Structured audit report is generated in minutes (CSV, PDF, JSON formats) |

***

## Capabilities

<table data-view="cards"><thead><tr><th>Feature</th><th>Description</th></tr></thead><tbody><tr><td><strong>Framework-aware validation</strong></td><td>Agents map controls to SOC 2, MiCA, ISO, GDPR, or internal frameworks</td></tr><tr><td><strong>Contextual cross-referencing</strong></td><td>Checks control coverage across departments, roles, and documentation silos</td></tr><tr><td><strong>Audit trail generation</strong></td><td>Every validation action is logged, timestamped, and exportable</td></tr><tr><td><strong>Escalation workflows</strong></td><td>Flags non-compliant or ambiguous areas and routes them to reviewers</td></tr><tr><td><strong>No-code policy updates</strong></td><td>Compliance teams can update logic without writing code</td></tr></tbody></table>

***

## Outcomes&#x20;

<table data-view="cards"><thead><tr><th>Metric</th><th>With GLIK Compliance &#x26; Audit Automation</th></tr></thead><tbody><tr><td>Time spent preparing for audits</td><td>⬇️ Cut by 70–90%</td></tr><tr><td>Policy validation consistency</td><td>⬆️ 100% repeatable, traceable, and auditable</td></tr><tr><td>Manual compliance mapping</td><td>⬇️ Eliminated</td></tr><tr><td>Onboarding time for new frameworks</td><td>⬇️ Days, not weeks</td></tr><tr><td>Audit trail completeness</td><td>⬆️ Machine-verified for every agent action</td></tr></tbody></table>


# Compliance Advisor Copilot

Policy analyst — deployed across teams, frameworks, and jurisdictions.

Multinationals struggle with fragmented, inaccessible, and slow-moving policy interpretation:

* Policy PDFs stored in **SharePoint, Google Drive, or Notion**
* Frameworks vary by **jurisdiction**, **team**, and **role**
* Employees file compliance queries through **email** or **Slack** — often unanswered
* Managers make decisions on **assumption, gut feel, or outdated SOPs**
* Policy drift accumulates across **HR, legal, finance, and engineering** teams

> ⚠️ This creates risk, delays, and inconsistency — especially in multi-jurisdiction organizations.

GLIK’s Compliance Advisor Copilot acts as an always-available assistant trained on your **internal policies**, **external regulations**, and **operational contexts**.

| Capability                        | Description                                                                       |
| --------------------------------- | --------------------------------------------------------------------------------- |
| **Natural language queries**      | Ask questions like “Can we approve this in Singapore?” or “Is this a GDPR issue?” |
| **Multi-jurisdiction logic**      | Understands regional policy variations and escalation rules                       |
| **Memory-backed interpretations** | Remembers past edge cases, exceptions, and clarifications                         |
| **Escalation workflows**          | Flags ambiguous queries for human review with full context trail                  |
| **Answer traceability**           | Provides citations, document references, and reasoning for each answer            |

***

### Use Cases

| **Without GLIK**                                                  | **With GLIK Compliance Advisor Copilot**                               |
| ----------------------------------------------------------------- | ---------------------------------------------------------------------- |
| Policy question is asked in Slack                                 | Query is entered in Slack, Confluence, or GLIK UI                      |
| Legal or ops teams manually check PDFs                            | Copilot interprets policy, cites rule, returns structured answer       |
| Conflicting interpretations between regions                       | Copilot applies jurisdiction-specific logic and highlights differences |
| Clarification requires email threads and waiting for legal review | Copilot auto-escalates edge cases with full context + prior decisions  |
| Compliance decisions are undocumented                             | Every query, answer, and rationale is logged and exportable for audit  |

***

## Measurable Value

| Metric                                 | Expected Impact                                  |
| -------------------------------------- | ------------------------------------------------ |
| Internal policy clarification time     | ⬇️ 80–95% faster                                 |
| Undocumented or misapplied decisions   | ⬇️ Significantly reduced                         |
| Legal/compliance team workload         | ⬇️ 40–60% drop in repetitive queries             |
| Response traceability and auditability | ⬆️ 100% — every interaction is logged            |
| Policy adoption across teams           | ⬆️ Dramatically improved with consistent answers |

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2Fc37XBMVxLTJCwCcpz58m%2Fimage.png?alt=media&amp;token=126f7138-42dc-4376-994d-88d5d643b195" alt=""><figcaption></figcaption></figure>


# Overview

Outlines GLIK's execution models to help enterprises choose the right app type for scalable automation, policy engines, conversational agents, and developer-controlled orchestration.

GLIK offers four foundational app types, each representing a distinct execution model for building and deploying intelligent systems. App types define how user input is handled, how state is managed, and which blocks and system features are available.

This guide helps teams understand when to use each type, based on enterprise scenarios such as internal approvals, client-facing automation, agent workflows, or memory-aware assistants.

***

### 🧩 GLIK App Types at a Glance

| App Type          | Execution Model                  | Ideal For                                       |
| ----------------- | -------------------------------- | ----------------------------------------------- |
| **Chatbot**       | Stateless, prompt-response logic | Basic Q\&A bots, static form handlers           |
| **Agent**         | Stateful with scoped memory      | Policy engines, multi-step enterprise flows     |
| **Advanced Chat** | Threaded, turn-based interaction | Assistants, advisors, conversation memory       |
| **Workflow**      | Graph-based logic with branching | Conditional processes, escalation, integrations |

### Use Case Breakdown & Guidance

#### **1. Chatbot**

**Model:** Stateless input/output\
**Best For:**

* Simple support bots (FAQs, policy links)
* Front-line triage in internal tools
* Single-turn verification bots (e.g., invoice status check)

**Limitations:**

* No persistent state or scoped memory
* Cannot use advanced memory or fallback blocks
* Not suitable for multi-step processes or regulated logic flows

***

#### **2. Agent**

**Model:** Stateful with memory and policy enforcement logic\
**Best For:**

* Expense approval agents
* HR onboarding logic
* Compliance evaluations
* Vendor risk screening

**Features:**

* Scoped memory (`invoice_data`, `policy_memory`, etc.)
* Full access to Variable Assigners, IF/ELSE, Tool Nodes
* End-to-end workflow continuity

**Considerations:**

* Does not use threaded chat interface
* LLM blocks must be explicitly invoked as steps
* Memory must be manually written/read using memory blocks

***

#### **3. Advanced Chat**

**Model:** Conversational memory and multi-turn assistant\
**Best For:**

* Executive assistants
* Internal helpdesk bots
* SOP navigators
* Contract review advisors

**Features:**

* Supports `conversation_variables` natively
* Allows fallback memory injection into prompts
* Multi-turn interaction flows without defining graph logic

**Caveats:**

* Cannot chain logic using IF/ELSE or Tool blocks
* Not ideal for deterministic policy enforcement
* Suited for reasoning and conversational exploration, not decision routing

***

#### **4. Workflow**

**Model:** Visual flow with branching logic and tool integrations\
**Best For:**

* Escalation frameworks (e.g., “if fails → reroute”)
* Multi-agent orchestration
* Cross-system automation (API → plugin → memory)
* Human-in-the-loop decision gates

**Features:**

* Full block access: LLM, Tool, Data Enrichment, Save Point, Knowledge
* Conditional logic supported at multiple branches
* Integrates with external APIs and internal memory stores

**Caveats:**

* Requires upfront logic design
* Best suited for technical users or implementation partners
* Works best with deterministic or well-scoped problem domains

***

### Memory & Variable Support Summary

| Feature                      | Chatbot | Agent | Advanced Chat | Workflow |
| ---------------------------- | ------- | ----- | ------------- | -------- |
| Conversation Variables       | ✖       | ✖     | ✅             | ✖        |
| Scoped Memory (e.g. session) | ✖       | ✅     | ✅             | ✅        |
| Tool Node / Plugin Access    | ✖       | ✅     | ✖             | ✅        |
| Conditional Routing          | ✖       | ✅     | ✖             | ✅        |
| Visual Flow Design           | ✖       | ✖     | ✖             | ✅        |

### Choosing the Right App Type

| Scenario                                          | Recommended App Type |
| ------------------------------------------------- | -------------------- |
| Automating policy approval workflows              | Agent or Workflow    |
| Building an internal compliance chatbot           | Advanced Chat        |
| Creating a no-memory Q\&A interface               | Chatbot              |
| Integrating multiple decision layers with routing | Workflow             |
| Designing a memory-enabled SOP navigator          | Advanced Chat        |
| Embedding policy logic into a partner SaaS tool   | Agent                |


# Chatbot

Stateless app type for fast, low-overhead enterprise Q\&A and support flows—ideal for simple automation without memory or branching.

GLIK defines **app types** as structured execution models that determine how workflows are built, how state is handled, and which system features are available. Each app type reflects an intentional tradeoff between control, complexity, and capability.

<details>

<summary>Summary</summary>

The Chatbot app type offers the most efficient way to deploy focused, stateless logic within GLIK Cloud. It is ideal for front-line automations, high-traffic Q\&A, and internal enterprise knowledge access.

It should be selected when the business need favors:

* Simplicity
* Predictability
* Speed
* Stateless interaction

For regulated processes, memory retention, or multi-step reasoning — escalate to a stateful app type.

</details>

GLIK Cloud currently supports four core app types:

* **Chatbot** (stateless Q\&A logic)
* **Agent** (stateful memory-driven logic)
* **Advanced Chat** (threaded conversational logic)
* **Workflow** (graph-based, condition-driven orchestration)

Understanding app types is essential to selecting the right execution mode for your enterprise use case.

***

### Chatbot App Type

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FY0N2zs7PAq7YINLL7WyF%2Fimage.png?alt=media&amp;token=4c614d57-d36d-4196-accb-5656bf520cc4" alt=""><figcaption><p>Provides a streamlined interface for creating stateless LLM-based chatbots with simple configuration, ideal for Q&#x26;A, internal support, and lightweight enterprise automation.</p></figcaption></figure>

The **Chatbot** app type provides a stateless, single-turn execution model. It is optimized for lightweight prompt-response use cases such as FAQ bots, static data lookups, or simple internal triage systems.

Chatbot apps:

* Accept user input
* Run a single structured response generation via LLM or tool logic
* Return a response without storing memory across sessions

It is the **lowest-complexity** app type in GLIK, designed for rapid deployment and minimal state management.

***

### When to Use a Chatbot&#x20;

| Scenario                        | Use Chatbot?      | Recommended Alternative        |
| ------------------------------- | ----------------- | ------------------------------ |
| Static FAQs                     | ✅ Yes             | —                              |
| Single-step form assistant      | ✅ Yes             | —                              |
| Expense escalation or approvals | ❌ No              | Agent or Workflow              |
| Document summarization          | ✅ Yes (stateless) | Agent if multiple turns needed |
| Memory-aware triage bot         | ❌ No              | Advanced Chat or Agent         |
| Regulated or auditable process  | ❌ No              | Workflow                       |

### Enterprise Strategic Value

While simple, the Chatbot app type delivers real business value in enterprise environments:

<table data-view="cards"><thead><tr><th>Value Area</th><th>Benefit Summary</th></tr></thead><tbody><tr><td><strong>Cost Efficiency</strong></td><td>- Minimal model usage per request - No need for memory or session tracking</td></tr><tr><td><strong>Speed to Deployment</strong></td><td>- Build and publish chatbots in minutes via GLIK Studio - No orchestration or branching logic</td></tr><tr><td><strong>Security &#x26; Control</strong></td><td>- Statelessness lowers risk of memory leakage - Simple validation is easier to audit and log</td></tr><tr><td><strong>Business Use Cases</strong></td><td>- Internal tools (policy lookup, HR, IT) - Customer-facing Q&#x26;A (pricing, docs, support) - Embedded chat in SaaS apps</td></tr></tbody></table>

### Developer Considerations

Enterprise developers using the Chatbot app type should be aware of its **limitations and boundary conditions**:

#### ✅ What Works Well:

* Prompt + single output logic
* Frontline decision routing
* Integration with static data tools or API responses

#### ❗ Key Limitations:

* No persistent state or scoped memory
* Cannot use fallback blocks or conditional routing
* No branching logic

Developers should **avoid overloading Chatbots** with multi-step reasoning or dynamic memory use cases — escalate to Agent or Workflow when complexity rises.


# Agent

Agents are the action layer of the GLIK platform — performing complex work invisibly, accurately, and repeatably.

The **Agent App Type** is designed for creating purpose-built, autonomous agents that perform targeted actions or complete multi-step processes — typically without a chat interface or ongoing conversation.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2Fj9FweG87l7NO5unzqmS7%2Fimage.png?alt=media&amp;token=126f3098-7206-4f3d-a2ca-092b5f92dbde" alt=""><figcaption><p>GLIK Agent performs multi-step reasoning, invokes external tools, and uses variable memory to complete tasks autonomously. It shows an agent orchestrating search actions, interpreting results, and responding intelligently — without requiring ongoing user intervention.</p></figcaption></figure>

Agents can be:

* Embedded inside apps or workflows
* Triggered by API calls, events, or forms
* Assigned to handle **discrete jobs** using orchestration logic, memory, and tools

GLIK Agents are ideal when you want **AI-powered action**, not just conversation or interface logic. They act on behalf of users or systems — ingesting context, reasoning through decisions, and executing tasks across one or more services.

***

## What makes Agents different?

| Feature          | Agent App Type                                                                     |
| ---------------- | ---------------------------------------------------------------------------------- |
| **Interface**    | No frontend chat required; runs silently or behind other UIs                       |
| **Trigger**      | External input, task queue, form, system event                                     |
| **Focus**        | Task completion, decision enforcement, orchestration                               |
| **Intelligence** | Agent-specific prompt logic + memory + dynamic tools                               |
| **Examples**     | - File classification agent- Contract summarizer- Internal support ticket resolver |

## When to use Agent instead of other types

Use an **Agent** when:

* You want **autonomous execution** without relying on a user conversation
* The task is **repeatable, structured, and logic-heavy**
* You need to **embed intelligence into a backend service**, workflow step, or plugin
* A chat interface or visual logic is unnecessary for the end user

***

## Enterprise Examples

| Scenario                   | Agent Function                                   |
| -------------------------- | ------------------------------------------------ |
| Document Upload            | Automatically classify, tag, and forward file    |
| Support Intake             | Extract intent and route to correct department   |
| Procurement Review         | Enforce cost thresholds + escalate violations    |
| Legacy CRM Action Trigger  | Fill out structured forms via internal API call  |
| Onboarding Pack Generation | Generate personalized policy PDF + metadata logs |

## How Agents Fit into the GLIK Stack

* **Workflow App**: Orchestrates logic
* **Advanced Chat App**: Interfaces with users
* **Agent App**: Executes tasks or decisions autonomously
* Agents can be **spawned by other apps**, or triggered via **API/Webhook/Form** and report back silently to orchestration layers.


# Advanced Chat

Use Advanced Chat when your workflows are too dynamic or nuanced to predefine entirely — but too important to leave to stateless bots.

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>

GLIK’s **Advanced Chat** [**App Type**](/app-types/overview) provides a structured, memory-aware conversational interface designed for multi-turn interactions. Unlike traditional chatbot implementations, which rely on single-turn prompt/response logic, Advanced Chat is built for scenarios where decisions, state, and role-based context must persist across multiple inputs and steps.

{% embed url="<https://www.mermaidchart.com/raw/abb4db22-728c-48c9-bf92-aeb6bae16220?theme=light&version=v0.1&format=svg>" %}
Highlights how multi-turn compliance guidance and internal policy advisory represent the largest adoption areas, while dynamic SOP walkthroughs and HR assistants demonstrate the flexibility of conversational agents in more contextual, role-specific scenarios.
{% endembed %}

## Why not just use a Chatbot?

[Basic Chatbots](/app-types/chatbot) are ideal for surface-level queries — such as FAQs, policy lookups, or verification tasks — where user input is predictable, and no decision memory is needed. However, once a conversation requires follow-up steps, user-specific state, policy routing, or cross-referencing internal data, Chatbots break down.

**Advanced Chat steps in where Chatbot ends.** It retains memory across turns, manages branching logic conversationally, and allows agents to evolve the dialogue as conditions or variables change. This enables use cases like internal compliance advisory, step-by-step HR onboarding, or triaging enterprise issues across departments.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

## Why not just use Workflow?

[Workflows in GLIK](/glik-cloud/what-is-a-workflow) are ideal for **structured automation with visual logic flows** — where decisions are predefined and users follow form-based or UI-driven steps. However, some enterprise interactions cannot be adequately reduced to buttons and branching trees. These include:

* Policy advisory situations with nuanced judgment
* Triage flows where user narratives shape decision logic
* Situations where **flexible conversational routing** is faster than visual branching

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FUpySu1NgKupBl1HLw7VB%2Fimage.png?alt=media&amp;token=c2b7739d-d54b-4488-a56e-84edf9400d19" alt=""><figcaption><p>App Type Selection Screen in GLIK Studio — This interface allows users to choose the execution model for a new GLIK application. Select from four App Types: Chatbot (stateless), Agent (stateful tool-using), Advanced Chat (multi-turn memory-aware dialog), and Workflow (visual orchestration for single-turn tasks). Each type is optimized for different levels of complexity, user interaction, and enterprise automation needs.</p></figcaption></figure>

Advanced Chat gives users the **natural interface of conversation**, but underpinned by powerful agent orchestration logic — meaning agents can store variables, invoke fallback logic, run subroutines, or escalate to workflows when thresholds or exceptions are hit.

In fact, **Advanced Chat includes orchestration** — it can invoke [blocks](/system-architecture/blocks-and-nodes), use memory variables, and even trigger workflows under the hood. But it presents this orchestration **as a conversational experience**, ideal for roles like advisors, analysts, or end users who prefer dialog over dashboards.

***

#### 💼 Executive Summary

| App Type          | Ideal For                                            | Memory | Orchestration |
| ----------------- | ---------------------------------------------------- | ------ | ------------- |
| **Chatbot**       | Simple Q\&A bots, single-turn logic                  | ❌      | ❌             |
| **Advanced Chat** | Multi-turn advisory, context-aware guidance          | ✅      | ✅             |
| **Workflow**      | Structured automations, backend system orchestration | ✅      | ✅ (visual)    |

***

#### 📈 GLIK Advantage

GLIK’s Advanced Chat mode allows enterprises to **wrap conversational intelligence around aging systems**. Whether it’s an outdated HR platform, a compliance portal with buried logic, or a PDF-based SOP flow, Advanced Chat turns those static tools into interactive agents — reducing cognitive load and accelerating user task completion.

> Use Advanced Chat when your workflows are too dynamic or nuanced to predefine entirely — but too important to leave to stateless bots.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>


# Workflow

GLIK Workflows turn static rules into real-time automation, enabling legacy systems to operate with AI-like responsiveness — without modification.

The **Workflow App Type** is GLIK’s most structured execution model, designed for automating rule-based processes using a visual block-based interface. It excels in scenarios where inputs, logic branches, and system behavior can be clearly defined up front. This makes it ideal for implementing **repeatable, auditable, and governed enterprise operations** — especially where compliance, routing, or integration requirements are complex but predictable.

{% hint style="info" %}

## What “Workflow” Means&#x20;

The word **“workflow”** is used in three different contexts within GLIK:

1. [**Workflow (App Type)**](/app-types/workflow) — A specific GLIK execution model designed for automating logic using a block-based interface. It’s one of the four foundational app types alongside [Chatbot](/app-types/chatbot), [Agent](/app-types/agent), and [Advanced Chat](/app-types/advanced-chat).
2. [**Workflow (Architecture)**](/system-architecture/execution-model/workflow-architecture) — A broader concept referring to the high-level orchestration of tasks, inputs, tools, and decisions across [GLIK apps](/app-types/overview). This includes how agents interact, how memory is passed, and how execution flows are triggered across systems.
3. [**Workflow (Editor View)**](/glik-cloud/workflow-editor) — The visual interface where you arrange blocks and nodes (like Variable Assigners, Tool Nodes, LLM Blocks, etc.) to construct executable logic paths. This is where low-code users build and configure the logic of any GLIK app, even outside the Workflow App Type.

> In short: the **Workflow App Type** is one way to execute workflows — but **“workflow”** as a term also describes how logic flows and systems connect across all App Types.
> {% endhint %}

## What sets Workflow apart?

While **Chatbots** and **Advanced Chat** are interaction-first models optimized for human-facing interfaces, **Workflow is system-first**. It doesn't rely on conversation — instead, it executes decisions, data transformations, or system calls based on preconfigured logic flows. Think of it as a **logic circuit for enterprise tasks**, where each block is a switch, each variable a wire, and each output a controlled signal.

Enterprises use GLIK Workflows to:

* Automate **multi-step approvals**
* Execute **decision trees based on policy thresholds**
* Trigger **system integrations or API calls**
* Coordinate **cross-system actions** like ticket generation or database updates

This App Type is often embedded as the **core logic engine** beneath other experiences — such as agents or conversational frontends — making it the backbone of scalable orchestration in enterprise environments.

{% embed url="<https://www.mermaidchart.com/raw/21d6fd94-1efd-49f0-b878-c22056fbd1da?theme=light&version=v0.1&format=svg>" %}
How users move from conceptual understanding to practical application of the Workflow App Type. It helps teams recognize when system-driven logic is more efficient than conversational AI, leading to faster deployment of rule-based automations.
{% endembed %}

## Why not just use Advanced Chat?

Advanced Chat is ideal when workflows must adapt to user responses, unknown inputs, or free-form conversations — but when the flow of logic is **predictable**, predefined, and not reliant on long-form input, **Workflow is more efficient and easier to maintain**. It provides:

* **Full visibility** over logic and branching
* **Clear audit trails** for compliance and governance
* **Reusable logic blocks** across multiple apps or templates

In short: **Use Advanced Chat when user input drives logic**; **use Workflow when logic drives execution**.

***

## When to choose Workflow

| App Type          | Best When…                                  | Input Type             | UI Model                 |
| ----------------- | ------------------------------------------- | ---------------------- | ------------------------ |
| **Chatbot**       | You need static responses to simple prompts | Stateless messages     | Simple Q\&A              |
| **Advanced Chat** | Conversations shape logic, memory required  | Multi-turn dialogue    | Dynamic chat             |
| **Workflow**      | Execution follows clear, visual logic paths | Form, variable, system | No chat; system-executed |

## Enterprise Value&#x20;

GLIK’s Workflow App Type is the fastest way for enterprises to **digitize and automate legacy processes** without requiring new software or retraining end users. Whether triggered by a form submission, agent escalation, or system event, workflows handle the invisible heavy lifting — evaluating inputs, applying rules, and orchestrating downstream actions.

> GLIK Workflows turn static rules into real-time automation, enabling legacy systems to operate with AI-like responsiveness — without modification.


# Overview

Ready-to-run orchestration templates for modernizing enterprise operations without replacing core systems.

For most enterprises, AI adoption is blocked by one persistent reality: **legacy systems**. These platforms — SAP, NetSuite, Oracle, in-house ERPs — are deeply entrenched, expensive to replace, and central to daily operations. But their rigidity prevents enterprises from capitalizing on the rapid acceleration of AI capabilities.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FORE7CQl5TapvLC3yhKax%2Fimage.png?alt=media&amp;token=e0a2793e-6ab0-4689-81af-6d0f67a2bad3" alt=""><figcaption><p>Anatomy of a GLIK Template: how GLIK templates encapsulate structured inputs, conditional logic, and reusable policy blocks — all configurable without code. Users can launch from prebuilt templates and adapt decision flows in minutes.</p></figcaption></figure>

**GLIK Templates** offer a different path forward.

{% embed url="<https://www.mermaidchart.com/raw/fcdb6ac5-a2ee-4670-ac47-b6b3217fae73?theme=light&version=v0.1&format=svg>" %}
Exploring, evaluating, and deploying a GLIK Template. It illustrates how enterprise users — from architects to operations leads — move from discovery to real-world deployment, highlighting the key decisions, interactions, and value checkpoints along the way.
{% endembed %}

Rather than replacing legacy software, GLIK Templates act as **intelligent overlays**. They allow enterprises to plug in modular, agent-driven orchestration flows that enhance what’s already there. No rebuilds. No migrations. No disruption.

Each template is a **ready-to-run application** that injects memory, logic, policy awareness, and agentic behavior into outdated systems — unlocking new value immediately.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

GLIK Templates are not theoretical models — they are **deployment-ready orchestration blueprints** that:

* Detect and integrate with real-world systems and workflows
* Use structured blocks and memory logic to reason, route, or escalate
* Apply existing enterprise rules and policies
* Deliver automation in **high-risk, high-complexity sectors** like finance, compliance, logistics, and defense
* Scale across roles, teams, and partners using no-code tools

Templates can be deployed in **GLIK Cloud** or packaged for white-label SaaS products.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

### Template Genres

<table data-view="cards"><thead><tr><th>Genre</th><th>Purpose</th><th>Example Use Cases</th></tr></thead><tbody><tr><td><a href="/templates/policy-automation"><strong>Policy Automation</strong></a></td><td>Automate decisions using uploaded documents and pre-existing rules</td><td>- Expense policy enforcement- Procurement thresholds- HR policy checks</td></tr><tr><td><a href="/templates/compliance-and-audit-automation"><strong>Compliance and Audit Automation</strong></a></td><td>Monitor, log, and escalate events tied to compliance or regulatory policy</td><td>- SOC 2 &#x26; ISO checks- Access logs- Policy violation escalation</td></tr><tr><td><a href="/templates/compliance-advisors"><strong>Compliance Advisors</strong></a></td><td>Interactive agents that answer policy-related queries</td><td>- Internal policy helpdesk- Legal documentation guidance- Security copilot</td></tr><tr><td><a href="/templates/knowledge-systems"><strong>Knowledge Systems</strong></a></td><td>Agents that retrieve and apply structured knowledge or documentation</td><td>- SOP interpreters- Training walkthroughs- Audit history referencing</td></tr><tr><td><a href="/templates/process-automation"><strong>Process Automation</strong></a></td><td>Agentified flows that automate business procedures</td><td>- Procurement pipelines- HR onboarding- Multi-document workflows</td></tr><tr><td><a href="/templates/task-resolution-agents"><strong>Task Resolution Agents</strong></a></td><td>Purpose-built agents that complete specific, bounded actions</td><td>- Email triage- Invoice validation- Exception handling</td></tr><tr><td><a href="/templates/work-coordination-agents"><strong>Work Coordination Agents</strong></a></td><td>Orchestrate tasks, nudges, and handoffs between departments or roles</td><td>- SLA management- Workflow bridging- Asynchronous coordination</td></tr><tr><td><a href="/templates/embedded-operational-copilots"><strong>Embedded Operational Copilots</strong></a></td><td>In-tool agents that support decision-making inline</td><td>- ERP overlays- Field service assistants- On-screen policy copilots</td></tr><tr><td><a href="/templates/expense-and-erp-agents/erp-vendor-ai-copilots-and-agents"><strong>Expense &#x26; ERP Agents</strong></a></td><td>Templates built specifically for aging ERP and expense systems</td><td>- SAP expense validation- NetSuite approval flows- ERP data reconciliation</td></tr><tr><td><a href="/templates/inventory-and-logistics-agents"><strong>Inventory &#x26; Logistics Agents</strong></a></td><td>Agents that reason over stock, supply chains, and time-sensitive logistics</td><td>- Inventory tracking- Just-in-time planning- Black Friday logistics</td></tr><tr><td><a href="/templates/sales-and-forecasting-agents"><strong>Sales &#x26; Forecasting Agents</strong></a></td><td>Predictive agents that model trends and plan resource allocation</td><td>- Seasonal demand planning- Dynamic pricing- Pipeline forecasting</td></tr><tr><td><a href="/templates/plugin-based-agent-platforms"><strong>Plugin-Based Agent Platforms</strong></a></td><td>Agent templates built for embedding into SaaS tools or API frameworks</td><td>- White-label copilots- MSP agent stacks- Plugin marketplaces</td></tr></tbody></table>


# Policy Automation

Transform rule-based decisions into scalable AI agents that reduce costs, enforce compliance, and accelerate approvals.

GLIK’s Policy Automation capabilities allow enterprises to codify decision logic from existing documents — such as expense policies, procurement rules, and compliance guidelines — into autonomous agents. These agents apply policy in real time, handle exceptions via LLM fallback, and escalate when ambiguity arises.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2Fsl6rurrS2t6yXPnIYtL0%2Fimage.png?alt=media&amp;token=10749ee9-6685-42af-8f2d-3e7344374ba6" alt=""><figcaption><p>End-to-End Orchestration in GLIK: A GLIK agent that integrates with SAP/Oracle APIs to retrieve, interpret, and apply enterprise expense policies.</p></figcaption></figure>

* Fetches an expense policy from an external enterprise system
* Uses fallback logic for default policies if retrieval fails
* Applies the policy to uploaded receipts (PDFs/images)
* Returns real-time responses to users with high reliability and low latency

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

By transforming policies into workflows, organizations reduce decision latency, enforce rules consistently, and save on labor costs — all while maintaining a transparent, traceable audit trail.

### Enterprise Benefits

<table data-view="cards"><thead><tr><th></th><th></th></tr></thead><tbody><tr><td>💸 <strong>Cost Savings</strong></td><td>Reduce time and labor required for manual policy review, especially in finance, HR, and compliance workflows.</td></tr><tr><td>🔍 <strong>Policy Enforcement</strong></td><td>Eliminate human error by ensuring all rules are enforced uniformly across teams and departments.</td></tr><tr><td>⚖️ <strong>Compliance Readiness</strong></td><td>Maintain auditability with traceable agent actions, memory snapshots, and escalation logs.</td></tr><tr><td>🚀 <strong>Scalable Decisions</strong></td><td>Handle high volumes of decisions (e.g. invoices, approvals) without increasing headcount.</td></tr><tr><td>🧠 <strong>Explainability</strong></td><td>Agents explain why decisions were made — citing policy clauses and thresholds with human-like summaries.</td></tr></tbody></table>

### Use Case Categories

* **Finance**: Expense reports, reimbursement approvals, budget threshold checks
* **Procurement**: Purchase requests, vendor validation, cost limit enforcement
* **HR & Operations**: Travel approvals, policy acknowledgment workflows
* **Compliance**: Sanction list checks, policy enforcement logs, exception routing

***

### GLIK Agent Capabilities

GLIK agents can:

* Extract structured data from PDFs or images (OCR-ready)
* Compare extracted values against a memory-stored or uploaded policy book
* Make decisions using threshold rules (e.g. "under $100", "vendor not blacklisted")
* Escalate to a human or LLM reasoning block when unclear
* Log the entire decision path for audit or QA review

<details>

<summary>🛒 GLIK Marketplace (Coming June 2025)</summary>

> **The fastest way to deploy enterprise solutions.**

The [**GLIK Marketplace**](/marketplace/overview) is launching in **June 2025** as the central destination for discovering, deploying, and customizing prebuilt AI agent templates. It will allow users to:

* 🔍 **Browse production-ready templates** across industries and workflows
* ⚙️ **Deploy instantly into** [**GLIK Studio**](/glik-cloud/getting-started/glik-cloud-vs.-glik-studio) with minimal setup
* 🧠 **Explore** [**logic**](/system-architecture/blocks-and-nodes/logic-blocks)**,** [**memory**](/system-architecture/memory-and-variable-scope/memory-slot-injection)**, and orchestration patterns** by example
* 🤝 Empowers **partners and service providers** to publish white-labeled templates
* 💼 **Access solutions for real enterprise scenarios**, including SAP integration, expense automation, compliance agents, and more

</details>

### Economic ROI Snapshot

| **Area**             | **Before GLIK**             | **After GLIK Agent Automation** |
| -------------------- | --------------------------- | ------------------------------- |
| Expense Review Time  | 3–5 minutes per report      | <30 seconds per report          |
| Manual Reviewer Cost | $25–$60/hr (Finance/HR)     | Near-zero per case              |
| Error Rate           | Inconsistent (policy drift) | Consistent rule enforcement     |
| Escalation Handling  | Unstructured emails         | Logged, traceable routing       |
| Audit Readiness      | Manual export, inconsistent | Auto-generated logs per case    |

### Real-World Outcomes

> A mid-size organization processing around **3,000 expense reports per month** can save up to **$8,000–$9,000 monthly** by automating first-pass reviews using an AI agent app trained on the company's own expense policy.
>
> These savings are driven by a **70% reduction in manual review effort**, faster turnaround, and the elimination of up to **95% of preventable policy violations** — especially those related to missing documentation, amount thresholds, or disallowed expense types (e.g., alcohol).
>
> By codifying policies into reusable agent workflows, organizations unlock scalable enforcement while significantly reducing operational costs.

<details>

<summary>📊 Supporting Industry Benchmarks</summary>

* **Manual Processing Costs**: According to the Global Business Travel Association (GBTA), the average cost to process a single expense report manually is **$58**, and correcting errors adds another **$52** per report. ([Fyle](https://www.fylehq.com/blog/expense-management-software-roi?utm_source=chatgpt.com))
* **Error Rates**: Approximately **19%** of expense reports contain errors, leading to significant additional costs and time spent on corrections. ([NetSuite](https://www.netsuite.com/portal/resource/articles/financial-management/expense-management-automation.shtml?utm_source=chatgpt.com))
* **Time Savings**: Companies have reported **58% reductions** in hours spent on expense management by implementing AI-powered automation. ([Yokoy](https://yokoy.io/case-studies/case-study-buhler-spend-management/?utm_source=chatgpt.com))
* **Return on Investment (ROI)**: Businesses processing **500 expense reports monthly** have saved over **100 hours of labor**, translating to thousands in cost savings. ([Fyle](https://www.fylehq.com/blog/the-roi-of-expense-management-and-cash-management-automation?utm_source=chatgpt.com))

</details>


# Overview

Describes GLIK templates that automate rules-based enterprise decisions, such as expense approvals and compliance enforcement.

Policy Automation templates in GLIK are designed to enforce and operationalize internal business rules and governance standards through intelligent agents. These templates enable organizations to ensure that policies are applied consistently, efficiently, and with audit-ready traceability—without requiring manual intervention at every step.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2F3K38fKsYQHISN7P8Zwuv%2Fimage.png?alt=media&amp;token=fa5ed9cf-34d7-4e16-902e-b1d6f0d78d9b" alt=""><figcaption><p>Example GLIK Studio setup for policy logic binding. Agents ingest uploaded or memory-stored policy rules and dynamically apply them to structured inputs using scoped variables and knowledge-aware retrieval.</p></figcaption></figure>

GLIK’s Policy Automation agents analyze uploaded files, form data, or system variables against defined rulesets such as:

* Expense thresholds
* Overtime regulations
* Procurement restrictions
* Compliance checklists

These workflows are built to mirror how policy evaluation occurs within enterprise systems such as SAP, Workday, or ServiceNow—while leveraging LLM-based reasoning and memory for flexibility and adaptability.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

### Key Characteristics

<table data-view="cards"><thead><tr><th></th><th></th></tr></thead><tbody><tr><td><strong>Rules-Driven</strong></td><td>Logic flows are configured around policy enforcement, not open-ended dialog.</td></tr><tr><td><strong>Input-Aware</strong></td><td>Accept structured forms, uploaded documents, or user-supplied variables.</td></tr><tr><td><strong>Escalation-Ready</strong></td><td>Escalates decisions to human approvers when criteria are unclear or conflicting.</td></tr><tr><td><strong>Memory-Aware</strong></td><td>Stores past decisions, policy logic, and organizational parameters for continuity.</td></tr></tbody></table>

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

### Use Cases

These templates are suited for:

* Finance teams automating approval flows
* Compliance teams enforcing regulatory adherence
* HR or operations ensuring procedural governance

### Deployment Environments

Policy Automation agents are deployable:

* Internally via GLIK Cloud (role-restricted workflows)
* As part of white-labeled SaaS offerings (with partner-specific policy sets)
* In hybrid environments integrating third-party APIs (e.g., SAP policy plugins)


# Expense Policy Validator — Summary Sheet

A plug-and-play policy enforcement agent that reduces audit risk and accelerates expense approvals.

## Problem

Enterprises lose significant time and audit reliability when enforcing expense policies manually. Finance teams must cross-check receipts, approvals, and exceptions across disparate systems — often from static PDFs, Excel files, or HR portals. This leads to slow approvals, inconsistent enforcement, and non-compliant reimbursements.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FiT3EZm3ECLSZ0na9ueyU%2Fimage.png?alt=media&amp;token=d1167f5d-de1a-4d60-89dd-1316ba6f7a6f" alt=""><figcaption><p>This final segment of the workflow compiles and transmits the outcome of the expense validation process. After all checks and decision logic are executed, the system formats the result into a structured JSON payload (Build JSON Payload), including approval status, reasons, and escalation flags. The result is then delivered to an external system such as an ERP platform, audit log, or reimbursement portal (Submit to Expense System). The session is formally concluded with a closure block (Close Validation Session), ensuring clean termination and traceability.</p></figcaption></figure>

## Agent Architecture

**Input:**

* Uploaded receipt image or expense submission
* Optional: Attached policy document (`.pdf`, `.md`, `.csv`)

## **Processing Workflow**

1. **OCR Block** – Extracts data from receipt (vendor, amount, date, etc.)
2. **Variable Assigner** – Normalizes inputs (e.g., `expense_total`, `category`, `receipt_vendor`)
3. **Memory Retrieval Block** – Loads `policy_memory` for threshold values and blacklisted vendors
4. **Conditional Logic Block** – Checks thresholds, flags compliance issues
5. **LLM Block (Fallback)** – For ambiguous cases, generates escalation message
6. **Output Block** – Returns:
   * ✅ Approved
   * ❌ Rejected with reason
   * 🔁 Escalation suggested (if ambiguous)

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FmXSD8ToaLA9mJOjIddno%2Fimage.png?alt=media&amp;token=5a3da877-2812-4aef-8479-fd24b7dfce8f" alt=""><figcaption><p>This conditional branch handles expense reports that fall outside policy thresholds. The system first classifies the severity of the violation (Classify Violation Severity) and routes the case accordingly. If the violation is clear-cut, the workflow generates a rejection message with reasoning and audit trace metadata (Render Rejection Summary). If the violation is ambiguous or edge-case, it escalates the issue to a designated agent (Escalate to Policy Officer) who may trigger human-in-the-loop review or override logic. All escalation events are persistently logged (Log Escalation Event) for audit compliance and retrospective analysis.</p></figcaption></figure>

## Strategic Value

* **90%+ reduction in manual reviews** for standard expense categories
* **Audit-ready compliance trail** for finance teams
* **MCP-compatible JSON structure** for downstream integration with ERP or financial systems
* Deployable via **no-code GLIK Studio** or installable from the **GLIK Marketplace** (June 2025)


# Enterprise Policy Intelligence

GLIK transforms disconnected policy documents into intelligent automation surfaces — delivering real-time enforcement, auditability, and cross-departmental orchestration.

Enterprises are built on policies — from compliance handbooks to engineering standards, procurement thresholds, and sales compensation rules. But too often, these documents live in disconnected systems: SharePoint folders, PDF repositories, legacy intranets, or tribal knowledge.

**GLIK turns these dormant rules into intelligent, agent-driven workflows.**

By ingesting, interpreting, and versioning enterprise policies, GLIK enables agents that:

* Enforce policies in real time
* Escalate edge cases using LLMs
* Log every decision path for compliance
* Adapt to new policy versions automatically
* Operate across departmental lines (Finance, Sales, Legal, HR, Engineering)

***

### How It Works

| **Function**                 | **GLIK Agentification Mechanism**                                                           |
| ---------------------------- | ------------------------------------------------------------------------------------------- |
| Ingest Policy Documents      | Uploads PDFs, DOCX, or knowledge base text into structured memory using **Knowledge Block** |
| Policy Parsing + Structuring | Extracts thresholds, rule logic, blacklists, exception conditions                           |
| Version-Aware Routing        | Agents check current version tags to apply correct policy scope                             |
| Departmental Routing         | Agents reference metadata to route decisions to Finance, Sales, or HR agents as needed      |
| LLM Fallback for Ambiguities | Unclear or edge-case decisions are handed to an LLM block for reasoning or escalation       |
| Change-Trace Logging         | All actions logged via **Audit Block** with version-based context trail                     |

{% embed url="<https://www.mermaidchart.com/raw/6a89d17d-4a3c-4bb3-9ca1-2d5dbd5ea96c?theme=light&version=v0.1&format=svg>" %}
From ingestion and rule parsing to real-time enforcement and ROI capture, GLIK creates a closed-loop system that not only automates policy execution but also adapts to future updates — enabling scalable compliance and measurable operational gains across departments.
{% endembed %}

## Enterprise-Wide Impact

When GLIK agentifies policies, the effect compounds across the organization:

* ✅ **Finance:** Expense thresholds, approvals, budget caps
* ✅ **Procurement:** Vendor rules, sourcing controls, preferred supplier logic
* ✅ **Engineering:** Security checklists, code release gating, compliance checklists
* ✅ **Sales & Ops:** Commission policies, approval chains, exception handling
* ✅ **HR & Legal:** Overtime rules, onboarding SOPs, regulatory training

Every policy becomes a live automation surface.

***

## Benefits at Scale

* 📉 **Reduce decision latency and labor costs**
* 🧠 **Codify tribal knowledge into persistent memory**
* 🔄 **Adapt faster to policy updates — without re-training staff**
* 🔍 **Gain full auditability with zero additional work**
* 🏗️ **Build enterprise-wide policy enforcement without integrations**


# Expense Policy Decision Engine

Automates organizational expense reviews by applying policy logic to uploaded documents using memory-aware agents.

The **Expense Policy Decision Engine** templates are a GLIK workshop series focused on building intelligent, memory-aware agent applications for enterprise expense automation. This learning module introduces practical agent orchestration techniques while demonstrating how GLIK templates can digitize and automate complex policy enforcement processes.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2Faba5EXSTGUUCNAzuAAXm%2Fimage.png?alt=media&amp;token=69301077-2e0a-4f96-8d48-f1abc009b448" alt=""><figcaption><p>Example multi-receipt evaluation with inline policy reasoning. The agent justifies rejections based on alcohol restrictions, cost limits, and missing managerial presence — and approves valid claims under policy thresholds.</p></figcaption></figure>

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

Each version in the workshop showcases a progressively advanced implementation of the same core use case: **automated expense approval using structured logic, document ingestion, and scoped memory**.

The series begins with a simple file-based decision agent and scales toward production-grade policy enforcement integrated with knowledge memory, LLM reasoning, and escalation systems.

### Workshop Objectives

The following section outlines the high-level learning outcomes of this GLIK workshop series.

<table data-view="cards"><thead><tr><th>Objective</th><th>Description</th><th data-hidden data-type="files"></th></tr></thead><tbody><tr><td><strong>Agent Application Design</strong></td><td>Understand the structure and role of agent applications within the GLIK orchestration platform</td><td></td></tr><tr><td><strong>Scoped Memory &#x26; Variables</strong></td><td>Identify how scoped memory and variables function in dynamic approval workflows</td><td></td></tr><tr><td><strong>Logic &#x26; Extraction Blocks</strong></td><td>Gain hands-on experience with conditional logic, memory retention, and document extraction blocks</td><td></td></tr><tr><td><strong>Policy Automation Principles</strong></td><td>Apply policy automation principles to real-world business rules</td><td></td></tr><tr><td><strong>Deployment Considerations</strong></td><td>Navigate access control, escalation triggers, and output formatting in enterprise environments</td><td></td></tr></tbody></table>

| Goal                               | Description                                                                     |
| ---------------------------------- | ------------------------------------------------------------------------------- |
| **Construct Reusable Agents**      | Teach participants how to construct a GLIK agent from reusable blocks           |
| **Explore Agent Memory Design**    | Explore memory usage, conditional branching, and document parsing               |
| **Prototype Real-World Scenarios** | Prototype agentified systems that apply organizational policies in real time    |
| **Modernize Legacy Workflows**     | Demonstrate how AI agents can modernize finance workflows across legacy systems |

### Example Use Cases

This workshop applies to teams automating:

* Employee-submitted expense requests
* Vendor invoice approvals
* Procurement policy enforcement
* Cross-departmental compliance automation

***

### Workshop Tracks

Each track is a standalone agent template with its own GitBook subpage:

| Version                          | Description                                                         |
| -------------------------------- | ------------------------------------------------------------------- |
| `v0 – Starter`                   | Upload a policy document and receipt. Agent returns approve/reject. |
| `v1 – Threshold Memory`          | Adds scoped session memory for dynamic rule tracking.               |
| `v2 – Policy API Integration`    | Pull rules from an external service or plugin.                      |
| `v3 – Multi-Policy & Escalation` | Handle complex rulesets and edge-case escalation.                   |

Participants may implement these agents incrementally or fork from the template directory to create custom variants.

***

### Prerequisites

* GLIK Cloud access (v1.2+)
* Workspace with File Upload and Memory Window features enabled
* Sample invoice files or receipts (PDF or image format)
* Optional: organizational policy book (PDF or structured JSON)

***

### Try the Starter Template

👉 [Explore the Starter Template](https://chatgpt.com/templates/policy-automation/expense-policy-decision-engine-starter)

This template demonstrates a basic agent that applies approval thresholds based on a file-uploaded policy document. Ideal for proving out the GLIK memory model and file-based automation workflows.


# Expense Policy Decision Engine (Starter)

This workshop introduces the **starter version** of the Expense Policy Decision Engine — a simple, document-driven GLIK agent that evaluates expense submissions against organizational policy thresholds.

The goal of this lesson is to give participants hands-on experience working with GLIK’s orchestration interface, memory objects, conditional logic, and agent-based decision routing. It is ideal for first-time users or teams exploring how GLIK can automate legacy, rules-based workflows.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

### 🔍 What This Agent Does

This GLIK agent automates the first stage of policy enforcement by evaluating uploaded expense documents (such as receipts or invoices) against preset business logic defined in a policy file. The agent can:

* Ingest receipts (PDF/image)
* Extract fields (amount, category, vendor, etc.)
* Compare extracted values to rules from a policy document
* Decide to **approve**, **reject**, or **escalate** based on thresholds or ambiguity

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2Fo1UCl6l1gP1nW96MHtmS%2Fimage.png?alt=media&amp;token=a998b6b7-ebb6-432a-8ab9-061796e6124a" alt=""><figcaption><p>Sample Expense Report — This invoice will be used in the Starter template walkthrough to demonstrate how the GLIK agent evaluates policy compliance based on extracted data.</p></figcaption></figure>

### 🧩 Key Components

| Component             | Function                                                          |
| --------------------- | ----------------------------------------------------------------- |
| **Start Block**       | Accepts file uploads (receipts, invoices) and optional user notes |
| **Doc Extractor**     | Parses uploaded documents into structured key-values              |
| **Data Enrichment**   | Normalizes formats and adds metadata (optional)                   |
| **Variable Assigner** | Stores parsed values in memory as `invoice_data`                  |
| **IF/ELSE Logic**     | Compares values against the uploaded policy memory                |
| **LLM Block**         | Adds explanation or fallback reasoning if logic is unclear        |
| **End Block**         | Outputs a decision response (approve/reject/escalate)             |

### 🎓 Learning Outcome

By completing this lesson, participants will be able to:

* Build and test a working GLIK agent using real invoice examples
* Understand how file parsing and scoped memory interact in GLIK
* Modify logic thresholds in the policy document to control agent behavior
* Identify key escalation points and extend functionality in later versions

***

### 📁 Practice Materials

> You can use the following sample receipts and policy files to test the agent template.

**Google Drive Folder:** [Access Example Files](https://drive.google.com/drive/u/4/folders/1vsqVOVTpaMwrtEsWBLqxQwlNeNaU8kuo)

*Receipts and policy book samples are provided in the folder above. These materials are for testing purposes only and can be substituted with actual enterprise documents when ready.*


# Practice Exercises

These exercises will guide you through testing the **Expense Policy Decision Engine (Starter)** using real-world policy logic and receipt samples. You’ll explore document parsing, memory variable use, and policy enforcement decisions.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

### 🔧 Setup Requirements

* Access to the deployed Starter agent in GLIK Cloud
* Uploaded [**Sample Expense Policy Book**](https://drive.google.com/drive/u/4/folders/1vsqVOVTpaMwrtEsWBLqxQwlNeNaU8kuo) (if needed)
* Receipt files:
  * [Receipt 1: Business Lunch – Compliant](https://drive.google.com/file/d/1-ILUeMe1_QUQBVDdwfkMby9PYdX3RabZ/view?usp=drive_link)
  * [Receipt 2: Hotel Stay – Compliant](https://drive.google.com/file/d/1P--Lh5MILOwIgK793zNa50TDWtYxfuOB/view?usp=drive_link)
  * [Receipt 3: Dinner + Wine – Non-Compliant](https://drive.google.com/file/d/1cmRUwFgeRfMSsU2hFCg0AgTOHCMGrAd5/view?usp=drive_link)

***

### 🧪 Exercise 1: Policy Match – Guest Entertainment

#### File: `Receipt_1.pdf`

1. Upload the sample policy document.
2. Upload `Receipt_1.pdf` (Business Lunch with client).
3. Ask the agent: `Should this be approved?`
4. Review:
   * `approval_result` = `approved`
   * Check justification for guest documentation and policy match.

✅ **Expected Outcome**: Receipt is **approved** under the guest entertainment policy ($48/person under $75, no alcohol, proper account code).

***

### 🧪 Exercise 2: Policy Match – Hotel Travel

#### File: `Receipt_2.pdf`

1. Reuse the uploaded policy book or upload again.
2. Upload `Receipt_2.pdf` (Hotel Stay).
3. Ask: `Is this reimbursable?`
4. Verify:
   * Agent parses per-night cost.
   * Travel justification is accepted.

✅ **Expected Outcome**: Receipt is **approved** because hotel cost is under $200/night and marked as approved travel.

***

### 🧪 Exercise 3: Policy Violation – Alcohol + Threshold

#### File: `Receipt_3.pdf`

1. Upload `Receipt_3.pdf` without a justification note.
2. Ask: `Can this expense be reimbursed?`
3. Review:
   * Alcohol detection
   * Per-person cost overage
   * Absence of executive override
   * `approval_result` = `rejected` or `escalate`

✅ **Expected Outcome**: Receipt is **rejected** for multiple violations (alcohol, per-person cost > $50, no exception).

***

### 🧩 Optional Exercise: Add a Justification Note

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FqDphp7KBXd4kzYrdR40f%2FIMG_1837.jpeg?alt=media&amp;token=fce5ed81-a205-4126-b0e7-42fcbbedc622" alt=""><figcaption><p>Example of dynamic policy override: When a justification note is added citing executive approval, the agent reevaluates the expense and reverses the original rejection based on updated policy conditions.</p></figcaption></figure>

Re-test `Receipt_3.pdf` but add this note:

> “Executive sponsor John Ramirez was present and approved the team celebration.”

Ask: `Does this change the outcome?`

⚠️ **Expected Outcome**: If logic is configured to check notes for escalation triggers, this may shift the result to **escalate** instead of immediate rejection.

***

### 🧠 Debug Tips

* Open the memory panel and inspect:
  * `invoice_data`
  * `approval_result`
  * `policy_memory`
* Test edge cases: remove account codes, increase amounts, or upload without a policy file


# Expense Policy Decision Engine (Threshold Memory)

Automates policy-driven expense approvals using structured memory, threshold logic, and LLM reasoning to reduce review costs and ensure compliance.

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>

This workshop guides you through the **Threshold Memory** version of the [Expense Policy Decision Engine template](/templates/policy-automation/expense-policy-decision-engine) — a rules-based workflow for automating expense report approvals using GLIK Cloud.

This version builds upon the Starter template, adding memory-aware decision logic and fallback pathways using [LLM reasoning](/system-architecture/blocks-and-nodes/input-and-extraction/llm-block/llm-reasoning). It demonstrates how policies can be encoded, recalled, and applied using conversation variables, branching logic, and optional escalation.

{% embed url="<https://www.mermaidchart.com/raw/e93c59d6-2588-475e-a63a-34308c379357?theme=light&version=v0.1&format=svg>" %}
This diagram shows how GLIK workflows dynamically apply memory-based policy thresholds using conditional logic. If no clear rule matches, fallback to LLM ensures decisions remain explainable.
{% endembed %}

### 🧭 What You’ll Learn

{% hint style="info" %}
**How Thresholds Work:** This [workflow](/glik-cloud/what-is-a-workflow) evaluates uploaded invoices against policy thresholds stored in memory (policy\_memory). If the invoice exceeds a category-specific limit or the global threshold, the system either rejects or escalates. For unmatched or ambiguous cases, it falls back to [LLM reasoning](/system-architecture/blocks-and-nodes/input-and-extraction/llm-block/llm-reasoning) for justification.
{% endhint %}

* How to structure a policy-driven approval agent in [GLIK Studio](/glik-cloud/getting-started/glik-cloud-vs.-glik-studio)
* How to extract structured data from uploaded files
* How to apply policy thresholds using [IF/ELSE logic blocks](/system-architecture/blocks-and-nodes/logic-blocks/if-else-branch)
* How to use conversation memory (`policy_memory`, `invoice_data`, etc.)
* How to handle ambiguity with [LLM fallback responses](/system-architecture/decision-routing/llm-fallthrough-patterns)

### 🛠️ Prerequisites

<table data-view="cards"><thead><tr><th>Topic</th><th>Description</th></tr></thead><tbody><tr><td>🎛️ GLIK Studio Interface</td><td>Review the <a href="/glik-cloud/getting-started/glik-cloud-vs.-glik-studio#what-is-glik-studio">GLIK Studio</a> interface and how <a href="/glik-cloud/app-types-overview">app types</a> are structured in GLIK Cloud.</td></tr><tr><td>🧱 Starter Template</td><td>Start with the <a href="/templates/policy-automation/expense-policy-decision-engine/expense-policy-decision-engine-starter">Expense Policy Starter</a> version before continuing with this Threshold Memory variant.</td></tr><tr><td>📂 Sample Files</td><td>Have a <a href="https://drive.google.com/drive/u/4/folders/18_aO02dinEDpndkjF3olUKsiEgrfEjqB">sample invoice</a> (PDF format) and, optionally, a policy document ready for upload.</td></tr></tbody></table>

### 🧱 Workshop Sections

1. **Template Overview**\
   A summary of all blocks and variables used.
2. **Block-by-Block Walkthrough**\
   Detailed breakdown of each node’s purpose and configuration.
3. **Threshold Logic & Memory Usage**\
   How policy thresholds are applied using memory variables.
4. [**LLM Fallback for Ambiguity**](/system-architecture/decision-routing/llm-fallthrough-patterns)\
   How to design graceful degradation to language models.
5. **Deployment & Testing**\
   Steps to test the flow and validate decision logic.

***

### 📁 Files & Resources

Use these practice files to simulate real-world invoice reviews. Upload them via the Start Block to test dynamic threshold evaluation and LLM fallback behavior.

* 📝 [Sample Expense Policy Book](https://drive.google.com/drive/u/4/folders/18_aO02dinEDpndkjF3olUKsiEgrfEjqB)
* 📄 [Example Chrome River-style invoice PDF](https://drive.google.com/drive/u/4/folders/18_aO02dinEDpndkjF3olUKsiEgrfEjqB) (upload via Start Block)
* 🧠 Coming soon: `policy_book.yml` for structured rule ingestion


# Practice Exercises

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>

These exercises help you test dynamic threshold evaluation using memory-stored policy logic in the **Threshold Memory** version of the Expense Policy Decision Engine.

***

### 📁 What You’ll Need

* `Expense Policy Book (Threshold Memory Version).md` (this may already be preloaded — check your workspace before uploading)
* Any of the following receipt files:

| File Name            | Description                             | Expected Outcome |
| -------------------- | --------------------------------------- | ---------------- |
| `Receipt_1_Only.pdf` | Blacklisted vendor: ACME Consulting     | ❌ Rejected       |
| `Receipt_2_Only.pdf` | Equipment > $3000 default threshold     | ❌ Rejected       |
| `Receipt_3_Only.pdf` | Blacklisted + over threshold            | ❌ Rejected       |
| `Receipt_4_Only.pdf` | Split invoices, suspicious behavior     | ⚠️ Escalate      |
| `Receipt_1.pdf`      | Compliant meal receipt with guest names | ✅ Approved       |
| `Receipt_2.pdf`      | Hotel < $200/night, pre-approved travel | ✅ Approved       |
| `Receipt_3.pdf`      | Alcohol + per-person limit exceeded     | ❌ Rejected       |

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FDNKx2PiG0OWdsirvzB3m%2Fimage.png?alt=media&amp;token=cc815b47-a809-4dd3-9df9-9be7fd3906d5" alt=""><figcaption><p>This <a href="https://drive.google.com/drive/u/4/folders/18_aO02dinEDpndkjF3olUKsiEgrfEjqB"><strong>folder</strong></a> contains all the required files for testing the Threshold Memory template, including the .yml workflow file, the preconfigured policy book (.md), and a set of labeled receipt PDFs. Students can use these to simulate various approval scenarios and observe dynamic threshold evaluation in action.</p></figcaption></figure>

### 🚀 Instructions

#### 1. Load or Upload the Policy File

Check if `Expense Policy Book (Threshold Memory Version).md` is already loaded in your workspace. If not, upload it when prompted in the Start Block.

#### 2. Upload a Receipt File

Choose one of the provided PDFs to upload as your test input.

#### 3. Use This Prompt in Chat:

```
Can you review this receipt and let me know if it complies with policy?
```

#### 4. Observe the Output

* Check that the assistant uses `policy_memory` to reference thresholds.
* Confirm whether it uses category-specific limits or global fallback.
* Look for mention of blacklist flags, metadata requirements, or compliance notes.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FRnKLjJYIHbDv93ERsCyp%2Fimage.png?alt=media&amp;token=b2bd59e9-167e-4083-a961-1887e0ff6e5f" alt=""><figcaption><p>This screenshot showcases the GLIK assistant evaluating uploaded receipts using memory-based policy thresholds. It dynamically references structured rules from the policy book, compares amounts against category-specific or global limits, and clearly explains each approval or rejection decision. Ideal for demonstrating how compliance logic is enforced through memory-scoped orchestration.</p></figcaption></figure>

### ✅ Success Criteria

* Assistant clearly identifies the matching policy rule
* Output includes a comparison (e.g., `$3,400 > $1,500 limit`)
* Final status is shown: `✅ Approved`, `❌ Rejected`, or `⚠️ Escalate`
* Reasoning is transparent and uses memory-based logic

***

Try different combinations of receipts to explore various logic paths in the workflow.


# Threshold Agent Response Tuning Exercises

These hands-on exercises help learners understand how to modify and tune assistant behavior in the **Threshold Memory** template by editing key blocks. You'll learn how to change how the agent evaluates, explains, and responds to policy violations.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

## Objectives

* Learn which blocks control logic, memory, and response formatting
* Customize fallback behavior and explanation style
* Practice modifying output to match business tone or policy emphasis

***

## Blocks to Explore

| Block Name           | Role in the Workflow                                        | Tips for Editing                             |
| -------------------- | ----------------------------------------------------------- | -------------------------------------------- |
| `Metadata Assigner`  | Sets key memory variables and conversation metadata         | Add tags like `review_required` or `flagged` |
| `Expense Evaluation` | Runs comparison logic (amount vs. threshold, vendor checks) | Modify IF/ELSE branches or add filters       |
| `Fallback Reasoning` | LLM-based explanation block for ambiguous or missing logic  | Change prompt tone or level of formality     |
| `Final Decision`     | Outputs `APPROVED`, `REJECTED`, `ESCALATE` with reason      | Customize wording or formatting              |

## Exercise 1: Change How Violations Are Explained

**🎯 Goal:**\
Make fallback explanations more formal, structured, and compliance-focused — especially when policy violations are detected.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FgwBjPG2FoQk6dveYCtuu%2Fimage.png?alt=media&amp;token=f3c209d9-808f-4fdc-9cb3-834c997f656f" alt=""><figcaption><p>This block is responsible for explaining whether a receipt is approved or rejected based on policy thresholds. To modify how violations are communicated, click into PROCESS REQUEST and edit the SYSTEM prompt tone — make it more formal, friendly, or tailored to your organization’s communication style.</p></figcaption></figure>

#### ✅ Steps

1. **Open the LLM Block** (currently titled "LLM")
2. **Locate the SYSTEM message** under the `Context` section
3. **Modify the final explanation sentence of the `<Example>` block** to read:

   ```
   Reason: This expense violates policy due to exceeding the threshold without an exception rule. A formal review is required for compliance logging.
   ```

   *(This replaces the current: “No exception rule found. Logged for escalation or review.”)*
4. Optionally, tweak the opening sentence of the SYSTEM prompt to reinforce tone:

   ```
   You are a compliance-focused corporate accountant. Review the receipt and policy to determine validity using formal, transparent justifications.
   ```
5. **Save and re-test** using:\
   `Receipt_4_Only.pdf`\
   *(This file contains a suspicious invoice split pattern and exceeds the global threshold)*

{% hint style="info" %}

#### The LLM is used here as a **fallback explanation agent**, especially when the IF/ELSE blocks don’t capture ambiguous or edge-case logic. This edit lets learners experiment with **output tone**, **formality**, and **compliance narrative structure** — without altering business logic.

{% endhint %}

## **Exercise 2: Tone Tuning in the Fallback Reasoning Block**

#### **Goal**

Teach users how to modify the fallback LLM block’s response tone when no policy match is found or ambiguity arises (e.g. split invoices, unclear categories).

***

#### **Why This Matters**

* Helps enterprise users adjust how AI communicates policy enforcement (e.g. strict vs supportive tone)
* Ensures responses align with internal brand or compliance voice
* Enables better UX when agents must reject or escalate expenses

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FiMyYxYhRM2guuLyHJoOp%2Fimage.png?alt=media&amp;token=03d9f161-9103-4493-8559-ae916083d440" alt=""><figcaption><p>To customize how the assistant responds in ambiguous or policy-missing cases, click into this block and edit the system prompt tone. Try adjusting language for different enterprise communication styles (e.g. formal, supportive, strict).</p></figcaption></figure>

#### **Steps**

1. **Open the LLM Fallback Block**
   * Locate the block that handles ambiguous or missing-policy cases (typically tagged `<policy>` and `<receipts>`)
2. **Identify the Current Prompt**
   * Look for something like:

     ```jinja2
     Please review the following receipt in the context of the policy:
     <policy>{{policy_memory}}</policy>
     <receipts>{{receipt_text}}</receipts>
     ```
3. **Modify the Tone**
   * Try rewriting the prompt in one of the following styles:
     * 🔍 **Strict:**

       > “This expense appears to violate corporate policy and will be flagged for immediate rejection.”
     * 💼 **Professional:**

       > “Based on the provided policy, this expense may not be compliant. Please advise.”
     * 🤝 **Supportive:**

       > “This expense might fall outside standard policy. Would you like me to escalate for review?”
4. **Save and Re-run a Test**
   * Use a borderline case like `Receipt_4_Only.pdf`
   * Observe how the assistant’s tone changes based on the new prompt

***

#### ✅ **Success Criteria**

* Output clearly reflects new tone
* System still uses memory-driven policy context
* Learner understands where and how to control fallback behavior

***

## Exercise 3: Add Logic to Escalate Alcohol Violations

#### Goal

Escalate receipts that include alcohol, even if thresholds are not exceeded.

#### Steps

1. Open **Expense Evaluation**
2. Add a condition:

   ```
   If invoice_data.contains_alcohol == true
     → Set `approval_result = ESCALATE`
   ```
3. Upload `Receipt_3.pdf` and confirm escalation

***

## Success Criteria

* Agent response is visibly changed (different tone, tags, or decision path)
* `conversation_notes` reflect updated explanations
* Output is aligned with edited logic and assistant behavior

Try adjusting block logic to fit different organizational policies or tone-of-voice standards!


# Expense Policy Decision Engine (Policy API Integration)

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>

This Expense Policy Decision Engine (Policy API Integration) template is a workshop that builds on the [Threshold Memory version](/templates/policy-automation/expense-policy-decision-engine/expense-policy-decision-engine-threshold-memory) of the [Expense Policy Decision Engine series of templates](/templates/policy-automation/expense-policy-decision-engine) and introduces a simulated API integration. Instead of using a real external API, this class uses GLIK Knowledge to simulate an API response containing policy rules (such as spending thresholds and vendor blacklists).

Participants will:

* Learn how to use the [**Knowledge Retrieval Block**](/system-architecture/blocks-and-nodes/input-and-extraction/knowledge-retrieval) to simulate calling an external policy API.
* Dynamically assign and evaluate retrieved rules in an expense approval workflow.
* Understand how internal knowledge objects can act as structured data endpoints.

This simulation sets the stage for connecting to real enterprise APIs in later stages.

***

### 🛠️ What You’ll Build

A workflow that:

* Accepts an uploaded invoice file
* Extracts invoice metadata
* Retrieves policy rules (thresholds, blacklists) from GLIK Knowledge
* Applies conditional logic to approve, reject, or escalate
* [Falls back to LLM reasoning](/system-architecture/blocks-and-nodes/input-and-extraction/llm-block/fallback-to-llm-reasoning) if no rule applies

***

### 🧩 Workflow Structure

{% embed url="<https://www.mermaidchart.com/raw/e129208d-2b42-4d65-9e70-b1b2922f8095?theme=light&version=v0.1&format=svg>" %}
Simulates an API integration using GLIK Knowledge. The uploaded invoice is extracted and evaluated against policy rules retrieved via a tag-based knowledge query. If the logic is ambiguous or unmatched, an LLM block provides fallback reasoning before issuing a final approval, rejection, or escalation decision.
{% endembed %}

### 📂 Step-by-Step Instructions

#### 1. **Create or Upload a Sample Policy in GLIK Knowledge**

Create a new memory object with the following JSON content:

```json
{
  "policy_id": "demo_policy_001",
  "threshold": 3000,
  "blacklist": ["ACME Consulting", "Shady Corp"],
  "categories": {
    "travel": 1000,
    "equipment": 5000
  }
}
```

Apply these tags:

* `type:policy`
* `demo:true`

***

#### 2. **Build the Workflow in GLIK Studio**

**Required Blocks:**

* 📥 **Start**
* 📄 **Doc Extractor**
* 🧠 **Knowledge Retrieval Block** (query: `type:policy AND demo:true`)
* 🧮 **Conditional Block** (compare values from `invoice_data` to `policy_memory`)
* 🤖 **LLM Block** (fallback)
* ✅ **Answer or End Block**

**Variables Used:**

* `invoice_data`
* `policy_memory`
* `approval_result`
* `conversation_notes`

***

### 🧪 Practice Exercises

* Modify the policy memory with a tighter threshold
* Add a new blacklisted vendor
* Re-upload the workflow and re-run with different invoice PDFs to test the logic path

***

### 🧠 Key Concepts&#x20;

* Structured data in memory vs. static config
* Simulated API integration
* Conditional logic based on dynamic variables
* Querying GLIK Knowledge by tag
* Using fallback reasoning for exception cases

***

### 📌 Next Steps

After this class, learners are ready to:

* Integrate real external APIs (e.g., using `API Call` blocks)
* Use branching logic to support multi-policy contexts
* Expand the workflow into a full Expense Audit Engine


# Practice Exercises


# Expense Policy Decision Engine (Escalation & Conflict Resolution)

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# Expense Policy Decision Engine (Audit & Logging)

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# Compliance and Audit Automation

Bring traceability, accountability, and audit-readiness to legacy enterprise systems—without rewriting them.

GLIK’s Compliance and Audit Automation templates allow organizations to embed intelligent agents into existing operational workflows—whether in finance, HR, procurement, or legacy ERP systems. These agents automatically log decisions, flag anomalies, record exceptions, and generate audit trails as part of routine processes.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FkT2LSE9EC3ygOKtYyANL%2Fimage.png?alt=media&amp;token=60a54152-084a-4b1d-852a-b926303d1ad0" alt=""><figcaption><p>Automated Compliance Decision Flow: automates the retrieval and validation of policy data. It includes HTTP-based policy access with status code verification, fallback to default logic when needed, and agent-generated messages for audit clarity. This logic ensures that compliance checks run reliably and transparently — without manual intervention.</p></figcaption></figure>

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

Instead of bolting on manual oversight layers after the fact, enterprises can now **build auditability into the workflows themselves**—ensuring every action is transparent, explainable, and verifiable from the moment it happens.

{% embed url="<https://www.mermaidchart.com/raw/e4f6349d-d943-4966-9a7f-ac2f26e3b55f?theme=light&version=v0.1&format=svg>" %}
Contrasts manual versus automated compliance workflows. On the left, users face delays due to manual review, policy interpretation, and inconsistent audit logging. On the right, GLIK agents streamline the process — applying policies instantly, escalating when needed, and logging outcomes automatically. This illustrates how GLIK transforms compliance from a labor-intensive task into a real-time, auditable flow.
{% endembed %}

## Enterprise Value

* **Reduce Audit Preparation Costs**\
  Automatically capture decision logs, escalation paths, and exception summaries—eliminating the need for retroactive documentation during audits.
* **Accelerate Time-to-Compliance**\
  Deploy plug-in agents that begin logging and enforcing policies on day one—no need to rebuild core systems.
* **Lower Legal and Regulatory Risk**\
  Maintain provable compliance across every automated decision, from expense approvals to policy exceptions.
* **Modernize Legacy Systems Without Replacing Them**\
  Use GLIK to layer compliance automation over SAP, Oracle, and custom-built systems without rewriting backend code.
* **Free Compliance Teams from Manual Oversight**\
  Let agents monitor, tag, and report violations—so human teams can focus on resolution and governance, not tracking activity line-by-line.

{% embed url="<https://www.mermaidchart.com/raw/74938871-3aff-403b-9cad-a2ed4954ff97?theme=light&version=v0.1&format=svg>" %}
How a GLIK agent orchestrates real-time compliance checks. Upon report upload, the agent fetches policy rules from memory, applies threshold logic, and logs the decision with traceable metadata. The system ensures transparent, auditable compliance — reducing human overhead and enabling instant escalation or approval.
{% endembed %}

<details>

<summary>🛒 GLIK Marketplace (Coming June 2025)</summary>

> **The fastest way to deploy enterprise solutions.**

The [**GLIK Marketplace**](/marketplace/overview) is launching in **June 2025** as the central destination for discovering, deploying, and customizing prebuilt AI agent templates. It will allow users to:

* 🔍 **Browse production-ready templates** across industries and workflows
* ⚙️ **Deploy instantly into** [**GLIK Studio**](/glik-cloud/getting-started/glik-cloud-vs.-glik-studio) with minimal setup
* 🧠 **Explore** [**logic**](/system-architecture/blocks-and-nodes/logic-blocks)**,** [**memory**](/system-architecture/memory-and-variable-scope/memory-slot-injection)**, and orchestration patterns** by example
* 🤝 Empowers **partners and service providers** to publish white-labeled templates
* 💼 **Access solutions for real enterprise scenarios**, including SAP integration, expense automation, compliance agents, and more

</details>

## When to Use This Template Genre

Choose Compliance and Audit Automation templates when your organization needs to:

<table data-view="cards"><thead><tr><th></th><th></th></tr></thead><tbody><tr><td>Ensure <strong>provable compliance</strong></td><td>Maintain full traceability across agent-driven decisions and automated workflows</td></tr><tr><td>Log <strong>who decided what and why</strong></td><td>Create accountable decision trails for auditors and stakeholders</td></tr><tr><td>Minimize risk from <strong>policy violations or improper approvals</strong></td><td>Prevent governance lapses before they escalate</td></tr><tr><td>Generate <strong>real-time audit trails</strong></td><td>Instantly surface activity logs for internal reviews or external regulators</td></tr><tr><td>Agentify <strong>cost control, HR, procurement, or operations</strong></td><td>Bring audit-ready explainability to legacy systems without rewriting them</td></tr></tbody></table>

### Comparison with Other Template Genres

While **Policy Automation** focuses on making the decision, **Compliance and Audit Automation** focuses on **proving the decision was correct, compliant, and traceable**.

Where **Compliance Advisors** help users follow rules, these agents make sure the rules were actually followed—by logging every step and exception in real time.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

### Agentify the Audit Layer

GLIK turns traditional audit processes from a **retroactive burden** into a **proactive agent-driven layer** that wraps around your existing enterprise stack. Whether you’re modernizing a procurement platform or expanding your finance automation, these templates make every step verifiable—without slowing anything down.


# KYC/AML Review Copilot

The **KYC/AML Review Copilot** templates are designed to help regulated institutions automate and orchestrate the **Know Your Customer (KYC)** and **Anti-Money Laundering (AML)** review process. Built with enterprise compliance workflows in mind, this copilot coordinates human-in-the-loop approvals, document validation, and escalation logic — streamlining onboarding for counterparties, clients, and ecosystem partners.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FYhRadHyXkxTkouuY5WSZ%2Fimage.png?alt=media&amp;token=9a435761-eca9-448e-b463-e172e1b160ea" alt=""><figcaption><p>Automates the identity screening process by integrating external AML API checks, conditional risk logic, LLM-powered escalation summaries, and human-in-the-loop compliance review. The flow begins with an API call to a sanctions screening service, followed by a decision block that determines whether to auto-approve or escalate. Escalated cases pass through a reasoning step and are handed off to a compliance officer for manual decisioning. All cases terminate in a unified decision block that outputs an audit-traceable status: Approved, Rejected, or Escalated.</p></figcaption></figure>

### 🔧 Template Use Cases

<table data-view="cards"><thead><tr><th></th><th></th></tr></thead><tbody><tr><td><strong>RWA Platforms &#x26; DeFi Infrastructure Providers</strong></td><td>Onboard institutional clients into tokenized asset ecosystems with regulatory-compliant identity flows</td></tr><tr><td><strong>Custodians &#x26; Broker-Dealers</strong></td><td>Manage identity-based onboarding and compliance checks with role-based approval flows</td></tr><tr><td><strong>Financial Services Firms</strong></td><td>Accelerate audit-compliant onboarding with automated document validation and internal logic gates</td></tr><tr><td><strong>Web3 Platforms with External KYC Partners</strong></td><td>Coordinate layered workflows and approvals involving third-party vendors (e.g., SumsUp, Sardine, Persona)</td></tr></tbody></table>

<details>

<summary>🚀 Coming Soon to GLIK Marketplace</summary>

This template will be available in the GLIK Marketplace as part of the **Compliance Automation Starter Pack**, and is installable into any GLIK Cloud workspace. Users will be able to:

* View and edit logic blocks via the visual workflow editor
* Customize escalation paths, approval thresholds, and document types
* Integrate with third-party compliance APIs

</details>

### 🧠 Key Features

* **OCR & ID Document Parsing**\
  Automatically extracts data from passports, IDs, and uploaded documents using GLIK's OCR Block.
* **Sanctions & Risk Screening Hooks**\
  Connect to third-party AML APIs (e.g., Chainalysis, Elliptic, WorldCheck) to retrieve flagged records.
* **Approval Chain Logic**\
  Multi-tiered decision logic for compliance officers, with thresholds based on risk categories and internal policies.
* **Escalation & Triage**\
  When edge cases or ambiguous statuses arise, the agent routes cases to senior reviewers and flags for additional documentation.
* **MCP-Compatible JSON Audit Trail**\
  All decisions, responses, and intermediate states are logged using GLIK’s memory system — ensuring portable compliance records.
* **Self-Serve Template Installation** *(Coming Soon)*\
  This template will be available via the GLIK Marketplace for one-click deployment into any GLIK workspace.

***

### 🔒 Regulatory Alignment

* Designed for MiCA, FATF, and German BaFin KYC requirements
* Compatible with traditional AML frameworks and emerging Web3 compliance flows
* Agent logic supports documentation triggers for internal audits and external regulators

***

###


# Learning Track

<details>

<summary>🚀 Coming Soon to GLIK Marketplace</summary>

These templates will be installable through the GLIK Marketplace and available as part of the **Compliance Automation Learning Series**. Each level is self-contained, but designed to build toward mastery of fully agentified compliance workflows.

</details>

The **KYC/AML Review Copilot** is a progressive template series and workshop track in GLIK AI, designed to help regulated institutions automate and orchestrate the **Know Your Customer (KYC)** and **Anti-Money Laundering (AML)** review process.

This isn’t just a single template — it’s a structured **learning journey**, from beginner to advanced, combining pre-built templates, real-world workflows, and modular lessons. You'll start with foundational automation (OCR + ID parsing), and advance toward **full orchestration of tiered approvals**, **risk triage**, **regulatory triggers**, and **policy-based decision memory**.

***

### 📚 Learning Track Structure

The series is designed to scale with your team’s needs and technical experience:

| Level            | Title                                             | Description                                                                                                                                                    |
| ---------------- | ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Starter**      | **KYC Copilot: OCR & Field Mapping**              | Learn how to extract ID document data and normalize input variables (e.g. `customer_name`, `date_of_birth`, `issuing_country`).                                |
| **Intermediate** | **Risk Rules & Sanctions Checks**                 | Integrate AML API calls and build conditional blocks to flag or approve based on risk tier, sanctions lists, or geography.                                     |
| **Advanced**     | **Escalation Logic & Audit Logging**              | Add human-in-the-loop escalation logic, memory logging, and Save Point checkpoints for audit compliance.                                                       |
| **Expert**       | **MiCA & Multi-Jurisdictional Compliance Engine** | Build workflows for jurisdiction-aware onboarding policies with branching logic per region.                                                                    |
| **Power User**   | **Agent Networks & Custody API Triggers**         | Coordinate between KYC agents, custodial partners, and internal compliance officers using multi-agent orchestration logic and outbound smart contract signals. |

Each level includes:

* An installable GLIK template
* A visual workflow breakdown
* Sample inputs & test data
* Role-based usage examples (compliance officer, ops, tech)

***

### 🧠 Who This Is For

* Web3 platforms integrating TradFi-grade onboarding
* RWA tokenization teams handling sensitive client data
* Custodians and broker-dealers building MiCA-compliant flows
* Compliance & ops teams that want no-code, logic-rich orchestration

***

### 🔒 Built for Enterprise Compliance

* Supports GLIK Memory Blocks for attestation tracking and rollback
* Compatible with AML vendors like SumsUp, Chainalysis, Elliptic
* Designed with regulatory regimes including FATF, MiCA, and BaFin in mind


# Compliance Copilot – MiCA Reporting

The **Compliance Copilot – MiCA Reporting** series of templates enables regulated financial entities, token issuers, and RWA platforms to orchestrate the internal workflows required to generate and manage **MiCA-compliant reports**.

Built for policy-aware, document-rich environments, this template allows institutions to **assign roles**, **enforce reporting timelines**, **automate decision traceability**, and **store output in regulatory-ready formats**.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FW1i0kxqpxHdmsQgKj5tB%2Fimage.png?alt=media&amp;token=5b5c264e-bdb1-43fd-afc9-aeaed4bd6a99" alt=""><figcaption><p>This loop is the core engine of the Compliance Copilot – MiCA Reporting workflow, systematically processing each required disclosure section under EU MiCA regulation—such as risk controls, liquidity coverage, and asset details—through a modular validation sequence. It initializes a structured template for each section, dynamically retrieves relevant compliance thresholds, executes rule-based checks for missing data or violations, and uses an LLM to summarize the compliance quality in plain language. By repeating this logic for each section, the loop ensures consistent, auditable validation across the entire compliance package, enabling downstream aggregation, reporting, or human review.</p></figcaption></figure>

## Regulatory Context

The **Markets in Crypto-Assets (MiCA)** regulation enforces new obligations across the EU for:

* Crypto-asset service providers (CASPs)
* Issuers of asset-referenced tokens (ARTs) or e-money tokens
* Entities offering custody, trading, or listing services

These obligations include maintaining structured records of compliance policies, attestations, financial disclosures, and risk procedures — often across departments.

This GLIK template turns those mandates into **repeatable, auditable, and role-based workflows**.

***

## Features

| Block/Component                    | Function                                                                                                                    |
| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| **Input Start Node**               | Triggers a new MiCA reporting cycle (monthly, quarterly, or ad hoc)                                                         |
| **Jurisdictional Branching Block** | Routes workflows based on EU member-state-specific extensions or enforcement timelines                                      |
| **Form-Fill Memory Block**         | Stores collected info from finance, legal, ops, and compliance officers (e.g., disclosures, risk policies, issuance events) |
| **Validation Checkpoint**          | Ensures completeness before submission (e.g., signature, control totals, asset coverage)                                    |
| **Escalation Logic**               | Flags overdue or non-compliant sections for director-level intervention                                                     |
| **Submission Memory Block**        | Stores final MiCA package for audit, attestation, or filing via external API endpoint                                       |

***

## Who This Is For

* **Crypto-asset service providers (CASPs)** operating or expanding in the EU
* **RWA tokenization platforms** launching under MiCA frameworks
* **Broker-dealers and fintechs** offering custody or settlement services
* **Legal & compliance officers** responsible for periodic reporting and disclosure compliance

***

## Benefits

* Automates MiCA-mandated document collection and validation
* Enables cross-functional collaboration (legal, risk, ops) inside one unified flow
* Captures immutable memory of every submission and attestation decision
* Provides audit trail and compliance posture alignment for external regulators or internal counsel

***

<details>

<summary>🚀 Coming Soon to GLIK Marketplace</summary>

This series of templates will be available in the **Compliance and Audit Automation** section of the GLIK Marketplace. Partners and institutions will be able to:

* Configure report triggers and deadlines (e.g., Q1 report, asset issuance event)
* Add or modify forms, document types, and control checkpoints
* Generate exportable audit-ready reports in `.pdf`, `.json`, or `.md` format
* Link to compliance data sources or regulatory portals (future)

</details>


# Workflow Phases

When building sophisticated workflows in GLiK, especially for regulatory use cases like MiCA compliance, it’s helpful to design your application in terms of **phases**. This approach improves clarity, modularity, and reusability—especially for learners and enterprise teams managing complex orchestration.

The following guide walks through the major workflow phases of the **Compliance Copilot – MiCA Reporting** template. Each phase corresponds to a key milestone in the MiCA reporting process.

{% hint style="info" %}

## What “Workflow” Means&#x20;

The word **“workflow”** is used in three different contexts within GLIK:

1. [**Workflow (App Type)**](/app-types/workflow) — A specific GLIK execution model designed for automating logic using a block-based interface. It’s one of the four foundational app types alongside [Chatbot](/app-types/chatbot), [Agent](/app-types/agent), and [Advanced Chat](/app-types/advanced-chat).
2. [**Workflow (Architecture)**](/system-architecture/execution-model/workflow-architecture) — A broader concept referring to the high-level orchestration of tasks, inputs, tools, and decisions across [GLIK apps](/app-types/overview). This includes how agents interact, how memory is passed, and how execution flows are triggered across systems.
3. [**Workflow (Editor View)**](/glik-cloud/workflow-editor) — The visual interface where you arrange blocks and nodes (like Variable Assigners, Tool Nodes, LLM Blocks, etc.) to construct executable logic paths. This is where low-code users build and configure the logic of any GLIK app, even outside the Workflow App Type.

> In short: the **Workflow App Type** is one way to execute workflows — but **“workflow”** as a term also describes how logic flows and systems connect across all App Types.
> {% endhint %}

### 🔎 Phase 1: Trigger & Metadata Preparation

This phase initiates the MiCA reporting workflow and prepares essential input variables.

* **Trigger**: Begins manually or via internal partner API
* **Document Parsing (Optional)**: Extracts key metadata (e.g., issuer, asset type, jurisdiction) using document extractors
* **Normalization**: Input variables are cleaned and mapped using tools like `Parameter Extractor`, `Variable Assigner`, and `Code`

**📦 Output**: A normalized input profile ready for validation.

***

### ♻️ Phase 2: Disclosure Section Validator Loop

This is the core loop of the MiCA workflow, validating each disclosure section independently.

* **Generate Section Template**: Initializes a reporting frame for the current section
* **Load Compliance Thresholds**: Retrieves jurisdictional or internal policy thresholds
* **Validate Thresholds and Fields**: Performs rule-based checks for missing data or violations
* **Evaluate Disclosure Quality**: Uses an LLM to assess clarity and completeness
* **Summarize (Optional)**: Produces a natural-language explanation of compliance status

**🔁 Output**: Each section passes through consistent, auditable validation logic.

***

### 📊 Phase 3: Report Aggregation & Assembly

Once all sections are validated, they’re combined into a unified compliance package.

* **Aggregate Sections**: Merge per-section results
* **Generate Audit Package**: Format the aggregated report into `.json`, `.csv`, or `.pdf` outputs using templates or LLMs

**📦 Output**: A fully assembled MiCA-compliant report.

***

### ✉️ Phase 4: Submission & Attestation

Final tasks for exporting or attesting the completed report.

* **Optional Review**: Assign human review or escalation agent for final sign-off
* **Compose Audit Log**: Log all decisions using `Compose Approval Log`
* **Submit/Export**: Route to API, archive, or internal system

**✅ Output**: Finalized submission with structured audit trail, ready for regulators or compliance systems.


# Block-by-Block Guide

This reference guide provides a detailed breakdown of each block used in the **Compliance Copilot – MiCA Reporting** template. The documentation is organized by **workflow phase** and presented in table format to help enterprise developers and solution engineers quickly understand the purpose, type, and role of each block.

***

### 🔍 Phase 1: Trigger & Metadata Preparation

| **Block Name**               | **Block Type**      | **Description**                                                     | **Purpose**                                                                        |
| ---------------------------- | ------------------- | ------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Start                        | System (default)    | Kicks off the workflow                                              | Initiates the application either via manual user click or incoming API call        |
| Extract Submission Documents | Doc Extractor       | Parses uploaded compliance documents to extract structured metadata | Converts unstructured files like PDFs into machine-readable inputs                 |
| Normalize Parameters         | Parameter Extractor | Converts extracted values into a normalized format                  | Ensures naming conventions, formats, and keys are consistent for downstream blocks |
| Assign Jurisdiction Code     | Variable Assigner   | Maps raw jurisdiction names to internal codes                       | Standardizes identifiers for rule-based logic                                      |

***

### ♻️ Phase 2: Disclosure Section Validator Loop

| **Block Name**                       | **Block Type**      | **Description**                                                               | **Purpose**                                                                            |
| ------------------------------------ | ------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| Section-by-Section Disclosure Review | Loop                | Iterates through a list of report sections, applying validation logic to each | Enables reusable logic for each disclosure section (risk, liquidity, governance, etc.) |
| → Generate Section Template          | Template            | Initializes a pre-filled template or format for the current section           | Establishes a uniform structure for each disclosure type before evaluation begins      |
| → Load Compliance Thresholds         | Knowledge Retrieval | Queries internal rulesets or knowledge documents to fetch policy thresholds   | Dynamically loads what each section must comply with                                   |
| → Validate Thresholds and Fields     | IF/ELSE             | Compares user input or extracted values against the thresholds                | Identifies missing fields or out-of-policy values                                      |
| → Evaluate Disclosure Quality        | LLM                 | Uses a language model to check clarity, relevance, or completion              | Adds a semantic quality check beyond simple rules                                      |
| → Summarize Compliance Quality       | LLM                 | Generates a plain-language summary of section-level compliance                | Useful for audit logs or human review                                                  |

***

### 📊 Phase 3: Report Aggregation & Assembly

| **Block Name**           | **Block Type**      | **Description**                        | **Purpose**                                                             |
| ------------------------ | ------------------- | -------------------------------------- | ----------------------------------------------------------------------- |
| Aggregate Sections       | Variable Aggregator | Combines loop output from all sections | Merges each section’s validation result into a single package           |
| Format Compliance Report | Template / LLM      | Formats the full report for delivery   | Outputs the final report in a structured file (`.json`, `.csv`, `.pdf`) |

***

### ✉️ Phase 4: Submission & Attestation

| **Block Name**          | **Block Type**  | **Description**                                                                  | **Purpose**                                                                            |
| ----------------------- | --------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| Final Review (Optional) | Agent           | Sends results to a Compliance Officer agent or human reviewer                    | Allows manual sign-off if policy requires it                                           |
| Compose Audit Log       | Code / Template | Generates structured output with metadata (e.g., reviewer ID, status, timestamp) | Creates an immutable record of the decision process                                    |
| Submit Report           | HTTP Request    | Routes the final report to an API endpoint or archive                            | Sends the MiCA-compliant package to an external system, regulator, or internal archive |


# Compliance Advisors

Turn policies into proactive agents that guide employees, reduce violations, and ensure real-time adherence.

GLIK’s Compliance Advisor templates enable enterprises to deploy intelligent agents that help users interpret, understand, and follow complex policies during day-to-day operations. Instead of retroactively flagging violations, these agents act at the point of action—clarifying requirements, surfacing exceptions, and offering guidance when uncertainty arises.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2Fr25nw32Bccsg2B0CfuJH%2Fimage.png?alt=media&amp;token=756ac6ab-d922-48e0-b49f-874e2fdb8fd7" alt=""><figcaption><p>Advisory Fallback and Explanation Logic: how Compliance Advisor agents can dynamically generate or default to policy data, check for receipt existence, and return informative responses when policy input is missing. Rather than enforcing in silence, these agents help users understand what’s needed and why — a defining trait of advisory workflows.</p></figcaption></figure>

Whether it’s navigating overtime limits, vendor eligibility, security disclosures, or financial controls, compliance advisor agents act as real-time co-pilots embedded into enterprise workflows—keeping employees aligned and reducing the risk of costly mistakes or compliance drift.

{% embed url="<https://www.mermaidchart.com/raw/6bdc9e98-5cf6-45ad-b372-34494f80818a?theme=light&version=v0.1&format=svg>" %}
Real-time flow of how employees interact with a Compliance Advisor agent. From initial confusion to guided decision-making, the agent activates in response to user queries, interprets policy logic, and ensures actions align with organizational rules — reducing violations and minimizing the need for human escalation.
{% endembed %}

## Enterprise Value

* **Prevent Violations Before They Happen**\
  Intervene early by guiding users through relevant rules, thresholds, and constraints in real time.
* **Accelerate Employee Onboarding & Training**\
  Replace bulky documentation with conversational, in-context guidance from embedded policy agents.
* **Reduce Compliance-Related Helpdesk Load**\
  Empower users to self-serve answers to policy questions—without escalating to legal, HR, or finance teams.
* **Close the Gap Between Policy and Execution**\
  Ensure your rules are not just written, but understood and followed—especially in dynamic, high-friction environments.
* **Adapt to Policy Changes Instantly**\
  Update agents with new rules and immediately propagate updated guidance across the enterprise.

{% embed url="<https://www.mermaidchart.com/raw/aacc00a2-a5d0-4370-88f1-1d8219e9dad3?theme=light&version=v0.1&format=svg>" %}
Critical dependencies needed for a Compliance Advisor agent to function effectively. The agent satisfies three core requirements: (R1) access to a policy rule library, (R2) awareness of user roles and permissions, and (R3) defined exception routing logic. These requirements ensure the agent can interpret policies, personalize responses, and escalate edge cases appropriately.
{% endembed %}

## When to Use This Template Genre

| **Use Case**                                     | **Why It Matters**                                                           |
| ------------------------------------------------ | ---------------------------------------------------------------------------- |
| Employees ask “Can I do this under policy?”      | Reduce uncertainty and catch violations before they occur                    |
| Complex SOPs or decision trees must be followed  | Help users navigate branching rules without reading lengthy documentation    |
| Policy adherence varies across departments       | Standardize behavior by embedding compliance directly into the workflow      |
| Training cycles are slow or uneven               | Provide in-task learning to close knowledge gaps in real time                |
| Users need help interpreting rules or exceptions | Deliver clarity and confidence without requiring manager or legal escalation |

### How This Differs from Compliance and Audit Automation

| Guide users **before or during** action               | Log and audit decisions **after** action                             |
| ----------------------------------------------------- | -------------------------------------------------------------------- |
| Focus on **understanding and interpretation**         | Focus on **traceability and enforcement**                            |
| Prevents violations by helping users follow the rules | Proves compliance by logging what happened                           |
| Conversational and interactive                        | Background monitoring and logging                                    |
| Example: “Can I approve this vendor?”                 | Example: “This vendor approval was tagged and logged with policy ID” |

### Why Compliance Advisors Matter Now

{% embed url="<https://www.mermaidchart.com/raw/89107024-08a2-4c77-a539-a92ea3c4ce78?theme=light&version=v0.1&format=svg>" %}
Compliance Advisor Interaction Flow: This sequence diagram illustrates how a user inquiry (“Can I approve this vendor?”) is processed by the Compliance Advisor agent. The agent checks policy rules against the Policy Database, identifies applicable constraints or exceptions, delivers a real-time response to the user, and logs the decision and context in the audit system — ensuring both adherence and traceability.
{% endembed %}

As policies grow more complex and distributed across systems, teams, and jurisdictions, enterprises need scalable ways to ensure policy adherence without constant human oversight. GLIK enables organizations to embed real-time policy intelligence directly into the systems employees use every day—turning guidance from a document into a dynamic, always-on experience.

Whether you’re managing risk in finance, operations, HR, or regulatory domains, compliance advisor templates help close the last mile between **what’s written** and **what’s done**.


# Global Control Copilot – Cross-Jurisdiction Policy Interpreter

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FEHGWWTAvs1Ch5ejy0nbU%2Fimage.png?alt=media&amp;token=62b2e1c6-a96c-436a-983a-c99c774a7b82" alt=""><figcaption><p>This block sequence handles the post-decision logic for the Global Control Copilot. If the submission is compliant, the LLM generates an approval summary with policy references, followed by a structured API submission with retry logic. If not, the flow escalates to a human analyst and provides the user with real-time guidance on why the submission failed. Both paths conclude with a Save Point block that logs the session's decision logic and outcome for auditability.</p></figcaption></figure>

{% hint style="info" %}
[Download Practice Files](https://drive.google.com/drive/u/4/folders/1RlcikzgdwXiKdNpuErhc2GqwjhanIW8x)
{% endhint %}

### 🔹 Phase 1: Context Initialization

| Step | Block Type            | Custom Block Name              | Description                                                                                                                                                                |
| ---- | --------------------- | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1    | `Parameter Extractor` | **Extract Request Context**    | Parses user-provided data and environmental metadata (e.g., `user_region`, `user_role`, `submission_type`). Establishes contextual variables for downstream logic.         |
| 2    | `Knowledge Retrieval` | **Load Applicable Policy Set** | Pulls the relevant policy corpus (e.g., MiCA, GDPR, SOX) based on the user’s region, department, and role. This is the source of truth for threshold checks and reasoning. |
| 3    | `Variable Assigner`   | **Assign Policy Thresholds**   | Converts raw policy values (e.g., `max_disclosure_days`, `reporting_limit`) into variables for downstream evaluation. Enables precise compliance enforcement logic.        |

### 🔹 Phase 2: Submission Intake & Preprocessing

| Step | Block Type        | Custom Block Name                  | Description                                                                                                                              |
| ---- | ----------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| 4    | `Doc Extractor`   | **Extract User Submission Fields** | Parses uploaded or pasted documents to extract relevant fields for analysis (e.g., `submitted_on`, `disclosure_category`, `risk_flags`). |
| 5    | `Data Enrichment` | **Normalize User + Context Data**  | Normalizes units (e.g., dates, monetary values), maps job roles and region codes, and prepares a clean dataset for analysis.             |

### 🔹 Phase 3: Compliance Reasoning

| Step | Block Type | Custom Block Name                | Description                                                                                                                                                         |
| ---- | ---------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 6    | `LLM`      | **Interpret Policy Constraints** | Uses a large language model to interpret extracted fields in light of the policy document. Detects vague, contradictory, or missing input that could violate rules. |
| 7    | `IF/ELSE`  | **Is Submission Compliant?**     | Branches logic based on LLM output and structured thresholds. If the submission passes all policy rules, proceeds to approval. Otherwise triggers escalation.       |

### 🔹 Phase 4A: Approval Track (IF Branch)

| Step | Block Type     | Custom Block Name                    | Description                                                                                                                                     |
| ---- | -------------- | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| 8    | `LLM`          | **Generate Approval Summary**        | Writes a natural language summary confirming that the submission meets compliance standards — with references to policy sections or thresholds. |
| 9    | `HTTP Request` | **Submit to Compliance Tracker API** | Sends structured output to an API endpoint or audit tool (e.g., Google Sheet, RegTech portal). Configured to retry on failure for reliability.  |

### 🔹 Phase 4B: Escalation Track (ELSE Branch)

| Step | Block Type | Custom Block Name                             | Description                                                                                                                                  |
| ---- | ---------- | --------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| 8    | `Agent`    | **Escalate to Compliance Analyst**            | Routes non-compliant or ambiguous cases to a human analyst with full context for review. May include notification, form handoff, or tagging. |
| 9    | `LLM`      | **Generate User Guidance & Exception Reason** | Provides the user with clear feedback on why the submission failed, referencing the violated policy and suggesting next actions.             |

### 🔹 Phase 5: Session Closure & Audit

| Step | Block Type   | Custom Block Name                       | Description                                                                                                                                                      |
| ---- | ------------ | --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 10   | `Save Point` | **Generate Compliance Session Summary** | Generates a markdown or JSON summary of the session, including extracted data, evaluation results, reasoning chain, and outcome. Ideal for logging or exporting. |
| 11   | `End`        | **End Session**                         | Concludes the workflow session and hands off the result to the UI or storage system.                                                                             |


# Input Combinations & Workflow Outcomes

Understand how combinations of user\_region, submission\_type, and user\_role control logic, escalation, and policy loading in the Global Copilot workflow.

This page documents how different combinations of `user_region`, `submission_type`, and `user_role` affect the internal logic, escalation rules, policy loading, and summary tone of the **Global Control Copilot – Cross-Jurisdiction Policy Interpreter** template.

These input-driven workflows are designed to route compliance submissions through highly contextual decision paths, driven by both upstream metadata and parsed file content.

This guide is intended to be the **authoritative reference** for engineers and template builders. It anticipates all major decision-making branches and ensures you have everything needed to implement or extend the template — no need to search elsewhere.

***

### 🧩 1. Why Inputs Matter

The Global Control Copilot is built for reuse across multiple jurisdictions, policy types, and team roles. These three inputs drive that adaptability:

| Input Variable    | Controls                                                                |
| ----------------- | ----------------------------------------------------------------------- |
| `user_region`     | Which policy schema (e.g., MiCA, SOX, GDPR) is loaded                   |
| `submission_type` | What content is expected (e.g., checklist, audit trail, risk report)    |
| `user_role`       | How strictly the submission is evaluated and how LLM feedback is framed |

***

### 📋 2. Input Combination Matrix (Quick Reference)

| Region | Type             | Role               | Policy Loaded           | Escalation Trigger                | Approval Condition                        |
| ------ | ---------------- | ------------------ | ----------------------- | --------------------------------- | ----------------------------------------- |
| EU     | Disclosure       | Finance Manager    | MiCA                    | Exposure > €1M, checklist missing | Risk exposure ≤ €1M, checklist = Complete |
| US     | Attestation      | Legal Counsel      | SOX                     | Missing CFO signoff, late filing  | Attestation = True, within 45-day window  |
| APAC   | Exception Report | Product Ops        | Fallback Policy         | Missing override\_reason          | Justified override present                |
| Global | Incident         | External Submitter | Internal Control Matrix | Missing timestamp/logs            | 72h disclosure, audit trail present       |

***

### ✅ 3. Full Examples

***

#### **Example A: EU + Disclosure + Finance Manager**

```yaml
user_region: EU  
submission_type: Disclosure  
user_role: Finance Manager
```

**Workflow Behavior:**

* Loads **MiCA** thresholds
* Requires: risk statement, governance section, liquidity summary
* Enforces €1M exposure cap
* Triggers escalation if checklist is missing
* Generates approval summary only if all fields complete and exposure ≤ €1M
* LLM tone is professional and internal-facing (for finance operations)

***

#### **Example B: US + Attestation + Legal Counsel**

```yaml
user_region: US  
submission_type: Attestation  
user_role: Legal Counsel
```

**Workflow Behavior:**

* Loads **SOX** rules via Knowledge Retrieval
* Requires: signed attestation block, audit trail
* Auto-approval only if CFO or legal signoff is validated
* Escalation triggered if signoff is blank or filing delayed > 45 days
* Summary tone framed toward legal compliance, references SEC expectations

***

#### **Example C: APAC + Exception Report + Product Ops**

```yaml
user_region: APAC  
submission_type: Exception Report  
user_role: Product Ops
```

**Workflow Behavior:**

* Loads fallback policy or internal guidelines
* Expects `override_reason` or policy justification section
* Escalates if override is empty or missing
* Approves only if justification is declared and matches expected structure
* LLM provides softer tone, explaining internal exception policy

***

#### **Example D: Global + Incident + External Submitter**

```yaml
user_region: Global  
submission_type: Incident  
user_role: External Submitter
```

**Workflow Behavior:**

* Loads internal control matrix (default fallback)
* Requires: incident timestamp, log of actions taken, DPO contact
* Auto-escalates on missing fields
* Summary warns user about trust boundary and flags for review
* Save Point logs all fields for audit trail

***

### 🔍 4. How These Inputs Are Used in Orchestration

Each input is extracted or set using a `Parameter Extractor` block early in the workflow. They're then referenced in:

* `Knowledge Retrieval` → Loads the correct policy based on `user_region`
* `Variable Assigner` → Sets thresholds like `risk_exposure_limit`, `deadline_days`
* `IF/ELSE` → Evaluates whether submission meets policy standards
* `LLM` → Tailors tone and reasoning based on `user_role`
* `Save Point` → Records input values and outcomes for traceability

***

### ⚠️ 5. Input Validation & Defaults

* If a required variable is **missing or malformed**, the workflow defaults to **safe mode**, typically escalating the submission
* Example guard:

  ```yaml
  if risk_exposure_limit == null:
    escalate = true
  ```
* You can enforce stricter checks using custom validation logic before policy evaluation begins

***

### 🛠️ 6. Best Practices for Builders

* Always set default values for `user_region`, `submission_type`, and `user_role` to prevent orphaned sessions
* Use descriptive labels in the chat UI or input form to guide the user clearly
* Avoid hardcoding policy thresholds — always reference memory or retrieval logic
* Tag Save Point logs with input variables for observability and debugging


# Reference Input Payloads

This page provides ready-to-use test payloads for simulating different compliance submission scenarios inside the **Global Control Copilot – Cross-Jurisdiction Policy Interpreter** template.

Each example includes expected logic routing, escalation behavior, and guidance for Save Point logging and observability.

Use these inputs with the **Parameter Extractor block**, preloaded memory, or API-driven sessions during testing and demo workflows.

***

### 🧾 Example A — MiCA Disclosure (EU, Finance)

```yaml
user_region: EU  
submission_type: Disclosure  
user_role: Finance Manager

risk_exposure: 920000  
checklist_status: Complete  
submission_date: 2025-05-22  
policy_reference: MiCA
```

#### 🔁 Expected Routing:

* Loads MiCA thresholds via `Knowledge Retrieval`
* Passes policy checks: exposure < €1M and checklist = Complete
* Flows through `LLM → HTTP Request → Save Point`

#### 🚨 Escalation Conditions (if triggered):

* `checklist_status != "Complete"`
* `risk_exposure > 1000000`

***

### 🧾 Example B — SOX Attestation (US, Legal Counsel)

```yaml
user_region: US  
submission_type: Attestation  
user_role: Legal Counsel

cfo_attestation: true  
audit_trail_present: true  
submission_date: 2025-04-15  
policy_reference: SOX
```

#### 🔁 Expected Routing:

* Loads SOX policy from memory or retrieval
* Validates `cfo_attestation` and `audit_trail_present`
* If both pass → generate approval summary
* `Save Point` logs legal context, signoff metadata

#### 🚨 Escalation Conditions:

* `cfo_attestation == false`
* `audit_trail_present == false`
* Submission date older than 45 days from quarter-end

***

### 🧾 Example C — Exception Report (APAC, Product Ops)

```yaml
user_region: APAC  
submission_type: Exception Report  
user_role: Product Ops

override_reason: "Smart contract error auto-mitigated under protocol X"  
policy_reference: APAC_Fallback_Policy  
checklist_status: Missing
```

#### 🔁 Expected Routing:

* Loads fallback policy (e.g., internal controls)
* Skips checklist validation
* Checks for presence of `override_reason`
* Generates justification summary

#### 🚨 Escalation Conditions:

* `override_reason == null`

***

### 🧾 Example D — Incident Report (Global, External Submitter)

```yaml
user_region: Global  
submission_type: Incident  
user_role: External Submitter

incident_timestamp: 2025-05-20T14:30:00Z  
audit_log_attached: true  
dpo_approval: true  
policy_reference: Internal_Control_Policy
```

#### 🔁 Expected Routing:

* Uses fallback internal compliance logic
* Requires 72h window + complete metadata
* Flags submission source as external in summary
* Logs all evidence fields in `Save Point`

#### 🚨 Escalation Conditions:

* Missing `incident_timestamp`
* `audit_log_attached == false`
* `dpo_approval == false`

***

### 🧠 Save Point Logging Tips

To maximize traceability and make audits reviewable:

* ✅ Include all key input variables in the Save Point output:

  ```json
  {
    "user_region": "US",
    "submission_type": "Attestation",
    "user_role": "Legal Counsel",
    "policy_reference": "SOX",
    "escalation_triggered": false,
    "reasoning_path": "Auto-approved under SOX thresholds"
  }
  ```
* ✅ Set a `session_label` or `test_case_id` for QA:

  ```yaml
  session_label: "Demo – SOX Legal Signoff"
  ```
* ✅ Log `escalation_reason` or `policy_matched` fields to track execution
* ✅ Export to JSON for diff-based comparisons across test cases


# Policy Retrieval via Input Routing

Definitive, no-guessing-needed guide for builders using GLIK Studio to dynamically fetch policy files based on user context.

This page explains how to dynamically retrieve the correct policy file (e.g., `.docx`, `.json`, or `.yaml`) based on user-provided context like `user_region`, `submission_type`, and `user_role`.

This is a **core pattern** in the Global Control Copilot template, where logic and validation depend on loading the right ruleset for the right user at the right time.

Whether you're pulling from a **static dataset**, using **in-memory config**, or accessing **GLIK Knowledge**, this page shows you exactly how to route logic and retrieve the right file — without hardcoding anything.

***

### 🧩 What This Pattern Enables

* ✅ Load MiCA, SOX, or fallback policies based on `user_region`
* ✅ Adjust document-based compliance logic dynamically per session
* ✅ Inject policy text into downstream LLM blocks, classifiers, and decisions
* ✅ Enable jurisdiction-aware automation at runtime
* ✅ Keep workflows modular, reusable, and future-proof

***

### 🔁 High-Level Pattern

```
IF/ELSE → SET VARIABLE → GET POLICY → (use in logic / LLM)
```

This means:

1. You detect the input conditions
2. You set a policy key (e.g., `policy_reference = "SOX"`)
3. You fetch the associated file or memory chunk using that key
4. You inject the contents downstream

***

### 🖼️ Example Logic (Visual from Studio)

**IF/ELSE Conditions:**

* `region == EU`
* `submission_type == Disclosure`
* `user_role == Finance Manager`\
  → then `SET policy_reference = "MiCA"`

**GET POLICY Block:**

* File name or memory key: `{{policy_reference}}.docx`

***

### 📂 Example Policy Files

These files live in your GLIK Cloud Dataset or are registered in memory/knowledge.

| policy\_reference | File Name                | Source Type       |
| ----------------- | ------------------------ | ----------------- |
| `MiCA`            | `MiCA_EU.docx`           | Dataset           |
| `SOX`             | `SOX_Controls_2025.json` | Dataset or Memory |
| `GDPR`            | `GDPR-Disclosure.yaml`   | Knowledge         |
| `Fallback_Policy` | `InternalPolicy.pdf`     | Static default    |

Best practice: Keep the file name aligned with the variable (e.g., `policy_reference = SOX` → `SOX.docx`).

***

### 💡 Tips for Builders

#### ✅ Save Point Logging

Always log the policy name for auditability and traceability.

```json
{
  "user_region": "US",
  "submission_type": "Attestation",
  "user_role": "Legal Counsel",
  "policy_reference": "SOX"
}
```

#### ✅ Add `session_label` or `policy_source` tags in memory:

```yaml
session_label: "SOX US Submission"
policy_source: "Dataset"
```

***

### 🛡️ Fallback Handling

If no policy matches the user's inputs:

1. Use a default case in your `IF/ELSE` block:

```yaml
ELSE → SET policy_reference = "Fallback_Policy"
```

2. Add a logic check before GET POLICY:

```yaml
IF policy_reference == null → route to escalation or system error handling
```

***

### 🔐 Dataset Access & Security

#### ✅ Public or Shared Dataset Policies:

* Easy to reuse
* Visible across workspaces (read-only recommended)

#### ✅ Private Dataset Policies:

* Best for sensitive rules
* Assign roles in the GLIK Workspace permissions

#### ✅ In-Memory Policies:

* Fastest for demos
* Good for SDK-based dynamic injection

***

### 🔄 Common Questions (and Clear Answers)

#### ❓ What if I want to store the policy in memory instead of a dataset?

You can. Just assign `policy_reference = "MiCA"` and use the `Memory Get` or direct memory block instead of `GET POLICY`. Same pattern applies.

***

#### ❓ Can I use `Knowledge Retrieval` instead of `GET POLICY`?

Yes. If your policies are stored as chunks in GLIK Knowledge, use the `Knowledge Retrieval` block and query by `policy_reference`.

```yaml
retriever_query:
  policy_name: {{policy_reference}}
```

***

#### ❓ What if my file isn’t found?

Handle this gracefully with a fallback route:

```yaml
IF policy_reference == null OR file not found:
  escalate = true
  error_message = "Policy not found for session"
```

***

#### ❓ Can I pass the full contents of the file into the LLM?

Yes. After `GET POLICY`, pipe the output into your `LLM` block prompt like:

```txt
Here is the policy content:
{{policy_document.text}}

Review this submission against the rules above...
```


# Input Logic & Routing Behavior

This page documents how input variables like user\_region, submission\_type, and user\_role shape the internal logic and execution flow of the Global Control Copilot template.

This page explains how dynamic input variables like `user_region`, `submission_type`, and `user_role` influence policy selection, compliance logic, and escalation behavior within the Global Control Copilot template.

These inputs are extracted via orchestration blocks (e.g., `Parameter Extractor`) and are used to route submissions through jurisdiction-specific logic paths.

***

## 1. Input Sources (Where Values Come From)

| Variable                            | Source Block         | Description                                                       |
| ----------------------------------- | -------------------- | ----------------------------------------------------------------- |
| `sys.files`                         | User Upload          | Contains raw disclosure content (risk, governance, jurisdiction). |
| `user_region`                       | Parameter Extractor  | Set by upstream chat metadata, dropdown, or auto-detected.        |
| `submission_type`                   | Parameter Extractor  | Declared by user form or inferred from workflow setup.            |
| `user_role`                         | Parameter Extractor  | May be prefilled from session or input during form submission.    |
| `risk_exposure`, `checklist_status` | Doc Extractor or LLM | Parsed from `sys.files`, then normalized via enrichment.          |

***

## 2. `user_region`: Determines Policy Source

| Value    | Effect                                                                               |
| -------- | ------------------------------------------------------------------------------------ |
| `EU`     | Loads MiCA policy. Enforces thresholds like €1M exposure, 5-day deadline, etc.       |
| `US`     | Loads SOX-based policy logic. Checks for signoffs and SEC-relevant fields.           |
| `APAC`   | Loads fallback or local templates. Often less rigid in checklist validation.         |
| `Global` | Uses internal generic fallback policy. Used for simulation or pre-alignment testing. |

***

## 3. `submission_type`: Determines Logic Branches

| Value              | Validations Triggered                                         |
| ------------------ | ------------------------------------------------------------- |
| `Disclosure`       | Requires risk, liquidity, governance sections.                |
| `Attestation`      | Requires signatures, audit metadata, compliance officer role. |
| `Exception Report` | Auto-escalates unless a valid policy override is present.     |
| `Incident`         | Evaluates breach detail, event log, and downstream impact.    |

***

## 4. `user_role`: Affects Prompt Tone & Escalation Rules

| Value                | Behavior Adjustments                                              |
| -------------------- | ----------------------------------------------------------------- |
| `Finance Manager`    | Triggers capital/risk validation logic.                           |
| `Legal Counsel`      | Expects attestation chain, stricter audit validation.             |
| `Product Ops`        | Focus on procedural policy routing; may tolerate soft violations. |
| `External Submitter` | Triggers early flagging, stricter trust boundaries.               |

***

## 5. Combined Example

If the submission is from:

* `user_region = EU`
* `submission_type = Disclosure`
* `user_role = Finance Manager`

Then:

* MiCA logic is loaded (via `Knowledge Retrieval`)
* Risk exposure and liquidity sections are required
* Checklist omission triggers escalation
* Summary tone addresses internal financial policy compliance

***

## 6. Required Blocks to Support This

To enable this dynamic behavior, the template must include:

* `Parameter Extractor` → to set `user_region`, `submission_type`, `user_role`
* `Knowledge Retrieval` → to fetch the correct policy content
* `Variable Assigner` → to inject threshold values (e.g., exposure limits)
* `Doc Extractor` or `LLM` → to parse the uploaded file and pull out key sections
* `IF/ELSE` → to branch based on compliance
* `Agent` and `LLM` → to escalate or summarize
* `Save Point` → to log and export session metadata

***

## 7. Code Block Example: Variable Payload

The following is a sample of how these input variables might appear inside the orchestration memory or test payload. This structure is useful for debugging, test configuration, or SDK integration when simulating different jurisdictional conditions.

```yaml
# Example Input Variable Payload
user_region: EU
submission_type: Disclosure
user_role: Finance Manager

# Derived values from parsed file (via LLM or Doc Extractor)
risk_exposure: 4200000
checklist_status: Complete
submission_date: 2025-05-24
policy_reference: MiCA
issuer_name: TokenBridge Capital Ltd.
```

This structure allows downstream logic blocks to reason based on both user-declared context (`user_region`, `submission_type`, `user_role`) and parsed content from uploaded files (`risk_exposure`, `issuer_name`, etc.).

For testing or debugging, these fields can be passed directly into a Variable Assigner block or used as fixed test cases during QA.

***

## 8. Example LLM Prompt Template (Dynamic Inputs)

This is a sample prompt used inside the **LLM reasoning block** to evaluate whether the uploaded compliance submission meets applicable policy requirements. It demonstrates how the system references both declared context variables and parsed data.

```txt
You are a compliance reasoning agent reviewing a policy disclosure report.

Jurisdiction: {{user_region}}  
Submission Type: {{submission_type}}  
User Role: {{user_role}}  
Policy Framework: {{policy_reference}}  

Evaluate the submission based on the following extracted details:

- Issuer: {{issuer_name}}  
- Reported Risk Exposure: €{{risk_exposure}}  
- Capital Buffer Checklist: {{checklist_status}}  
- Submission Date: {{submission_date}}

Determine whether the submission:
1. Meets the policy thresholds based on the loaded policy ({{policy_reference}})
2. Contains all required sections for the submission type ({{submission_type}})
3. Requires escalation based on missing, incomplete, or delayed information

If the submission is compliant, generate a brief summary of why.  
If not, identify the violations and recommend next steps.
```

This pattern ensures consistent reasoning across jurisdictions and allows developers to structure prompt logic around contextual input variables without hardcoding static policy rules.

***

## 9. Escalation Logic Conditions (Examples)

The Global Control Copilot uses conditional logic blocks (like `IF/ELSE`) to evaluate whether a submission meets policy thresholds or requires escalation to a human reviewer. These conditions are derived from both user-declared inputs and parsed values.

Here are example escalation triggers based on variable conditions:

***

#### 🔍 Conditional Logic Triggers

| Condition                                                              | Explanation               | Escalation Action                |
| ---------------------------------------------------------------------- | ------------------------- | -------------------------------- |
| `risk_exposure > 1000000` and `user_region == "EU"`                    | MiCA limit exceeded       | Escalate to compliance analyst   |
| `checklist_status != "Complete"` and `submission_type == "Disclosure"` | Required section missing  | Trigger user guidance + escalate |
| `submission_date > deadline_by_policy`                                 | Late submission           | Flag and route to manual review  |
| `user_role == "External Submitter"` and `attestation_missing == true`  | Trust boundary exceeded   | Auto-escalation with warning     |
| `submission_type == "Exception Report"` and `override_reason == null`  | No justification provided | Block auto-approval and escalate |

***

#### 🧠 Memory Variables Involved

* `risk_exposure` (float)
* `checklist_status` (enum: `Complete`, `Incomplete`, `Missing`)
* `submission_date` (date)
* `user_region`, `user_role`, `submission_type` (string)
* `attestation_missing` (boolean)
* `override_reason` (string/null)

***

#### ✨ Escalation Outputs

When triggered, these conditions typically route the workflow to:

* An `Agent` block (e.g., assigned to a compliance reviewer)
* An `LLM` block to generate a detailed explanation for the user
* A `Save Point` block for logging the flagged session

***

## 10. Auto-Approval Logic Conditions (Examples)

While escalation rules define when to stop and escalate, **auto-approval rules** help define a “clean pass” scenario — where no manual review is needed.

| Condition                                                              | Explanation                 | Auto-Approval Action                     |
| ---------------------------------------------------------------------- | --------------------------- | ---------------------------------------- |
| `risk_exposure <= 1000000` and `user_region == "EU"`                   | MiCA threshold respected    | Allow approval summary generation        |
| `checklist_status == "Complete"` and `submission_type == "Disclosure"` | Disclosure fully filled     | Proceed to HTTP API export               |
| `attestation_verified == true` and `submission_type == "Attestation"`  | External review confirmed   | Mark submission valid without escalation |
| `override_reason != null` and `submission_type == "Exception Report"`  | Justified exception present | Log with reasoning and approve           |
| `submission_date <= policy_deadline`                                   | On-time report              | Skip delay flag, proceed to approval     |

These conditions trigger an `LLM` → `HTTP Request` → `Save Point` path.

***

## 11. Block-Level Wiring Map (Execution Flow Summary)

Below is a high-level description of how these logic conditions are implemented using GLIK Studio blocks:

#### 🔁 Decision Flow in Orchestration

1. **File Upload** (`sys.files`)
   * Ingested at start node or through chat form
2. **Parameter Extractor Block**
   * Sets: `user_region`, `submission_type`, `user_role`
3. **Doc Extractor / LLM Parser Block**
   * Parses `risk_exposure`, `checklist_status`, `attestation_verified`, `submission_date`
4. **IF/ELSE Block — “Is Submission Compliant?”**
   * Evaluates combined conditions:

     ```yaml
     if:
       risk_exposure <= threshold_by_region
       and checklist_status == "Complete"
       and submission_date <= policy_deadline
     ```
5. **IF path → Auto-Approval Track**
   * `LLM Block`: generate approval summary
   * `HTTP Request`: post to compliance API
   * `Save Point`: log session summary
6. **ELSE path → Escalation Track**
   * `Agent Block`: escalate for review
   * `LLM Block`: explain rejection or missing elements
   * `Save Point`: export violation metadata


# Predefined Policy Thresholds

Reference policy rules (MiCA, SOX, GDPR) used for threshold logic in the Global Copilot — mapped by user\_region and injected dynamically.

This page documents sample policy rule sets and threshold values used by the **Global Control Copilot – Cross-Jurisdiction Policy Interpreter** template.

These rules are dynamically selected at runtime based on the values of `user_region` and `submission_type`. They are then injected into the workflow using a `Variable Assigner` or `Knowledge Retrieval` block and can be used to determine auto-approval, escalation, or user guidance behavior.

***

### 🔍 How Policies Are Used in GLIK

Policy definitions can be used to:

* Populate compliance thresholds (e.g., exposure caps, deadline limits)
* Control which sections are required for a submission to pass
* Inform `LLM` reasoning blocks about regulatory expectations
* Enable auto-approval or trigger escalation pathways
* Support jurisdiction-specific logic, without rewriting the workflow

They can be injected in three main ways:

1. **Variable Assigner** block (static config or memory preload)
2. **Knowledge Retrieval** block (dynamic policy fetch)
3. **Preloaded session memory** (for SDK and automation use)

***

### 🌐 Example Policy Rule Sets

***

#### 🧾 MiCA (Markets in Crypto-Assets)

```yaml
policy_reference: MiCA
risk_exposure_limit_eur: 1000000
reporting_deadline_days: 5
checklist_required: true
attestation_required: true
liquidity_disclosure_required: true
```

***

#### 🧾 SOX (Sarbanes-Oxley Act)

```yaml
policy_reference: SOX
quarterly_disclosure_deadline_days: 45
cfo_attestation_required: true
audit_trail_required: true
sec_submission_flag: true
```

***

#### 🧾 GDPR (General Data Protection Regulation)

```yaml
policy_reference: GDPR
incident_disclosure_window_hours: 72
data_classification_required: true
dpo_approval_required: true
audit_log_required: true
```

***

### 🔁 Dynamic Policy Loading

These rules can be fetched dynamically using a `Knowledge Retrieval` block, where `user_region` or `submission_type` is passed in as a query variable. This allows the template to stay modular and respond to jurisdiction-specific needs in real time.

Example:

```yaml
retriever_query:
  policy_name: {{user_region}}_compliance_policy
```

***

### 🧰 Fallback Behavior (Missing or Null Policy Values)

If any required threshold (e.g., `risk_exposure_limit_eur`) is missing or malformed:

* The workflow should default to **safe mode** — typically triggering escalation
* You can add an `IF/ELSE` guard:

  ```yaml
  if risk_exposure_limit_eur == null:
    escalate = true
  ```
* `LLM` blocks can also be configured to explain "policy unknown" conditions gracefully to the end user

***

### ⚙️ Overriding Policies Mid-Session

GLIK workflows can support dynamic override logic — for example, if `submission_type == Exception Report` and the user provides a valid `override_reason`, policy rules can be conditionally relaxed.

Use an `IF/ELSE` block:

```yaml
if submission_type == "Exception Report" and override_reason != null:
  apply_exception_handling = true
```

***

### 📦 Storing Policies in GLIK Knowledge

Instead of using YAML only, policy definitions can also be stored in **GLIK Knowledge** as structured chunks or JSON nodes. This is ideal for organizations managing multiple policies or updates over time.

Use `Knowledge Retrieval` to query:

* MiCA policies by country
* GDPR enforcement by sector
* Internal control matrices

***

### 📌 Best Practices

* Keep policy keys consistent across all regions for easier variable mapping
* Use `user_region` and `submission_type` together to disambiguate edge cases
* Always log which policy was used via `Save Point` or memory trace

***

### 📄 Related Pages

* [Input Logic & Routing Behavior](/templates/compliance-advisors/global-control-copilot-cross-jurisdiction-policy-interpreter/input-logic-and-routing-behavior)
* [Compliance Copilot – MiCA Reporting](/templates/compliance-and-audit-automation/compliance-copilot-mica-reporting)
* [Blocks & Nodes Overview](/system-architecture/blocks-and-nodes)


# Knowledge Systems

Transform static documentation into intelligent agents that deliver answers, guide tasks, and accelerate execution—without changing your existing systems.

Most enterprises are sitting on mountains of institutional knowledge: standard operating procedures (SOPs), policy manuals, onboarding guides, customer service scripts, product documentation, internal wikis, and archived PDFs. But that knowledge is fragmented, outdated, and inaccessible at the moment of need.

GLIK’s Knowledge Systems templates let you **agentify these legacy knowledge assets**, turning them into conversational, intelligent, and actionable agents. These agents don’t just search documents—they understand them, reason over them, and return context-aware answers instantly.

***

### Enterprise Value

* **Compress Training Time from Weeks to Hours**\
  Replace passive training materials with agents that actively walk employees through real workflows and answer questions in real time.
* **Preserve and Operationalize Tribal Knowledge**\
  Capture decades of undocumented know-how and deliver it as structured, traceable agent responses—especially in regulated or high-turnover environments.
* **Make Internal Docs Useful Again**\
  From forgotten SOPs to 200-page policy manuals, knowledge agents surface relevant content when it matters most—without manual searching.
* **Lower Support Costs**\
  Reduce internal support tickets and clarification loops by letting agents resolve questions without manager intervention.
* **Scale Expertise Across Locations and Teams**\
  Ensure every team—whether in Manila or Munich—gets consistent, policy-aligned guidance across any process or system.

***

### When to Use This Template Genre

| **Preexisting System or Context**                    | **Agentified Solution Using Knowledge Systems**                            |
| ---------------------------------------------------- | -------------------------------------------------------------------------- |
| SOPs for IT ticket routing, HR tasks, safety checks  | SOP Navigator Agent (interactive Q\&A and task walkthroughs)               |
| Outdated internal helpdesk knowledge base            | Self-updating Knowledge Agent trained on latest docs and decisions         |
| Customer service scripts and email templates         | Response Composer Agent that adapts tone, policy, and escalation logic     |
| Onboarding documents for new hires                   | New Hire Copilot Agent that answers questions and guides setup             |
| Legal or policy archives stored as PDFs or Word docs | Compliance Reference Agent that fetches the right clause or rule on demand |

***

### Why This Matters Now

Enterprises can no longer afford the cost of **inefficient knowledge access**. When answers are buried in SharePoint folders, employee time is wasted, mistakes are made, and policies are inconsistently followed. Worse, the value of institutional memory is lost every time someone leaves.

GLIK’s Knowledge System templates let you **skip the content migration**, avoid custom integrations, and go straight from “PDF on disk” to “live agent in production.” These agents deliver immediate ROI—helping people work faster, learn faster, and stay compliant.

***

### Related Templates

While **Compliance Advisors** focus on interpreting rules, and **Policy Automation** on enforcing them, Knowledge Systems are about **making the right knowledge available in the moment of action**.

These templates often serve as the **foundation** for other agents—powering escalation flows, fallback reasoning, or in-task clarification across departments.


# Overview

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# Compliance SOP Agent

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# Process Automation

Agentify cross-system handoffs, validations, and approvals — inside the tools you already use. No system migrations. No manual routing. Just faster decisions, everywhere.

Many enterprise processes—form intake, record updates, file routing, task triage—still rely on manual work, email chains, or disconnected legacy systems. GLIK’s Process Automation templates transform these workflows into intelligent, self-executing agents that operate inside or alongside your existing systems.

These agents don’t make compliance decisions or enforce policies—they **perform structured actions**, move data between systems, and ensure task completion without human bottlenecks. They are designed to replicate repetitive operational steps across finance, HR, procurement, and customer support environments—where inefficiency leads directly to cost.

***

### Enterprise Value

* **Free Teams from Low-Value Manual Tasks**\
  Eliminate rote process steps like file renaming, form parsing, or ticket tagging—so employees focus on resolution, not repetition.
* **Bridge Disconnected Systems Without New Integrations**\
  Use agents to move information between old systems (e.g. shared folders → ERP forms) without needing a middleware overhaul.
* **Accelerate Task Completion Across Teams**\
  Replace email-driven handoffs with agents that automatically assign, route, and verify completion of steps across stakeholders.
* **Reduce Errors and Rework**\
  Let agents standardize inputs, sanitize formats, and validate information before the next step is triggered.
* **Agentify Workflows Without Rebuilding Them**\
  Wrap process automation around legacy tools like SharePoint, SAP, email inboxes, or file-based workflows—delivering transformation without disruption.

***

### When to Use This Template Genre

| **Existing Workflow**                                     | **Agentified Example Using Process Automation**                                  |
| --------------------------------------------------------- | -------------------------------------------------------------------------------- |
| Manual form submissions and email handoffs                | Form Intake Agent that validates entries and routes to appropriate team          |
| Routing scanned documents into folders or systems         | File Triage Agent that names, tags, and stores files correctly                   |
| Processing requests from email into CRMs or ERPs          | Request Processing Agent that parses email and submits structured data           |
| Assigning repetitive approval steps manually              | Multi-step Workflow Agent that progresses tasks through all required checkpoints |
| Copy/paste workflows between systems (e.g., finance → HR) | Cross-System Sync Agent that handles data propagation with transformation logic  |

### How It Differs from Policy Automation

| **Process Automation**                             | **Policy Automation**                                          |
| -------------------------------------------------- | -------------------------------------------------------------- |
| Focuses on **executing actions and routing steps** | Focuses on **making decisions and applying rules**             |
| Does not evaluate policy logic or enforce rules    | Makes approve/reject/escalate decisions based on encoded logic |
| Replaces **manual steps and inefficiencies**       | Replaces **inconsistent judgment and rule violations**         |
| Examples: triage, intake, task routing             | Examples: expense approval, compliance threshold enforcement   |

### Why Process Automation Matters

Most enterprise inefficiencies aren't caused by bad decisions—they're caused by **slow, fragmented, or manual processes**. GLIK’s Process Automation templates deliver immediate ROI by accelerating, error-proofing, and simplifying these processes—without forcing enterprises to rip out existing tools.

With these templates, GLIK becomes the connective tissue that automates handoffs, reduces noise, and ensures things get done—no code rewrite required.


# Task Resolution Agents

Automate the resolution of multi-step, cross-functional tasks with agents that take initiative—not just automate steps.

In enterprise environments, many tasks don’t just require simple automation—they require **resolution**. That means multiple steps, multiple parties, conditional logic, follow-ups, and a clear end state: **the task is complete, the issue is closed, or the user is satisfied.**

GLIK’s **Task Resolution Agents** are designed for these outcomes. These are not lightweight process automations or form bots. They are **proactive, multi-step agents** that drive tasks forward—chaining decisions, triggering follow-ups, escalating exceptions, and verifying that resolution criteria are met.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

### Why We Call These "Agents" (Not Just Automation)

Some template genres are called **Automation** because they focus on streamlining **static, linear processes** (like routing a document or logging an action). But **Task Resolution Agents** involve **autonomous behavior**: they interpret status, apply logic, interact across systems or roles, and persist across sessions until a goal is reached.

We use the term **agent** when the system isn’t just executing a function—it’s **owning the outcome.**

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

### Enterprise Value

* **Shorten Resolution Times for Complex Tasks**\
  Automate multi-step flows like onboarding, procurement, IT provisioning, or exception handling—without ping-ponging across teams.
* **Reduce Manual Follow-Ups and Missed Steps**\
  Let agents track what’s completed, what’s pending, and what needs escalation—so no resolution chain breaks down.
* **Ensure Consistent Task Handling Across Departments**\
  Codify best practices into agents that resolve tasks the same way every time, regardless of who initiates them.
* **Handle Exceptions Without Rewriting Processes**\
  Agents can escalate, reassign, or explain failure modes—without breaking your core process flows.
* **Agentify Legacy Ticketing, Workflow, or Case-Based Systems**\
  Instead of waiting for users to move tickets or complete checklists, let agents take ownership of the full resolution path.

{% hint style="info" %}
Project tools track tasks—[**GLIK agents resolve them**](/templates/task-resolution-agents/why-agentify-task-resolution). Agents take action, escalate intelligently, and persist across systems until the job is done. Less chasing. More closing.
{% endhint %}

### When to Use This Template Genre

| **Legacy or Manual Scenario**                  | **Agentified Task Resolution Example**                                          |
| ---------------------------------------------- | ------------------------------------------------------------------------------- |
| HR team manually coordinating onboarding tasks | New Hire Agent that sequences accounts, equipment, and policy steps             |
| IT manually provisions user access and assets  | IT Setup Agent that creates tickets, tracks progress, escalates delays          |
| Finance team follows up on payment disputes    | Payment Dispute Agent that triages docs, tracks approvals, and closes loop      |
| Procurement requests lost in email threads     | Purchasing Resolution Agent that drives requisition to approval                 |
| Compliance reviews happen inconsistently       | Review Completion Agent that checks logs, alerts managers, and confirms closure |

***

### How This Differs from Process Automation

| **Task Resolution Agents**                          | **Process Automation**                                    |
| --------------------------------------------------- | --------------------------------------------------------- |
| Own the **end-to-end outcome** of a multi-step task | Automate a specific step or handoff in a broader workflow |
| Persist across time and handle escalation           | Execute immediately and stop                              |
| Involve multiple roles or departments               | Typically confined to a fixed logic flow                  |
| Goal: “Is the task resolved?”                       | Goal: “Was the process executed?”                         |

***

### Why Task Resolution Deserves Agents

Enterprises rely on thousands of recurring tasks—onboarding, provisioning, vendor setup, case handling. These tasks often fall through the cracks because they’re too complex for simple automation, but too mundane for high-priority project management.

GLIK enables you to assign these responsibilities to agents—turning multi-step coordination into repeatable, reliable, intelligent resolution flows. You don’t need to rebuild your workflows. You just need agents that can see the whole picture and finish the job.


# Why Agentify Task Resolution

Enterprises spend millions on task and project management platforms—Jira, Asana, ServiceNow, Workday, SAP, and more—to track work across teams. Yet despite this, task resolution remains slow, inconsistent, and reliant on human follow-through.

The problem is simple: **project tools track**, but they don’t **resolve**. GLIK Task Resolution Agents close that gap.

GLIK delivers a layer of agent intelligence that **wraps around your existing systems**, taking direct action to **move tasks forward**, **apply rules**, and **resolve workflows end-to-end**—not just log their status.

***

## The Reality of Task Management Today

Modern task and project platforms have made enterprise workflows visible. But they haven't made them fast, reliable, or self-executing.

Teams still chase status updates, escalate delays manually, and close tasks days or weeks after the resolution criteria were actually met. This is especially true for:

* Cross-departmental handoffs
* High-volume service workflows (HR, IT, finance)
* Policy-governed processes
* Exception-based work (compliance, onboarding, procurement)

These aren’t software limitations—they’re **workflow ownership failures**. GLIK agents solve this by **owning the outcome.**

***

## The Strategic Gap: Visibility ≠ Resolution

| Traditional Project/Task Tool | GLIK Task Resolution Agent                             |
| ----------------------------- | ------------------------------------------------------ |
| Logs the task                 | Takes action to complete the task                      |
| Waits for human input         | Detects state and initiates the next logical step      |
| Tracks status                 | Updates status *and* takes corrective action if needed |
| Sends reminders               | Escalates with context and supporting data             |
| Displays the checklist        | Executes the checklist                                 |

Modern software tells you **what needs to happen**. GLIK agents ensure it **actually happens**.

***

## Agentification: A Cost-Saving, Efficiency-Driving Layer

GLIK agents don’t replace project management systems. They plug into them or wrap around them—automating structured resolution logic wherever manual effort slows things down.

This unlocks:

* **Fewer human hours spent on follow-ups**
* **Faster task completion without delays or missed steps**
* **Higher consistency across departments and teams**
* **Reduced context-switching and overhead for knowledge workers**
* **End-to-end auditability for every completed resolution flow**

In short: **less chasing, more closing**.

***

## Enterprise Scenarios Where GLIK Agents Deliver ROI

| Legacy System or Workflow                     | GLIK Agentified Resolution Flow                                                                     |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| HR provisioning managed in spreadsheets       | Onboarding Agent completes account setup, equipment requests, and policy confirmations across tools |
| Procurement email requests routed by hand     | Resolution Agent triages vendors, checks budgets, and escalates exceptions until fully resolved     |
| Compliance reviews logged manually in docs    | Agent flags reviews, validates document completion, and archives resolution log                     |
| IT tickets spread across Jira, email, Slack   | Agent ensures all required steps are completed and closes tickets based on full scope logic         |
| Finance follow-ups scattered across platforms | Agent monitors status, triggers approvals, updates ERP system, and confirms payment flow            |

## Implementation is Simple: No Need to Rip & Replace

GLIK is system-agnostic. Agents can:

* Watch existing tickets, tasks, and flows
* Pull data from legacy tools (including email, SharePoint, SAP, and Slack)
* Push updates into CRMs, ERPs, PM platforms, or file systems
* Escalate via internal channels when blockers arise

There’s no need to rebuild your task infrastructure. You’re simply **assigning responsibility to an agent who will see it through.**

***

## Why GLIK? Why Now?

As enterprise work becomes more distributed, asynchronous, and rules-driven, the cost of **incomplete resolution** keeps rising—both in lost time and operational risk.

GLIK turns your knowledge, policies, and workflows into **agents that act**. Not just track. Not just remind. But finish the job.

> You don’t need more dashboards.\
> You need fewer open loops.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>


# Work Coordination Agents

Coordinate timing, ownership, and accountability across fragmented workflows—without adding more managers or meetings.

Work doesn’t fail because no one knows *what* to do. It fails because no one knows *when* to do it, *who* is supposed to do it, or whether it’s already been done.

GLIK’s **Work Coordination Agents** specialize in solving that problem.

These agents don’t own the task itself—but they ensure the task flows through the right people, in the right sequence, at the right time. They coordinate reminders, handoffs, nudges, and escalations—especially in asynchronous, cross-departmental, or deadline-driven environments where human follow-through is inconsistent or delayed.

<details>

<summary>Copilots vs Agents </summary>

**Copilot:** A **collaborative AI assistant** embedded into enterprise tools that helps users complete tasks by offering real-time guidance, clarification, and policy interpretation.

* Requires user input
* Embedded directly into UI
* Guides users without replacing them

**Agent:** An **autonomous AI worker** that independently executes steps, applies logic, and resolves workflows—often across systems or without user prompting.

* Executes tasks on its own
* Operates in the background or via workflows
* Designed to reduce or replace human labor for routine steps

> **GLIK Rule of Thumb:** Use a **copilot** when the user is completing the task and needs help. Use an **agent** when the system can (and should) complete the task independently.

</details>

## What Are Work Coordination Agents?

Work Coordination Agents act as **digital coordinators** embedded into workflows. They don’t resolve tasks like Task Resolution Agents. They don’t move data like ERP Agents. They don’t optimize operations like Logistics Agents.

Instead, they ensure:

* Tasks are picked up on time
* Hand-offs don’t stall
* Status doesn’t go stale
* And no one says, “Sorry, I didn’t know that was mine”

They **track commitments, trigger actions, and escalate ambiguity**—not as a tracker, but as an intelligent actor that keeps the work in motion.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

### How They Differ from Other Agent Types

| Work Coordination Agents                         | Task Resolution Agents                            | ERP/Logistics Agents                                   |
| ------------------------------------------------ | ------------------------------------------------- | ------------------------------------------------------ |
| Manage **ownership, timing, and accountability** | Resolve tasks end-to-end with business logic      | Move or sync structured data within enterprise systems |
| Focus on **flow control and people handoffs**    | Focus on outcomes and exception closure           | Focus on structured system-to-system transactions      |
| Trigger escalations, reminders, and reassignment | Make policy-driven decisions and execute outcomes | Process receipts, orders, or resource updates          |
| Example: SLA breach escalator, follow-up tracker | Example: onboarding resolution agent              | Example: purchase order agent, restocking agent        |

## Enterprise Value

* **Eliminate Delays Caused by Handoff Failure**\
  Agents ensure work doesn’t get stuck between departments or dropped when roles shift.
* **Preserve Accountability Without Adding Overhead**\
  Let agents track who’s responsible for what and trigger reminders—without needing a project manager in every process.
* **Maintain Workflow Momentum**\
  Agents keep multi-actor flows on track by managing state, timers, deadlines, and fallback routing.
* **Improve SLA and Compliance Adherence**\
  Ensure resolution deadlines are met, escalations happen on time, and tasks don’t slip through the cracks.
* **Agentify Cross-Team Coordination Without New Infrastructure**\
  Plug into existing systems—Slack, email, ticketing platforms, ERPs—and drive coordination without rebuilds.

***

## When to Use This Template Genre

| **Scenario**                                              | **Work Coordination Agent Solution**                                  |
| --------------------------------------------------------- | --------------------------------------------------------------------- |
| A ticket waits for 3 days because no one claimed it       | SLA Reminder Agent triggers warning, reassigns, or escalates          |
| Handoff from HR to IT gets lost during onboarding         | Handoff Tracker Agent confirms step completion and notifies next team |
| Compliance reviews miss their internal deadlines          | Review Deadline Agent alerts reviewers and flags overdue items        |
| Team members forget to submit expense reports on time     | Submission Window Agent reminds based on policy-driven deadlines      |
| Distributed teams can't tell when they're blocking others | Blocking Chain Agent surfaces dependencies and assigns responsibility |

***

## Why Coordination Itself Deserves Agentification

Enterprise execution is increasingly **asynchronous**, **multi-actor**, and **dependent on timing**. But most systems still rely on static workflows and static people—who forget, delay, or miscommunicate.

GLIK’s Work Coordination Agents bring a **real-time, persistent awareness layer** to your processes. They manage flow—not just tasks.

You don’t need more status meetings. You need agents that can **watch the workflow and move it forward.**


# Escrow Agent Orchestration

The **Escrow Agent Orchestration** template coordinates the **multi-party logic**, **conditional approvals**, and **timed release mechanisms** that power escrow agreements — whether between asset issuers, buyers, legal validators, or custodians.

Built for both **tokenized asset transactions** and **off-chain legal agreements**, this agent handles the structured back-and-forth needed to secure trust in complex handoffs, approvals, and milestone-based releases.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FqsUdEBK6ajb4S9IWuGjt%2Fimage.png?alt=media&amp;token=8848eda8-bc10-4cc1-b1bc-945a7c5502f0" alt=""><figcaption><p>This segment of the Escrow Agent Orchestration workflow performs real-time analysis on each section of the uploaded agreement. After enriching the section with external metadata (e.g., KYC status, wallet verification), a Gemini-powered LLM summarizes deal-specific risk factors. The workflow then queries compliance policies via knowledge retrieval to validate terms and conditions. These blocks form the core logic loop, enabling dynamic, section-by-section orchestration before downstream escalation, approval, or decision synthesis logic is applied.</p></figcaption></figure>

### 🔧 Use Case Examples

<table data-view="cards"><thead><tr><th>Scenario</th><th>Description</th></tr></thead><tbody><tr><td><strong>Tokenized Gold Sale</strong></td><td>Orchestrate the approval chain between seller, buyer, compliance officer, and delivery custodian</td></tr><tr><td><strong>Cross-jurisdictional real estate tokenization</strong></td><td>Ensure all legal documentation is uploaded, reviewed, and signed before contract release</td></tr><tr><td><strong>RWA Custody Transfer</strong></td><td>Automate escrow conditions between asset issuer, liquidity provider, and token registrar prior to on-chain minting</td></tr></tbody></table>

***

### ⚙️ Workflow Architecture

<table data-view="cards"><thead><tr><th>Component</th><th>Function</th></tr></thead><tbody><tr><td><strong>Escrow Agreement Upload</strong></td><td>Buyer or issuer uploads agreement terms and initiates deal flow</td></tr><tr><td><strong>Party Assignment Block</strong></td><td>Identifies all stakeholders and their roles (Issuer, Buyer, Compliance, Legal, Custody)</td></tr><tr><td><strong>Approval Chain Logic</strong></td><td>Conditional blocks for multi-party sign-off and jurisdictional rules</td></tr><tr><td><strong>Time-Based Hold Logic</strong></td><td>Optional “timelock” logic before funds or assets can be moved</td></tr><tr><td><strong>Save Point Memory Block</strong></td><td>Stores every decision, message, document, and sign-off state for traceability</td></tr><tr><td><strong>Final Trigger Node</strong></td><td>If all conditions are met, trigger smart contract, release asset, or notify external system (e.g., Swarm, Copper, Fireblocks)</td></tr></tbody></table>

***

### 🔐 Designed For

* **Legal compliance teams** coordinating approvals across regions or asset types
* **Broker-dealers or transfer agents** managing escrow mechanics with multiple counterparties
* **Asset tokenization platforms** like Swarm where off-chain approvals precede on-chain actions
* **Custodians and validators** who must wait for upstream consensus before executing custody triggers

***

### 🧠 Strategic Value

* Reduces human coordination bottlenecks
* Creates a transparent, versioned memory of every stage in the escrow process
* Prevents execution before validation — reducing reputational and regulatory risk
* Operates as a policy-aware precondition layer for on-chain contracts

***

### 🚀 Coming Soon to GLIK Marketplace

This template will be available in the **Work Coordination Agents** category in the GLIK Marketplace. Partners and institutions will be able to:

* Install directly into any GLIK workspace
* Customize stakeholder roles and sign-off sequences
* Integrate external APIs or smart contracts as the “final release” logic


# ClickUp Coordination Copilot


# Copilot Architecture


# Workflow & Orchestration


# Block-by-Block Guide


# Input & Output Formats


# Persistent Behavior Config


# Practice Exercises


# Deployment Instructions


# Internal Use & Dogfooding


# Embedded Operational Copilots

Embed intelligent copilots directly into enterprise tools to help users complete high-friction tasks—faster, smarter, and with less training.

ERPs, HR portals, finance tools, procurement dashboards—are complex, outdated, or unintuitive. Employees spend hours navigating them, asking coworkers for help, or escalating support tickets just to get through basic workflows.

GLIK’s **Embedded Operational Copilots** change that.

These agents sit *inside* the tools people already use. They guide users step-by-step through policies, approvals, configurations, and data inputs—offering clarification, surface-level reasoning, and proactive suggestions as the user works.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

## What Are Copilots?

Unlike standalone agents that **act independently** to complete tasks behind the scenes, **copilots are collaborative**—they assist the user in completing a task, but **don’t take over ownership**.

They are:

* **Context-aware**: understand what the user is doing
* **Interface-embedded**: run inside the application
* **Instructional**: suggest, explain, and support user decisions
* **Persistent**: remain available across workflows, without needing relaunch

<details>

<summary>Copilots vs Agents </summary>

**Copilot:** A **collaborative AI assistant** embedded into enterprise tools that helps users complete tasks by offering real-time guidance, clarification, and policy interpretation.

* Requires user input
* Embedded directly into UI
* Guides users without replacing them

**Agent:** An **autonomous AI worker** that independently executes steps, applies logic, and resolves workflows—often across systems or without user prompting.

* Executes tasks on its own
* Operates in the background or via workflows
* Designed to reduce or replace human labor for routine steps

> **GLIK Rule of Thumb:** Use a **copilot** when the user is completing the task and needs help. Use an **agent** when the system can (and should) complete the task independently.

</details>

## How Copilots Differ from Agents

| Embedded Operational Copilots                           | Autonomous Agents (e.g. Task Resolution, Policy)            |
| ------------------------------------------------------- | ----------------------------------------------------------- |
| **Work alongside users** in real time                   | Act independently and execute tasks on behalf of users      |
| Appear inside enterprise UIs (e.g. SAP, Workday)        | Often work in the background or across tools                |
| Provide help, clarification, and suggestions            | Apply logic and enforce rules autonomously                  |
| Great for training, support, and step-by-step actions   | Great for decision enforcement, routing, and automation     |
| Analogy: an intelligent assistant in the passenger seat | Analogy: a self-driving service completing the trip for you |

***

## Enterprise Value

* **Reduce Support Ticket Volume**\
  Copilots help users help themselves—reducing IT, HR, and ops escalations.
* **Accelerate Task Completion Inside Legacy Tools**\
  Provide intelligent assistance for navigating complex systems like SAP, Oracle, or ServiceNow.
* **Lower Training and Onboarding Costs**\
  New hires get live guidance instead of PDFs and long ramp-up cycles.
* **Improve Policy Adherence Through In-Context Guidance**\
  Copilots explain rules and thresholds in real time—before users make mistakes.
* **Agentify UX Without Rebuilding the UI**\
  Drop copilots into portals, dashboards, or apps without redesigning the entire system.

***

## When to Use This Template Genre

| **Use Case**                                           | **Copilot Solution**                                              |
| ------------------------------------------------------ | ----------------------------------------------------------------- |
| Employee struggles to submit travel reimbursement      | Embedded Finance Copilot walks through policy and form steps      |
| New manager navigating HR approval workflows           | HR Ops Copilot explains thresholds and escalates edge cases       |
| Field agent needs help entering sales orders correctly | ERP Copilot checks logic and alerts about invalid input           |
| Employee using a confusing internal procurement portal | Procurement Copilot suggests categories and flags missing data    |
| User unsure how to request time off under new policy   | Leave Request Copilot interprets policy and walks through options |

***

## Why Copilots Are the Next Layer of UX Agentification

Most enterprise UX problems don’t require new interfaces—they require **supportive intelligence inside the existing ones**.

GLIK copilots provide that: always-on, user-aligned, enterprise-aware guidance that sits where the friction is.

> You don’t need smarter forms.\
> You need a smarter guide sitting inside the form.

With Embedded Operational Copilots, GLIK becomes the layer that turns friction into flow.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>


# Expense & ERP Agents

Agentify your finance, accounting, and ERP systems to reduce leakage, accelerate approvals, and enforce policy with precision—without rebuilding your backend.

ERP platforms like SAP, Oracle, NetSuite, and Workday are the operational backbone of large enterprises. But despite decades of automation, these systems still require **manual approvals, human exception handling, and policy interpretation** that slows down finance operations and introduces risk.

GLIK’s **Expense & ERP Agents** act as intelligent layers that **wrap around your existing platforms** to make your financial workflows faster, safer, and more adaptive. These agents handle decisions, escalate exceptions, check policy thresholds, and validate transactions across your financial stack—without needing invasive changes to your core ERP infrastructure.

***

### Why Agentify ERP and Finance Systems?

Because **traditional ERP systems are built for structure—not intelligence.**

They process forms, move data, and log entries. But they don’t:

* Interpret complex or evolving policies
* Handle fuzzy, exception-based decisions
* Adapt to dynamic thresholds or contextual business logic
* Reduce dependency on humans for triage, escalation, or justification

That’s where agents step in.

> GLIK agents don’t replace your ERP system.\
> They **fill the judgment gap** and reduce the operational drag that slows it down.

<details>

<summary>ERP Vendor AI Copilots and Agents</summary>

Your ERP copilot improves the UI. **GLIK gives you a policy-aware, goal-driven AI that operates across UIs, systems, and workflows.** It doesn’t just assist. It resolves.

</details>

### Enterprise Value

* **Accelerate Expense Approvals Without Sacrificing Control**\
  Agents validate thresholds, vendor status, and documentation before routing for human sign-off—if needed at all.
* **Catch Errors and Violations Before They Hit the Books**\
  Policy-aware agents flag anomalies, excessive charges, or blacklisted vendors before data is finalized.
* **Minimize Manual Review Workload**\
  Let agents screen expense reports, receipts, and PO requests against encoded policies 24/7.
* **Increase Consistency in Policy Enforcement Across Departments**\
  Standardize financial controls by making agents the frontline for rule interpretation and application.
* **Add Intelligence to Static Workflows**\
  Embed logic into ERP processes that would otherwise require human intuition or judgment.

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

## When to Use This Template Genre

| **ERP Use Case or Finance Workflow**              | **GLIK Agentified Upgrade**                                             |
| ------------------------------------------------- | ----------------------------------------------------------------------- |
| Expense approvals based on email and spreadsheets | Agent validates policy thresholds, flags violations, routes exceptions  |
| Travel reimbursements routed inconsistently       | Agent enforces per diem rules, guest policies, receipt compliance       |
| Purchase orders lack contextual review            | Agent checks vendor lists, cost thresholds, and past purchasing history |
| Accounting staff manually resolves exceptions     | Agent detects pattern anomalies and applies escalation workflows        |
| Expense policy updates take weeks to propagate    | Agent reflects updated policy logic instantly across approvals          |

## How This Differs from Policy Automation or Process Automation

| Expense & ERP Agents                           | Policy Automation                    | Process Automation                         |
| ---------------------------------------------- | ------------------------------------ | ------------------------------------------ |
| Directly interfaces with ERP/Finance platforms | Encodes rules for approval/rejection | Moves data or tasks across systems         |
| Applies policy logic in financial context      | Focused on general rule enforcement  | Focused on flow, not decision intelligence |
| Resolves finance-specific exceptions           | Evaluates yes/no decisions           | Performs steps, not financial reasoning    |
| Thinks like a controller, acts like an analyst | Thinks like a rules engine           | Thinks like a routing system               |

## Why Now?

Because even the best ERPs weren’t designed for **agent-driven logic, edge-case handling, or adaptive decision-making.**

They were designed for **data entry, transaction processing, and system-of-record visibility**—and they do that well. But the real friction in finance isn’t the form. It’s the **judgment**: the unclear case, the missing receipt, the strange vendor, the third exception.

GLIK lets you deploy AI agents to handle these exceptions intelligently, **at the edge of your ERP system**—not buried behind layers of manual steps, emails, and legacy workflows.

> ERP is your database of record.\
> **GLIK is your layer of intelligent financial judgment.**

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>


# ERP Vendor AI Copilots and Agents

1. **Native ERPs offer narrow copilots—GLIK offers cross-system intelligence.**
   * SAP Joule, Oracle Digital Assistant, or Workday Copilot are great *inside their own ecosystems*.
   * GLIK agents operate **across systems**, stitching together workflows from email, Slack, spreadsheets, PDFs, custom APIs, and legacy forms — not just within ERP confines.
2. **GLIK agents are customizable, composable, and purpose-built.**
   * ERP-native agents are often **hardcoded** and follow rigid release cycles.
   * GLIK templates can be cloned, adapted, and extended to match **your org’s specific policy rules, escalation logic, or legacy integrations**.
3. **GLIK wraps&#x20;*****everything*****, not just modern SaaS.**
   * Many enterprises still use legacy workflows that predate AI.
   * GLIK can agentify old SharePoint flows, email-driven approvals, or even air-gapped paper-based systems — with minimal lift.
4. **You’re not locked into a vendor's roadmap.**
   * GLIK is vendor-agnostic.
   * You can create domain-specific logic (e.g. cross-policy expense agents, strike resolution agents, SAP + Slack copilots) without waiting for your ERP provider to build it.
5. **GLIK is an agent-first platform, not an ERP bolt-on.**
   * ERP copilots enhance *interface interactions*.
   * GLIK agents **own outcomes**: they monitor, decide, act, escalate, explain, and log — across your entire process stack.

> Your ERP copilot improves the UI. **GLIK gives you a policy-aware, goal-driven AI that operates across UIs, systems, and workflows.** It doesn’t just assist. It resolves.


# Custody Approval Workflow for Token Issuance

The **Custody Approval Workflow for Token Issuance** is a GLIK AI template designed to coordinate the internal approval process required before triggering custody operations for asset issuance — whether for tokenized securities, on-chain gold, or other regulated RWAs.

This template supports **multi-departmental sign-off**, integrates with **document repositories and risk checks**, and can optionally trigger a smart contract or REST-based custody API once final clearance is granted.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FiRJXbIcPbYD5MO3Uan9a%2Fimage.png?alt=media&amp;token=fcc8015c-52fc-4ec2-9c93-13bf26e0ad67" alt=""><figcaption><p>This part of the <strong>Custody Approval Workflow</strong> handles multi-agent decision-making, where Custody, Legal, Compliance, and Ops agents independently review the issuance request after input normalization. If all approve, the flow proceeds; otherwise, it routes to an Escalation Reviewer. The final block compiles all decisions and metadata into a structured approval log for downstream issuance or audit.</p></figcaption></figure>

## Use Case Context

Many asset managers, tokenization teams, and legal/compliance departments must complete several steps before releasing control to a qualified custodian. These steps often include:

* Verifying investor accreditation status
* Collecting and validating required legal documents
* Approving asset eligibility under specific regulatory regimes
* Confirming readiness from compliance, finance, and product teams
* Logging internal consent from legal counsel or regulatory affairs

This template orchestrates these steps into a **structured, auditable approval chain** — streamlining internal coordination and reducing issuance risk.

***

## Workflow Features

<table data-view="cards"><thead><tr><th>Component</th><th>Function</th></tr></thead><tbody><tr><td><strong>Input Form</strong></td><td>Initiate issuance request with asset metadata, investor details, and supporting documents</td></tr><tr><td><strong>Document Upload Block</strong></td><td>Capture PDF agreements, KYC docs, jurisdictional forms</td></tr><tr><td><strong>Parallel Review Nodes</strong></td><td>Trigger internal sign-off from multiple departments (e.g., Legal, Risk, Finance)</td></tr><tr><td><strong>Conditional Logic</strong></td><td>Flag high-risk assets or missing documents for escalation</td></tr><tr><td><strong>Save Point Agent</strong></td><td>Capture decision memory for rollback, audit, or internal review</td></tr><tr><td><strong>Custody Trigger Node</strong></td><td>If fully approved, optionally call a custody API or trigger a smart contract function</td></tr></tbody></table>

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FpZPpCP6xHupZLO79fHlu%2Fimage.png?alt=media&amp;token=de19ae48-35d3-4c50-8930-d5ec79890ab0" alt=""><figcaption><p>This part of the <strong>Custody Approval Workflow</strong> handles multi-agent decision-making, where Custody, Legal, Compliance, and Ops agents independently review the issuance request after input normalization. If all approve, the flow proceeds; otherwise, it routes to an Escalation Reviewer. The final block compiles all decisions and metadata into a structured approval log for downstream issuance or audit.</p></figcaption></figure>

## Who This Is For

* Tokenization desks at RWA platforms
* Legal teams overseeing compliant custody practices
* Institutional DeFi players preparing for MiCA or other regional custody regulations
* Custodians accepting programmable workflows from their clients

***

<details>

<summary>🚀 Coming Soon to the GLIK Marketplace</summary>

This template will be available in the **Expense & ERP Agents** category, and installable directly into any GLIK workspace. Users will be able to:

* Customize sign-off routing per department
* Insert proprietary review steps or external validation APIs
* Swap out custody trigger methods depending on provider (e.g. Copper, Fireblocks, Anchorage)

</details>


# Inventory & Logistics Agents

Agentify your inventory and logistics operations to act before stockouts, reroute before delays, and optimize fulfillment across your existing systems—without rewriting them.

Enterprises already use ERPs, WMS, and TMS platforms to manage inventory, procurement, and logistics. But these systems operate on **fixed rules**, **batch logic**, and **manual thresholds**—leaving gaps in responsiveness, adaptability, and exception handling.

GLIK’s **Inventory & Logistics Agents** close those gaps by layering intelligent agents on top of your current systems. These agents monitor stock levels, vendor patterns, fulfillment delays, and seasonal trends. They escalate when thresholds are breached, reroute when shipments are at risk, and proactively trigger resolution flows when manual action is too slow.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FnzoSHgQApGc7Tdai64gV%2Fimage.png?alt=media&amp;token=7b0d11a7-d191-4258-a2c2-660481a12da7" alt=""><figcaption><p>This core loop processes individual logistics signals — such as low inventory, vendor anomalies, or delayed shipments — and routes them through intelligent classification, analysis, and response logic. After retrieving relevant thresholds and policies (Retrieve Threshold Rules), the signal is categorized (Classify Signal Risk Level) as either normal/informational or critical. Stable signals trigger a forecast summary (Summarize Operational Insight) and are conditionally logged (Determine Signal Severity). High-risk signals invoke an escalation agent (Trigger Escalation Agent) that dispatches corrective action. All insights and responses are compiled for export, enabling real-time decision layers across fulfillment, procurement, and operations.</p></figcaption></figure>

## Why Agentify Inventory & Logistics?

Because most enterprise systems can **track**, but only agents can **respond, adapt, and resolve**.

Traditional platforms (SAP, Oracle, NetSuite, Manhattan, etc.) are built for structured transactions—not intelligent exception handling. They:

* Wait for thresholds to be hit
* Depend on batch jobs or static alerts
* Require manual reconfiguration for new rules
* Operate in silos, not across systems

GLIK agents turn your logistics stack into a **real-time decision-making layer**—without replacing what already works.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FezRcWIdkpAYdpPU7Q32F%2Fimage.png?alt=media&amp;token=c4a067c4-1ddd-4bb1-a91c-826f26455960" alt=""><figcaption><p>This loop orchestrates intelligent responses to individual logistics signals such as low stock levels, shipment delays, or vendor anomalies. After enriching the signal with operational metadata (Enrich with Operational Info), the system retrieves policy rules for comparison (Retrieve Threshold Rules). It then classifies each signal as normal or critical (Classify Signal Risk Level). Informational signals are passed to an LLM (Summarize Operational Insight) to generate contextual summaries, while high-risk signals trigger corrective actions via agent dispatch (Trigger Escalation Agent). This enables real-time, rule-aware, and context-sensitive routing of fulfillment decisions — without manual intervention or system replacement.</p></figcaption></figure>

## Enterprise Value

* **Prevent Stockouts Before They Happen**\
  Agents detect demand spikes, lead time shifts, or supply delays and initiate early interventions.
* **Reduce Overstocking and Inventory Waste**\
  Intelligent agents monitor turnover, seasonality, and location to make smarter reordering decisions.
* **Respond to Fulfillment Delays Proactively**\
  Agents reroute, escalate, or notify downstream systems when logistics disruptions are detected.
* **Coordinate Across Siloed Systems Without Middleware**\
  Agents operate across ERP, WMS, procurement, Slack, and email—without costly system integration.
* **Handle the Exception Cases Your ERP Can’t**\
  When things don’t go to plan, GLIK agents fill the gap with contextual logic, escalation, and resolution.

## When to Use This Template Genre

| **Legacy Workflow or Scenario**                     | **Agentified Upgrade with GLIK**                                    |
| --------------------------------------------------- | ------------------------------------------------------------------- |
| Stock threshold hits trigger last-minute orders     | Restocking Agent forecasts and acts on projected stockouts          |
| Delayed shipments discovered too late               | Shipment Monitoring Agent flags risk and routes updates proactively |
| Warehouse imbalance creates fulfillment bottlenecks | Inventory Balancing Agent redistributes based on proximity and need |
| Seasonal demand spikes handled reactively           | Seasonal Inventory Agent triggers proactive planning and alerts     |
| Vendor performance monitored manually               | Vendor Monitoring Agent tracks delays and escalates outliers        |

## How It Differs from Other Agent Genres

| Inventory & Logistics Agents                              | Task Resolution Agents                                 | ERP/Finance Agents                           |
| --------------------------------------------------------- | ------------------------------------------------------ | -------------------------------------------- |
| Focus on **physical goods, timing, and fulfillment**      | Focus on workflow outcomes across roles or departments | Focus on policy-based financial transactions |
| Designed for **reordering, rerouting, balancing**         | Designed for human task resolution and escalation      | Designed for rule-enforced approvals         |
| Acts on **external variables** (location, shipping, time) | Acts on internal workflow state                        | Acts on finance rules and policies           |

## Why Now?

Even the most advanced logistics platforms struggle with **adaptability**, **exception handling**, and **cross-system reasoning**.

GLIK gives enterprises an edge by enabling AI agents to monitor, interpret, and act on logistics signals in real time—without costly infrastructure changes. Whether you're running on SAP, NetSuite, or spreadsheets + Slack, GLIK agents sit on top and drive **operational responsiveness**.

> Your WMS moves boxes.\
> **GLIK agents move decisions.**


# Sales & Forecasting Agents

Use agent intelligence to transform your sales and planning data into proactive actions—before the quarter is lost or the opportunity is missed.

Enterprise forecasting often suffers from two extremes: it’s either **over-engineered** (tied to complex, inflexible BI tools and CRM pipelines) or **underpowered** (stuck in spreadsheets and gut-feel assumptions). Neither is fast, adaptive, or context-aware.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FRMBArDlhcadQdEokwtpL%2Fimage.png?alt=media&amp;token=4be8d130-c368-4d6c-9641-14deff1cedff" alt=""><figcaption><p>This final sequence handles the compilation, transmission, and closure of the Forecast Orchestration Engine's execution flow. Once all forecast segments are analyzed and evaluated, the system assembles a structured JSON output (Compile Output Payload), transmits it to external systems such as CRMs, dashboards, or alert channels (Send Forecast Summary To...), and gracefully completes the session (Complete Forecast Session). This ensures that forecast insights and actions are not only generated but also delivered and operationalized across enterprise systems.</p></figcaption></figure>

GLIK’s **Sales & Forecasting Agents** bridge this gap. These agents sit on top of your existing data—CRM, ERP, inventory, external feeds—and deliver **real-time interpretation, early warnings, and decision triggers** for everything from demand spikes to territory performance gaps.

They don’t just report. They **recommend, escalate, and act.**

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

## What These Agents Do

* Interpret historical sales, seasonality, and regional performance
* Factor in logistics, demand patterns, and economic signals
* Trigger early alerts when targets are slipping or demand is surging
* Recommend adjustments to sales targets, inventory allocations, or campaign timing
* Coordinate action across sales, ops, finance, and fulfillment teams

GLIK agents give your forecasting layer **execution power**—not just visibility.

<figure><img src="https://3916444914-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDBilw3zq3DIWtwBIyxN9%2Fuploads%2FItTWbTSZ3cfeyuSFWWV8%2Fimage.png?alt=media&amp;token=4efebf69-3e16-41e7-b02e-56ce85508c6b" alt=""><figcaption><p>This loop orchestrates per-segment forecasting decisions across SKUs, regions, or timeframes. After enriching each segment with CRM and operational metadata (Enrich with CRM &#x26; Ops Data), the system retrieves relevant historical patterns and market context (Pull Sales History &#x26; Context). It then classifies the forecast signal (Classify Forecast Pattern) into either stable insights (Generate Forecast Insight) or actionable anomalies (Trigger Forecast Action).</p></figcaption></figure>

## Enterprise Value

* **Spot Risks and Opportunities Sooner**\
  Get alerted about underperforming SKUs, sales teams, or regions before it’s too late to respond.
* **Break Down Silos Between Sales, Inventory, and Logistics**\
  Agents unify data interpretation across ERP, CRM, and supply chain inputs—without middleware complexity.
* **Replace Static Forecasting Models with Adaptive Logic**\
  Templates can be tuned per vertical, region, product line, or promotional cycle—instantly.
* **Free Analysts from Manual Correlation and Reporting**\
  Agents automate trend analysis, report generation, and action triggers across stakeholders.
* **Shift from Reactive to Preemptive Sales Strategy**\
  Don’t just look at what happened. Act on what’s about to happen.

<details>

<summary>Copilots vs Agents </summary>

**Copilot:** A **collaborative AI assistant** embedded into enterprise tools that helps users complete tasks by offering real-time guidance, clarification, and policy interpretation.

* Requires user input
* Embedded directly into UI
* Guides users without replacing them

**Agent:** An **autonomous AI worker** that independently executes steps, applies logic, and resolves workflows—often across systems or without user prompting.

* Executes tasks on its own
* Operates in the background or via workflows
* Designed to reduce or replace human labor for routine steps

> **GLIK Rule of Thumb:** Use a **copilot** when the user is completing the task and needs help. Use an **agent** when the system can (and should) complete the task independently.

</details>

## When to Use This Template Genre

| **Legacy Process or Workflow**                           | **Agentified Forecasting Upgrade**                                     |
| -------------------------------------------------------- | ---------------------------------------------------------------------- |
| Sales targets reviewed monthly in Excel                  | Forecast Agent flags early misses and routes to sales leads            |
| Inventory allocation follows static seasonal assumptions | Agent detects real-time demand shifts and recommends adjustments       |
| Sales + marketing + ops teams work in isolation          | Agent synchronizes signals and triggers alerts across departments      |
| BI dashboards surface trends, but no one owns action     | Forecast Agent triggers next steps and alerts responsible owners       |
| New product launch demand is estimated manually          | Agent triangulates historical comps + early signals for rollout pacing |

## How This Differs from Other Genres

| Sales & Forecasting Agents                                | Inventory & Logistics Agents                      | ERP/Expense Agents                               |
| --------------------------------------------------------- | ------------------------------------------------- | ------------------------------------------------ |
| Focus on **predictive intelligence** and forward planning | Focus on **execution and flow of goods**          | Focus on **approvals and financial controls**    |
| Suggest actions, highlight risk, monitor trends           | Trigger restocking, rerouting, and delivery logic | Enforce policies and validate transactional data |
| Operate across CRM, marketing, inventory, and finance     | Operate across supply chain and warehouse systems | Operate within finance, accounting, procurement  |

## Why Agentify Forecasting?

Because you already have the data—but data doesn’t create action.

GLIK agents **see across platforms**, interpret historical trends and current signals, and act in real time to improve outcomes. They don’t just tell you what your problem is. They tell the right person what to do—and when to do it.

> A BI dashboard shows you the trend.\
> **A GLIK agent moves your team toward the fix.**

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>


# Plugin-Based Agent Platforms

Build modular, composable, and installable agents that teams can deploy, configure, and reuse across enterprise environments.

Not every agent needs to be hardcoded into a single workflow. Some agents are **reusable capabilities**—expense validators, compliance reviewers, SOP responders—that can be plugged into multiple flows, teams, or even entire business units.

GLIK’s **Plugin-Based Agent Platform** templates let you create **modular agent logic** that can be installed, configured, and reused as a plugin. These agents behave like **internal apps**: they expose parameters, accept configuration, and respond to tasks across use cases, users, and systems.

Think of them as **agentized building blocks** you can distribute, govern, and compose inside your enterprise.

<details>

<summary>Implementation Support &#x26; Expert Guidance</summary>

Need assistance deploying or customizing this GLIK template for your organization?

Our team offers dedicated coaching and technical walkthrough sessions to ensure successful adoption and alignment with enterprise requirements.

Typical areas of support include:

* Template onboarding and orchestration strategy
* Workflow configuration and logic review
* Memory variable setup and session handling
* Custom integration guidance (e.g. plugins, APIs)
* [Request a Session](mailto:undefined)

</details>

## What These Templates Enable

* Create reusable agent logic that acts like a **plugin**
* Publish agents to a **shared workspace library** or internal marketplace
* Allow teams to configure agents by plugging in policies, thresholds, or datasets
* Support **multi-tenant deployments** of the same agent logic (e.g. different teams, different rules)
* Keep logic centralized, but behavior configurable

***

## Enterprise Value

* **Reduce Development Overhead with Reusable Components**\
  Build a policy validator or audit tracker once—use it everywhere.
* **Enable Internal Teams to Self-Serve and Compose Agents**\
  Let HR, finance, compliance, or field ops install and configure agents from a curated library.
* **Increase Governance While Supporting Flexibility**\
  Teams can control inputs—central admins control the logic.
* **Accelerate New Agent Deployments Across Departments**\
  Clone, adapt, and deploy agents in hours—not weeks.
* **Prepare for External SaaS or Partner Integrations**\
  Build agents that your teams or external clients can consume as modular services.

## When to Use This Template Genre

| **Need or Scenario**                                      | **Plugin-Based Agent Platform Approach**                               |
| --------------------------------------------------------- | ---------------------------------------------------------------------- |
| You’ve built an approval agent for finance                | Make it configurable per department policy and publish it as a plugin  |
| Field teams need their own compliance checkers            | Create an agent template with install-time configuration options       |
| IT wants to offer reusable onboarding logic to HR/Legal   | Build an agent plugin with step logic + external variable binding      |
| Client-facing teams want agent interfaces they can modify | Deploy agents with plug-and-play APIs and override paths               |
| You want devs to scale agent logic across business units  | Wrap agents as plugins that can be slotted into any orchestration flow |

## How This Differs from Other Genres

| Plugin-Based Agent Platforms                            | Policy/Task/ERP Agents                             |
| ------------------------------------------------------- | -------------------------------------------------- |
| Focus on **reusability and composability**              | Focus on **specific, targeted functionality**      |
| Designed for **distribution and configuration**         | Designed for **execution within a fixed workflow** |
| Agent logic is centralized; inputs are configurable     | Logic and inputs often coupled tightly             |
| Ideal for marketplaces, libraries, and internal tooling | Ideal for embedded use cases                       |

## Why Now?

As enterprises adopt more agent-driven workflows, the need for **scalable governance** and **team-level flexibility** becomes critical.

GLIK’s plugin-based agent architecture makes that possible—allowing you to distribute standardized intelligence while letting teams shape how it runs.

> Build once. Configure everywhere. Govern centrally.

With GLIK Plugin-Based Agent Platforms, you don’t just deploy agents.\
You **enable ecosystems.**

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>


# Overview


# Publishing Templates


# Overview

GLIK is a modular orchestration platform designed to support enterprise-grade agent applications, decision workflows, and memory-aware automation. At the core of GLIK is an execution engine that coordinates nodes — known as **blocks** in the visual studio — to process structured input, route decisions, and invoke tools or AI models.

This section introduces the foundational architecture of GLIK, enabling both enterprise leaders and developer teams to understand how agent workflows are composed, executed, and audited across environments.

{% embed url="<https://www.mermaidchart.com/raw/cc33086c-9a7a-4f1a-8bc7-40117cc1e503?theme=light&version=v0.1&format=svg>" %}
GLIK’s modular architecture: all app types (Workflow, Agent, Advanced Chat, Chatbot) inherit from a shared orchestration foundation. Each app is built from logic blocks (LLM, Policy, Variable Assigner), connected to memory via Knowledge Blocks. This structure enables scalable, reusable AI agents across enterprise systems.
{% endembed %}

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>

### What This Architecture Enables

GLIK's system design provides a reliable and extensible foundation for:

* **Operationalizing business logic** via reusable orchestration templates
* **Embedding decision automation** into existing enterprise systems
* **Ensuring traceability and compliance** through memory, logging, and fallback systems
* **Scaling across environments** — whether cloud-hosted or deployed via Open Core

***

### Core Architectural Concepts

#### 1. **Blocks & Nodes**

The system is built on modular execution units:

* **Blocks** are visual elements used to build workflows in the GLIK Cloud Studio.
* **Nodes** are the runtime equivalents that execute in a directed flow graph.\
  Each node processes input, applies logic, and passes structured output downstream.

#### 2. **Execution Model**

The execution engine processes flows deterministically:

* Resolves scoped inputs and memory
* Executes each node in sequence (with conditional branching support)
* Handles fallback or escalation paths based on runtime outcomes

#### 3. **Memory & Variable Scope**

GLIK provides a structured memory model:

* Memory objects can be scoped to `User`, `App`, or `Org`
* Variables persist across nodes and sessions when needed
* Used for context injection, audit logging, and agent continuity

#### 4. **Decision Routing**

Policy automation and logic branching are handled through a combination of:

* Conditional blocks (e.g., IF/ELSE)
* LLM-driven classifiers
* Escalation nodes that reroute uncertain decisions to humans or fallback paths

#### 5. **System Observability**

GLIK supports operational monitoring and traceability through:

* Execution logs and visual traces
* Save points, snapshots, and output inspection
* Optional memory audit trails

<details>

<summary>📣 Try GLIK </summary>

Explore and deploy your first app at [app.glik.ai](https://app.glik.ai)

</details>

### Cloud + Open Core Parity

The orchestration model remains consistent whether running in [GLIK Cloud](/glik-cloud) or deploying via [Open Core](/developers/glik-open-core). Execution patterns, node types, and memory constructs are designed for **deployment-agnostic continuity**, enabling secure adoption in both managed and self-hosted environments.

For Open Core specifics, see: [GLIK Open Core Deployment & CLI Reference](/developers/glik-open-core/deployment-and-installation)

***

### Audience & Use

This section serves both:

* **Enterprise solution teams** evaluating architecture alignment, integration paths, and risk frameworks
* **Technical implementers and developers** designing, customizing, or extending orchestration flows in production environments


# Blocks & Nodes

In GLIK, agent applications are constructed using modular components known as **blocks** and **nodes**. While these terms are often used interchangeably, they serve distinct roles within the system — particularly in the context of deployment, execution, and platform integration.

This overview clarifies the difference between blocks and nodes, and explains how they operate across various app types in GLIK Cloud and GLIK Open Core environments.

***

### What Are Blocks?

**Blocks** are the visual components available in the GLIK Studio interface. Users can drag, configure, and connect blocks to build workflows without writing code.

* Represent high-level actions or logic units (e.g., LLM call, IF/ELSE, Variable Assigner)
* Include UI configuration (e.g., dropdowns, variable bindings, content prompts)
* Support nested logic, parallel flows, and scoped memory control

Blocks are the **front-end abstraction** of the orchestration logic and do not execute directly. Instead, they are compiled into runtime **nodes**.

***

### What Are Nodes?

**Nodes** are the underlying runtime units that execute within GLIK’s orchestration engine. Each node corresponds to a block and is defined as part of a directed flow graph.

* Nodes are generated when a user saves or deploys an app from GLIK Studio
* They operate sequentially or conditionally depending on app logic
* Each node processes input, updates memory, and passes results downstream

Nodes are used in:

* [**Open Core**](/developers/glik-open-core) — where flows are defined and deployed directly without visual UI
* [**GLIK Cloud execution engine**](/glik-cloud) — where blocks are translated into nodes behind the scenes

***

### App Type Integration

Each GLIK app type compiles blocks into nodes using a standardized orchestration model. Here’s how blocks and nodes fit across different app types:

| App Type          | Blocks Used                      | Nodes Executed                | Notes                                                  |
| ----------------- | -------------------------------- | ----------------------------- | ------------------------------------------------------ |
| **Chatbot**       | Limited (LLM, Answer)            | Stateless node chain          | No memory, single-turn                                 |
| **Agent**         | Full block range                 | Autonomous node orchestration | Uses tools, memory, and feedback loops                 |
| **Advanced Chat** | Full block range + memory blocks | Stateful node execution       | Supports conversation memory and escalation            |
| **Workflow**      | Deterministic blocks             | Single-run execution graph    | Designed for API automations and output transformation |

***

### [Developer Notes](/developers/overview)

* Blocks are stored as configuration metadata in GLIK Cloud
* Nodes are compiled representations stored in DSL or YAML in Open Core
* Each node type has a unique schema: input bindings, execution context, return types

To extend or create new logic, developers may define custom nodes or plugins that render new blocks in the Studio.


# Utilities

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# Start Block

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# End Node

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# HTTP Request

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>


# List Operator


# Classifier Nodes


# Question Classifier


# Logic Blocks


# IF/ELSE Branch


# Iteration


# Loop


# Transform Blocks


# Variable Assigner


# Variable Aggregator


# Parameter Extractor


# Data Enrichment


# Prompt Template


# Code


# Input & Extraction


# Doc Extractor


# Knowledge Retrieval


# LLM Block

The **LLM Block** in GLIK Studio is a node that routes data into a large language model (LLM) — such as OpenAI's GPT or Anthropic's Claude — and returns a generated response. It enables natural language understanding, reasoning, and synthesis to be embedded inside a structured enterprise workflow.

It acts as a dynamic reasoning node for:

* Decision explanation
* Ambiguity resolution
* Freeform synthesis (e.g. summaries, justifications, answers)

***

### 🧱 Block vs. Node in GLIK

* A **block** is a configurable building element in GLIK Studio's visual interface.
* A **node** is an instance of that block placed into a specific workflow (graph).

Think of a **block** as a type or template — and a **node** as its usage in a particular context.

***

### 🌐 GLIK Studio vs. GLIK Cloud

* **GLIK Studio** is the visual builder for composing workflows using blocks (like LLM Block).
* **GLIK Cloud** is the managed runtime environment where workflows are executed — it runs and scales your AI-powered applications.

Workflows designed in Studio are published to Cloud.

***

### 💼 Enterprise Use Case Context

The LLM Block allows enterprise builders to embed generative reasoning into business logic. It becomes especially useful in:

#### For Enterprise Developers

* **Fallback logic**: Handle uncertain or missing cases in rules-based flows.
* **Complex prompt chains**: Inject variables and memory into prompts to drive dynamic reasoning.
* **Human-like summarization**: Explain a decision using natural language.

#### For Executive Decision Makers

* **Transparency**: LLMs explain how and why an approval was made.
* **AI as a co-pilot**: Use LLMs to evaluate nuanced decisions based on enterprise context.
* **Policy compliance**: Summarize which thresholds, rules, or values were triggered.

***

### 🛠 Common Configurations

| Property       | Description                                           |
| -------------- | ----------------------------------------------------- |
| Prompt Input   | The system message or instruction for the LLM         |
| Variables Used | Pulls from upstream nodes or session variables        |
| Model Target   | Can be set to a default (e.g., GPT-4, Claude)         |
| Output Binding | Stores output in a variable like `conversation_notes` |

***

### 📘 Example Usage

> In the **Expense Policy Decision Engine**, the LLM Block is triggered when invoice data is incomplete or ambiguous. It generates an explanation and decision recommendation such as:\
> *"Based on the vendor history and lack of an uploaded policy document, this expense should be escalated for manual review."*

***

### 🧠 Best Practices

* Always use **fallback conditions** to avoid over-relying on the LLM
* Keep prompts **deterministic and structured** if used in workflows that affect finance, security, or compliance
* Include **memory injection** if context across steps is important

<details>

<summary>In Progress</summary>

This page is currently under active development. Content may be incomplete, evolving, or placeholder-only. Please check back later for finalized documentation and fully structured examples.

</details>

### 🚀 Looking Ahead

Future versions of GLIK will support:

* Fine-tuned models per organization
* Prompt versioning and audit logs
* Role-based prompt injection for use-case control




---

[Next Page](/llms-full.txt/1)