# Execution Model

GLIK’s execution model defines how logic is processed, workflows are executed, and intelligent behavior emerges across apps. Whether deployed as a stateless chatbot, a memory-aware agent, or a branching orchestration workflow, every GLIK application follows a structured execution lifecycle powered by modular blocks, scoped memory, and policy-aware flow control.

This section of the documentation explains how the system interprets user input, propagates values, triggers node-based logic, and maintains continuity across tasks.

Understanding the execution model is essential for:

* Designing scalable workflows and agents
* Debugging and optimizing orchestration behavior
* Mapping AI logic to legacy system constraints
* Managing memory, conditional logic, and escalation patterns

{% embed url="<https://www.mermaidchart.com/raw/0fd4d66b-580f-433b-bbe1-2aebc8dfaf3a?theme=light&version=v0.1&format=svg>" %}
Execution Model Overview — This diagram illustrates how a GLIK application processes input through modular blocks. Based on App Type selection, logic flows through a block engine that triggers variables, conditions, tools, reasoning agents, and memory checkpoints before producing structured output.
{% endembed %}

## What Is Executed in GLIK?

At the heart of every GLIK app is a **flow of logic blocks**. These are modular execution units (like Variable Assigners, Tool Nodes, Conditional Branches, or LLM Blocks) that respond to input, invoke actions, and emit results. The engine connects these blocks based on app configuration, memory state, and user interactions — forming a dynamic, traceable logic circuit.

Depending on the App Type selected (e.g., Chatbot, Agent, Advanced Chat, Workflow), this logic may be wrapped in conversation, triggered by system events, or embedded in no-code frontends.

***

## Pages in This Section

Each subpage below dives into a critical part of the GLIK execution system:

**1.** [**Workflow Architecture**](/system-architecture/execution-model/workflow-architecture.md)

Explains how execution is structured within apps — including step sequencing, branching logic, memory routing, and orchestration composition. This is the best starting point for understanding how GLIK runs logic.

**2.** [**Flow Engine**](/system-architecture/execution-model/flow-engine.md)

Describes the runtime engine that powers GLIK execution. Covers async/sync behavior, step scheduling, runtime limits, and how logic is advanced during an app run.

**3.** [**Node Lifecycle**](/system-architecture/execution-model/node-lifecycle.md)

Outlines how each block or node behaves during execution — from initialization to termination. This includes lifecycle states, retry behavior, error propagation, and system-managed state transitions.

**4.** [**Input Binding & Value Resolution**](/system-architecture/execution-model/input-binding-and-value-resolution.md)

Covers how inputs are passed between blocks, how variable scopes are respected, and how external inputs (like API results or user form entries) are resolved into usable values within the execution flow.

***

## Why This Matters

GLIK apps are more than just prompt wrappers — they are **composable reasoning systems** that can orchestrate decisions, enforce policy, escalate exceptions, and interoperate with legacy systems. The Execution Model is what makes this possible.

Whether you're building a policy automation agent, a knowledge retriever, or a cross-system orchestration layer, this section explains how **your logic becomes live** — and how every block, variable, and output fits into a runtime lifecycle.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.glik.ai/system-architecture/execution-model.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
