# Changelog
Source: https://docs.leapter.com/changelog
The latest and upcoming features in Leapter, plus an overview of everything you can do โ with links into the docs.
Latest changes first. Looking for a specific capability instead? Jump to **[All features](#all-features)** for a complete, linked index.
Dates reflect when each change reached the product. Some larger initiatives roll out gradually
behind feature flags, so an item may appear here shortly before it becomes visible in your workspace.
Blueprints move to a LogicFlow-JSON storage format for quicker loads and saves.
***
Every version of a project becomes a change you can inspect, compare, and restore โ with a stream-aware graph that shows drafts forking from and merging back into main, and **View conversation** to reopen the Lab Agent chat behind any change. See [Timeline](/fundamentals/track-changes/timeline).
Pick a [change workflow](/fundamentals/track-changes/change-workflow) per project: apply edits directly, or hold them on a draft and gate delivery to main with reviewers and [approval rules](/fundamentals/track-changes/review-and-approvals) โ four-eyes approval, passing tests, resolved comments, and more.
Express first-match business rules as a grid of inputs and outcomes instead of a long chain of decisions โ clearer to read and easier to review. The Lab Agent now builds one whenever a rule is really a lookup. See [Decision Tables](/fundamentals/leapter-canvas/decision-tables).
Connect external tools like **Linear** and **GitHub** so the Lab Agent can use them on your behalf โ enabled per workspace by an owner, connected individually by each member. See [Integrations](/fundamentals/integrations).
***
![The Lab Agent chat panel open beside the No-Claims Bonus Engine Specification View, answering a question with type-annotated reference pills]()
Now the single home for AI-assisted work โ **@-mention pills** and **auto-generated tests** run through the agent.
Foundations for self-hosted, enterprise deployments.
Everything now lives in a **workspace** you share with your team โ the old split between a personal account and separate teams is gone. Switch workspaces from the sidebar, and invite members with owner or member roles. See [Workspaces](/fundamentals/workspaces).
Pressing **Ctrl+I** (Cmd+I on Mac) with a node selected drops it into the Lab Agent chat as a reference, instead of opening a separate edit bar. See [Edit with Ctrl+I](/fundamentals/change-your-blueprint/ai-editing).
***
An agent that runs your Blueprints and tests, reads and writes your types, and creates and renames Blueprints โ with approval and speed/quality modes.
Value and data types as a first-class, business-readable layer.
Share a project via link; viewers can copy it, and anonymous `/try` works without an account.
***
![The Leapter Specification View showing the Contents sidebar, a dependencies diagram, and the Inputs and Outputs of the No-Claims Bonus Engine project]()
Spec, models, and types merged into one structured document, with **live and test execution in the browser** โ no round trip.
Build reusable test cases and run them from the editor or CLI, plus a VS Code extension with Veritas highlighting.
***
**Natural-language operators** โ `and`/`or`, `is`/`isnt`, `not`, and `absent` โ plus execution traces distributed across the diagram.
In-process execution from the CLI, plus an MCP tool that renders a Blueprint viewer.
## All features
Everything you can do in Leapter, with a link to where each capability is documented.
### Create
Describe your logic and let Leapter build the Blueprint.
Start from a ready-made example and adapt it.
Build every node yourself on an empty canvas.
### Build & edit
Build and edit by chatting with AI โ it runs your tests, too.
Click any node, title, or description to edit it in place.
Press Ctrl+I to point the Lab Agent at the node you selected.
Keep your plain-language descriptions and your logic aligned.
### The editor
Your whole project as one structured, editable document.
Focus on a single Blueprint's flowchart.
Define each Blueprint's signature.
Reusable Value Types and Data Types.
Decisions, loops, returns, and errors.
First-match rules as a grid of inputs and outcomes.
Compose logic from reusable sub-Blueprints.
### Test
Run with sample inputs and step through the execution.
Reusable test cases โ auto-generate them with the Lab Agent.
### Track changes
Every version of your project โ inspect, compare, and restore.
Save edits directly, or hold them on a draft until you're ready.
Gate changes with reviewers and rules like four-eyes approval.
### Deploy & integrate
Call your Blueprint over HTTP from any application.
Connect AI assistants via the Model Context Protocol.
Export ready-made n8n workflows.
View your logic as JavaScript or Python.
Embed a read-only Blueprint viewer in any page.
Authenticate your integrations.
### Collaborate & share
Organize related Blueprints into projects.
Invite members and share projects in a workspace.
Discuss specific nodes and sections with your team.
Generate a public, read-only link to a project.
Connect external tools for the Lab Agent to use.
Manage your personal settings.
# AI Protocol (MCP)
Source: https://docs.leapter.com/executing-blueprints/connect-mcp
Connect AI assistants and agents to your Blueprints using the Model Context Protocol.
The Model Context Protocol (MCP) is a standardized protocol that lets AI assistants and agents use external tools. Leapter exposes your published Blueprints as MCP tools, so any MCP-compatible AI client can call your logic directly.
## Get the endpoint URL
1. Open your Blueprint in the editor.
2. Click the **Share** button in the toolbar.
3. Select **Connect**.
4. In the Connect dialog, select the **AI Protocol (MCP)** tab.
![The Connect dialog showing the AI Protocol (MCP) tab with endpoint URLs]()
The dialog shows two endpoint URLs:
### Standard Endpoint
```
https://lab.leapter.com/runtime/api/v1/{appspace}/{project-id}/mcp
```
Use this for most MCP clients. It uses the standard MCP transport protocol.
### Real-Time Streaming Endpoint (SSE)
```
https://lab.leapter.com/runtime/api/v1/{appspace}/{project-id}/mcp/sse
```
Use this for clients that require Server-Sent Events (SSE) streaming, such as some older MCP integrations.
Click the **Copy** button next to either URL to copy it to your clipboard.
## Authentication
All MCP connections require an API key. Pass it as a header:
* **Header name:** `X-API-Key`
* **Header value:** your API key
See [API Keys](/fundamentals/api-keys) to create and manage your keys.
## Connect with Claude Desktop
1. Copy the **Standard Endpoint** URL from the Connect dialog.
2. Open Claude Desktop and go to **Settings** โ **Developer** โ **Edit Config**.
3. Add an MCP server entry in your `claude_desktop_config.json`:
```json theme={null}
{
"mcpServers": {
"leapter": {
"url": "https://lab.leapter.com/runtime/api/v1/{appspace}/{project-id}/mcp",
"headers": {
"X-API-Key": "your-api-key"
}
}
}
}
```
4. Replace `{appspace}`, `{project-id}`, and `your-api-key` with your actual values.
5. Restart Claude Desktop.
Your Blueprints now appear as available tools in Claude Desktop.
## Connect with Cursor
1. Copy the **Standard Endpoint** URL from the Connect dialog.
2. In Cursor, open **Settings** โ **MCP**.
3. Add a new MCP server with:
* **URL:** your Standard Endpoint
* **Headers:** `X-API-Key: your-api-key`
4. Save and your Blueprints become available as tools in Cursor's AI features.
## Connect with other MCP clients
Any MCP-compatible client can connect to your Blueprints. You need:
* The **Standard Endpoint** or **SSE Streaming Endpoint** URL (depending on what the client supports)
* An **API key** passed as the `X-API-Key` header
Refer to your client's documentation for how to configure MCP server connections.
## What to do next
* **[Web API (OpenAPI)](/executing-blueprints/connect-rest-api)** โ call your Blueprints through a REST API instead
* **[API Keys](/fundamentals/api-keys)** โ create and manage API keys
* **[MCP Agent Workflow](/executing-blueprints/n8n-mcp-agent)** โ use your Blueprints as tools in an n8n AI agent
# Web API (OpenAPI)
Source: https://docs.leapter.com/executing-blueprints/connect-rest-api
Call your Blueprints through the OpenAPI-compatible REST API from any application.
Leapter generates an OpenAPI specification for your project, giving you a standard REST API to call any published Blueprint from any application.
## Get the OpenAPI spec URL
1. Open any Blueprint in the editor.
2. Click the **Share** button in the toolbar.
3. Select **Connect**.
4. In the Connect dialog, select the **Web API (OpenAPI)** tab.
![The Connect dialog showing the Web API (OpenAPI) tab with the spec URL and curl example]()
The dialog shows your OpenAPI specification URL:
```
https://lab.leapter.com/runtime/api/v1/{appspace}/{project-id}/openapi
```
Click the **Copy** button to copy it to your clipboard.
The OpenAPI spec covers **all published Blueprints** in the project, not just the one you currently have open.
## Authentication
All API calls require an API key passed as a header:
* **Header name:** `X-API-Key`
* **Header value:** your API key
See [API Keys](/fundamentals/api-keys) to create and manage your keys.
## Example: call a Blueprint with curl
The Connect dialog provides a ready-made curl command for the Blueprint you have open โ it has the appspace, project ID, Blueprint ID, and a sample API key already filled in. The general pattern is:
```bash theme={null}
curl -X POST "https://lab.leapter.com/runtime/api/v1/{appspace}/{project-id}/models/{blueprint-id}/runs" \
-H "Content-Type: application/json" \
-H "X-API-Key: your-api-key" \
-d '{"input1": "value1", "input2": "value2"}'
```
Replace the placeholders with your actual values and the request body with your Blueprint's input parameters.
## Use with Postman
1. Copy the **OpenAPI spec URL** from the Connect dialog.
2. In Postman, click **Import** and paste the URL.
3. Postman generates a collection with all your Blueprint endpoints.
4. Set the `X-API-Key` header in the collection's authorization settings.
5. Fill in the request body with your input values and send a request.
## Use with Swagger UI
You can also paste the OpenAPI spec URL into [Swagger Editor](https://editor.swagger.io/) or any OpenAPI-compatible tool to explore and test your endpoints interactively.
## What to do next
* **[AI Protocol (MCP)](/executing-blueprints/connect-mcp)** โ connect AI assistants to your Blueprints via MCP
* **[API Keys](/fundamentals/api-keys)** โ create and manage API keys
* **[HTTP Workflow](/executing-blueprints/n8n-http)** โ export an n8n workflow that calls your Blueprint via HTTP
# Embed in Websites
Source: https://docs.leapter.com/executing-blueprints/embed
Embed an interactive, read-only Blueprint viewer in any website using a web component.
You can embed an interactive view of your Blueprint in any website. The embed uses a web component that renders your Blueprint as a read-only, pannable, zoomable diagram โ no authentication required.
## Get the embed code
1. Open your Blueprint in the editor.
2. Click the **Share** button in the toolbar.
3. Select **Embed**.
4. Click **Copy Code**.
![The Embed Blueprint dialog showing the HTML embed code]()
## The embed code
The generated code looks like this:
```html theme={null}
```
Paste this into your website's HTML where you want the Blueprint to appear.
## How it works
The embed code includes your Blueprint data directly as a base64-encoded value in the `logic` attribute. This means:
* **No authentication required** โ viewers do not need a Leapter account
* **No API calls** โ the Blueprint data is self-contained in the HTML
* **Read-only** โ viewers can explore the Blueprint but cannot edit it
* **Interactive** โ viewers can pan and zoom to navigate the diagram
## Customization attributes
The `` element accepts a small set of boolean attributes โ include the attribute name to turn an option on, omit it to leave it off:
| Attribute | Description |
| :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `show-descriptions` | Show node descriptions in the diagram |
| `show-expressions` | Show expressions on nodes |
| `frame` | Render a border frame around the viewer |
| `autoplay` | Start trace replay automatically when the viewer loads. The viewer adds a play / pause button and a speed control to its toolbar so visitors can control the animation. Autoplay pauses on its own as soon as the visitor takes manual control (clicking a step, using prev / next, stepping in or out) and at the end of the trace. See [Stepping through a trace](/fundamentals/test-your-blueprint#stepping-through-a-trace). |
## Updating the embed
Since the Blueprint data is embedded directly in the HTML, the embed shows the Blueprint as it was when you copied the code. If you update your Blueprint, you need to re-copy the embed code and replace it on your website.
## What to do next
* **[Export as Code](/executing-blueprints/export-code)** โ view your Blueprint as JavaScript or Python code
* **[Web API (OpenAPI)](/executing-blueprints/connect-rest-api)** โ let users interact with your Blueprint through a REST API
* **[Deploy & Integrate](/executing-blueprints/introduction)** โ explore all deployment options
# Export as Code
Source: https://docs.leapter.com/executing-blueprints/export-code
View and copy your Blueprint logic as JavaScript or Python code.
Leapter can transpile your Blueprint into JavaScript or Python code. This gives you a readable, standalone version of your logic that you can copy and use outside of Leapter.
## View the code
1. Open your Blueprint in the editor.
2. Click the **Share** button in the toolbar.
3. Select **Code**.
![The Code View dialog showing transpiled JavaScript with syntax highlighting]()
The Code View dialog opens with two tabs:
* **JavaScript** โ your Blueprint transpiled to JavaScript
* **Python** โ your Blueprint transpiled to Python
Both tabs display the code with syntax highlighting and line numbers. Click the **Copy** button to copy the code to your clipboard.
## What the code includes
The transpiled code is a self-contained representation of your Blueprint logic:
* **Function signatures** with typed parameters matching your Blueprint's data contract
* **JSDoc comments** (JavaScript) or **docstrings** (Python) describing inputs and outputs
* **Conditional logic, calculations, and data transformations** โ the full execution flow of your Blueprint
The code is generated from the current state of your Blueprint in the editor.
The Code View is read-only. To edit your Blueprint, use the [Blueprint Editor](/fundamentals/leapter-canvas/introduction).
## Use cases
* **Code review** โ inspect the generated logic to verify correctness
* **Porting to other systems** โ use the code as a starting point for implementing the logic in your own codebase
* **Documentation** โ include the code in technical documentation to explain what a Blueprint does
* **Version comparison** โ copy the code at different points in time to compare changes
## What to do next
* **[Code Workflow](/executing-blueprints/n8n-code)** โ export the code as part of an n8n workflow
* **[Web API (OpenAPI)](/executing-blueprints/connect-rest-api)** โ call your Blueprint via REST instead of running the code yourself
* **[Embed in Websites](/executing-blueprints/embed)** โ embed an interactive Blueprint viewer in a webpage
# Overview
Source: https://docs.leapter.com/executing-blueprints/introduction
Run your Blueprints in production โ connect via API, export to n8n, generate code, or embed in websites.
Once you have built and tested your Blueprint, you can deploy it and integrate it into your applications, workflows, and websites. Leapter handles the execution infrastructure โ you choose how to connect.
## The Share menu
All deployment options start from the **Share** button in the Blueprint Editor toolbar. Click it to see the available options:
![The Share menu with deployment options and a Link option for public sharing]()
| Option | What it does |
| :---------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Connect** | Get API endpoints for MCP or REST API integration |
| **n8n** | Export ready-made n8n workflows (HTTP, Code, or MCP Agent) |
| **Code** | View your Blueprint as JavaScript or Python code |
| **Embed** | Get an HTML snippet to embed an interactive Blueprint viewer |
| **PNG** | Download a static image of your Blueprint |
| **Export Source** | Download the project's source files for use with the Leapter CLI or version control |
| **Link** | Generate a [public read-only link](/fundamentals/sharing) so anyone can read the project's Specification view โ no Leapter account required (rolling out behind a feature flag; may not be available in your environment yet) |
## Deployment options
### Connect via API
Leapter exposes your published Blueprints through two protocols:
* **[AI Protocol (MCP)](/executing-blueprints/connect-mcp)** โ connect AI assistants and agents using the Model Context Protocol. Ideal for Claude Desktop, Cursor, and other MCP-compatible tools.
* **[Web API (OpenAPI)](/executing-blueprints/connect-rest-api)** โ call your Blueprints through a standard REST API from any application. Includes a full OpenAPI specification.
Both require an [API key](/fundamentals/api-keys) for authentication.
### Export to n8n
Leapter can generate complete n8n workflows that you import directly into n8n:
* **[HTTP Workflow](/executing-blueprints/n8n-http)** โ calls your deployed Blueprint via HTTP API
* **[Code Workflow](/executing-blueprints/n8n-code)** โ runs your Blueprint logic directly as JavaScript inside n8n, with no external API calls
* **[MCP Agent Workflow](/executing-blueprints/n8n-mcp-agent)** โ creates an AI agent that uses your Blueprints as tools
### View as code
**[Export as Code](/executing-blueprints/export-code)** shows your Blueprint logic transpiled to JavaScript or Python. Use it for code review, porting logic to other systems, or documentation.
### Embed in websites
**[Embed in Websites](/executing-blueprints/embed)** gives you an HTML snippet with a web component that renders an interactive, read-only view of your Blueprint. No authentication required โ the Blueprint data is embedded directly in the code.
## Monitor production runs
After you deploy a Blueprint, you can monitor its executions in the **Prod Runs** panel inside the Blueprint Editor.
![The Prod Runs panel with Time and Status filters and a correlation-ID search, shown before any production runs have been recorded]()
To open it, click **Prod Runs** in the right sidebar of the editor.
Each run in the list shows:
* **Status** โ whether the run succeeded or failed
* **Timestamp** โ when the run occurred
* **Duration** โ how long the execution took (e.g., 303ms)
* **Runtime** โ which runtime executed the Blueprint (e.g., Script:Node.js)
### Inspecting a run
Click on any run to expand it and see:
* **Input** โ the exact data that was sent to the Blueprint
* **Output** โ the result the Blueprint returned
* **Trace data** โ the step-by-step execution path through your Blueprint
### Replaying a run
Each expanded run has a **Replay** button. Clicking it re-executes the Blueprint with the same inputs as the original run. This is useful for debugging issues or verifying that a fix works correctly after you update your Blueprint.
### Filtering runs
Use the filters at the top of the panel to narrow down the results:
* **Time** โ filter by time range (e.g., Last 7 Days, Last 24 Hours)
* **Status** โ show all runs or filter by success/failure
* **Search** โ find a specific run by its correlation ID
## What to do next
* **[API Keys](/fundamentals/api-keys)** โ create API keys to authenticate your integrations
* **[AI Protocol (MCP)](/executing-blueprints/connect-mcp)** โ connect AI assistants to your Blueprints
* **[Web API (OpenAPI)](/executing-blueprints/connect-rest-api)** โ integrate with any application via REST
# Code Workflow
Source: https://docs.leapter.com/executing-blueprints/n8n-code
Export an n8n workflow that runs your Blueprint logic directly as JavaScript โ no API calls needed.
Leapter can generate an n8n workflow that runs your Blueprint logic entirely within n8n. Instead of calling an external API, the workflow contains your Blueprint transpiled to JavaScript in a Code node. This means no network latency, no API key required at runtime, and no dependency on external services.
## What this creates
The Code Workflow is a 3-node n8n workflow:
| Node | Purpose |
| :--------------- | :------------------------------------------------------------------------------------- |
| **Form Trigger** | Displays a form with input fields matching your Blueprint's data contract |
| **Code** | Contains your full Blueprint logic transpiled to JavaScript โ executes directly in n8n |
| **Form** | Displays the results |
## Export the workflow
1. Open your Blueprint in the editor.
2. Click the **Share** button in the toolbar.
3. Select **n8n**.
4. In the Export to n8n dialog, select the **Code Workflow** tab.
5. Click **Copy to Clipboard**.
![The Export to n8n dialog showing the Code Workflow tab]()
## Import into n8n
1. Open your n8n instance.
2. Create a new workflow.
3. Click the **three-dot menu** (or use **Ctrl+V** / **Cmd+V**) and select **Import from clipboard**.
4. The 3-node workflow appears on the canvas.
## How the Code node works
The Code node contains your Blueprint logic transpiled to JavaScript. You can open it to inspect the code, but you do not need to modify it. The code:
* Reads inputs from the Form Trigger node
* Executes your Blueprint's logic (conditions, calculations, data transformations)
* Returns the outputs for the final Form node to display
Since the code is a snapshot of your Blueprint at export time, you need to re-export the workflow if you update your Blueprint.
## Run the workflow
1. Click **Test Workflow** to run it manually.
2. Fill in the form with your test inputs.
3. The Code node executes your logic and the Form node displays the results.
No API key or network connection to Leapter is needed at runtime.
## When to use Code vs HTTP
| | Code Workflow | HTTP Workflow |
| :----------------- | :------------------------------------------------- | :---------------------------------------- |
| **API dependency** | None โ runs locally | Requires Leapter API |
| **Authentication** | Not needed at runtime | API key required |
| **Updates** | Re-export after Blueprint changes | Always calls latest published version |
| **Best for** | Offline use, low latency, self-contained workflows | Always-current logic, no re-export needed |
## What to do next
* **[HTTP Workflow](/executing-blueprints/n8n-http)** โ export a workflow that calls the API instead
* **[MCP Agent Workflow](/executing-blueprints/n8n-mcp-agent)** โ use your Blueprints as AI agent tools in n8n
* **[Export as Code](/executing-blueprints/export-code)** โ view and copy the transpiled code outside of n8n
# HTTP Workflow
Source: https://docs.leapter.com/executing-blueprints/n8n-http
Export a ready-made n8n workflow that calls your Blueprint via HTTP API.
Leapter can generate a complete n8n workflow that calls your deployed Blueprint through its HTTP API. The exported workflow includes form inputs, data transformation, the API call, and result display โ ready to import and run.
## What this creates
The HTTP Workflow is a 4-node n8n workflow:
| Node | Purpose |
| :----------------- | :------------------------------------------------------------------------ |
| **Form Trigger** | Displays a form with input fields matching your Blueprint's data contract |
| **Transform Data** | Transforms the form data into the format expected by the API |
| **HTTP Request** | Calls your deployed Blueprint via its REST API endpoint |
| **Form** | Displays the results returned by the Blueprint |
## Export the workflow
1. Open your Blueprint in the editor.
2. Click the **Share** button in the toolbar.
3. Select **n8n**.
4. In the Export to n8n dialog, select the **HTTP Workflow** tab.
5. Click **Copy to Clipboard**.
![The Export to n8n dialog showing the HTTP Workflow tab with the workflow JSON]()
## Import into n8n
1. Open your n8n instance.
2. Create a new workflow.
3. Click the **three-dot menu** (or use **Ctrl+V** / **Cmd+V**) and select **Import from clipboard**.
4. The 4-node workflow appears on the canvas.
## Configure the API key
The HTTP Request node needs your API key to authenticate with Leapter:
1. Open the **HTTP Request** node.
2. In the **Authentication** section, add a **Header Auth** credential.
3. Set the header name to `X-API-Key` and the value to your API key.
4. Save the credential.
See [API Keys](/fundamentals/api-keys) to create a key if you have not already.
## Run the workflow
1. Click **Test Workflow** to run it manually.
2. Fill in the form with your test inputs.
3. The workflow calls your Blueprint and displays the results in the final Form node.
Once you are satisfied with the results, activate the workflow to make it available via its trigger URL.
## What to do next
* **[Code Workflow](/executing-blueprints/n8n-code)** โ run your Blueprint logic directly in n8n without API calls
* **[MCP Agent Workflow](/executing-blueprints/n8n-mcp-agent)** โ use your Blueprints as tools in an n8n AI agent
* **[Web API (OpenAPI)](/executing-blueprints/connect-rest-api)** โ learn more about the REST API the workflow calls
# MCP Agent Workflow
Source: https://docs.leapter.com/executing-blueprints/n8n-mcp-agent
Export an n8n AI Agent workflow that uses your Blueprints as tools via MCP.
Leapter can generate an n8n workflow that creates an AI agent with access to all your project's Blueprints as tools. The agent uses the Model Context Protocol (MCP) to call your Blueprints, so users can interact with your logic through a chat interface.
## What this creates
The MCP Agent Workflow is a 4-node n8n workflow:
| Node | Purpose |
| :---------------- | :----------------------------------------------------------------------------------- |
| **Chat Trigger** | Provides a chat interface for users to interact with the agent |
| **AI Agent** | The AI agent that reasons about user messages and calls tools |
| **MCP Client** | Connects to your Leapter project via MCP, exposing all published Blueprints as tools |
| **Simple Memory** | Maintains conversation context across messages |
## Export the workflow
1. Open any Blueprint in the editor.
2. Click the **Share** button in the toolbar.
3. Select **n8n**.
4. In the Export to n8n dialog, select the **MCP Agent Workflow** tab.
5. Click **Copy to Clipboard**.
![The Export to n8n dialog showing the MCP Agent Workflow tab]()
## Import into n8n
1. Open your n8n instance.
2. Create a new workflow.
3. Click the **three-dot menu** (or use **Ctrl+V** / **Cmd+V**) and select **Import from clipboard**.
4. The 4-node workflow appears on the canvas.
## Post-import setup
After importing, you need to configure two things before the workflow can run.
### Connect an AI model
1. Open the **AI Agent** node.
2. Connect an AI model (OpenAI, Anthropic, Google, or any supported provider).
3. Configure the model credentials if you have not already set them up in n8n.
### Configure the MCP Client
1. Open the **MCP Client** node.
2. Create a **Header Auth** credential:
* **Header name:** `X-API-Key`
* **Header value:** your Leapter API key
3. Save the credential.
See [API Keys](/fundamentals/api-keys) to create a key if you have not already.
## Run the workflow
1. Click **Test Workflow** (or **Chat** in the bottom panel) to open the chat interface.
2. Type a message that relates to your Blueprint's logic.
3. The AI agent decides which Blueprint(s) to call, executes them via MCP, and returns a natural language response.
All published Blueprints in your project are available as tools โ the agent automatically discovers them through the MCP connection.
## What to do next
* **[HTTP Workflow](/executing-blueprints/n8n-http)** โ export a workflow that calls a specific Blueprint via HTTP
* **[Code Workflow](/executing-blueprints/n8n-code)** โ run Blueprint logic directly in n8n
* **[AI Protocol (MCP)](/executing-blueprints/connect-mcp)** โ connect other MCP clients to your Blueprints
# API Keys
Source: https://docs.leapter.com/fundamentals/api-keys
Create and manage API keys to authenticate your integrations with Leapter.
API keys authenticate external applications that call your Blueprints. You need an API key for any integration that connects to Leapter at runtime โ including the [REST API](/executing-blueprints/connect-rest-api), [MCP connections](/executing-blueprints/connect-mcp), and [n8n HTTP workflows](/executing-blueprints/n8n-http).
## Where to find API Keys
Click **API Keys** in the left sidebar of Leapter. This opens the API Keys management page.
![The API Keys page showing a table of keys with name, permissions, status, and usage information]()
The table shows all your API keys with:
| Column | Description |
| :-------------- | :----------------------------------------------------------- |
| **Name** | The friendly name you gave the key |
| **Permissions** | The projects the key can access |
| **Key** | The key prefix (the full key is only shown once at creation) |
| **Status** | Whether the key is Active or Revoked |
| **Last Used** | When the key was last used to make an API call |
| **Created** | When the key was created |
## Create an API key
1. Click **Create API Key** in the top right.
2. Enter a **Key Name** โ a friendly name to help you identify this key later (e.g., "n8n Integration" or "Production API").
3. Select one or more **Projects** the key should have access to. A single key can grant access to several projects โ useful when one integration calls Blueprints from multiple projects.
4. Click **Create Key**.
![The Create API Key dialog with fields for key name and project selection]()
After creation, the full API key is displayed. **Copy it immediately** โ you will not be able to see the full key again. All keys start with the `lpt_` prefix.
## Edit which projects a key can access
You can change a key's project scope without revoking it. This is useful when you add a new project that an existing integration should also be able to call.
1. Find the key in the table.
2. Click the **three-dot menu** on the right.
3. Select **Edit projects**.
4. Adjust the project selection and confirm.
The key keeps the same value โ anything authenticating with it continues to work, with access to the new set of projects.
Store your API key securely. If you lose it, you will need to create a new one. Never share API keys in public repositories or client-side code.
## Use your API key
Pass the API key as a header in all requests to Leapter:
* **Header name:** `X-API-Key`
* **Header value:** your API key
For example, in a curl request that runs a Blueprint:
```bash theme={null}
curl -X POST "https://lab.leapter.com/runtime/api/v1/{appspace}/{project-id}/models/{blueprint-id}/runs" \
-H "Content-Type: application/json" \
-H "X-API-Key: lpt_your-api-key-here" \
-d '{"input1": "value1"}'
```
Each integration page explains where to configure the API key for that specific tool:
* **[MCP connections](/executing-blueprints/connect-mcp)** โ set as a header in your MCP client configuration
* **[REST API](/executing-blueprints/connect-rest-api)** โ pass as the `X-API-Key` header in HTTP requests
* **[n8n HTTP Workflow](/executing-blueprints/n8n-http)** โ configure in the HTTP Request node's authentication settings
* **[n8n MCP Agent Workflow](/executing-blueprints/n8n-mcp-agent)** โ set up as a Header Auth credential in the MCP Client node
## Revoke a key
If a key is compromised or no longer needed, you can revoke it:
1. Find the key in the table.
2. Click the **three-dot menu** on the right.
3. Select **Revoke**.
Revoked keys stop working immediately. You can toggle **Show revoked keys** to see previously revoked keys.
## What to do next
* **[AI Protocol (MCP)](/executing-blueprints/connect-mcp)** โ connect AI assistants to your Blueprints
* **[Web API (OpenAPI)](/executing-blueprints/connect-rest-api)** โ call your Blueprints through a REST API
* **[Deploy & Integrate](/executing-blueprints/introduction)** โ explore all deployment options
# Edit with Ctrl+I
Source: https://docs.leapter.com/fundamentals/change-your-blueprint/ai-editing
Press Ctrl+I (Cmd+I on Mac) to point the Lab Agent at the node you have selected โ the fastest way to ask for a change to a specific part of your Blueprint.
**Ctrl+I** (or **Cmd+I** on Mac) is a shortcut for pointing the **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** at a specific part of your Blueprint. Select a node and press it, and that node is dropped into the Lab Agent chat as a reference โ so you can ask for a change to exactly that element without describing which one you mean.
## How to use it
1. Click a node, section, or element on the canvas to focus it.
2. Press **Ctrl+I** (**Cmd+I** on Mac).
3. The focused node appears in the Lab Agent's chat as a reference pill.
4. Type your instruction โ for example *"round this to two decimals"* or *"add an else branch that declines"* โ and send it.
The agent makes the change with the referenced node as context, and you review and apply it like any other [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) edit.
Ctrl+I no longer opens a separate floating edit bar. It now feeds the **Lab Agent**, so a scoped tweak and a longer, multi-step request happen in the same place โ the agent chat โ and both show up in your conversation history.
## When to use Ctrl+I
| You want toโฆ | Reach forโฆ |
| :-------------------------------------------------- | :-------------------------------------------------------------------------- |
| Change the specific node you're looking at | **Ctrl+I**, then type your instruction |
| Build across several Blueprints, run tests, iterate | The **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** directly |
| Type an exact value, title, or expression yourself | **[Inline editing](/fundamentals/change-your-blueprint/inline-editing)** |
## What to do next
* **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** โ the full conversational AI that Ctrl+I feeds into
* **[Inline editing](/fundamentals/change-your-blueprint/inline-editing)** โ edit titles, values, and expressions by hand
* **[Controlling the Flow](/fundamentals/leapter-canvas/controlling-the-flow)** โ the elements you can add and change
# Inline Editing
Source: https://docs.leapter.com/fundamentals/change-your-blueprint/inline-editing
Edit your Blueprints directly in the editor โ click to edit titles, descriptions, and expressions, and use the node toolbar to manage elements.
You edit your Blueprints directly in the [Blueprint Editor](/fundamentals/leapter-canvas/introduction). Every change โ whether it's renaming a section, adjusting a condition, or adding a new element โ happens in place: you click what you want to change and edit it on the spot.
You can edit from either presentation of your project:
* From the [Specification view](/fundamentals/leapter-canvas/specification-view), click into a node, a description, or a heading anywhere in the document.
* From the [Diagram view](/fundamentals/leapter-canvas/diagram-view), click any element on the maximized diagram.
There is no separate "edit mode" to switch into.
## Editing elements
Double-click any editable part of an element to start editing inline. A text cursor appears and you can type directly.
Each element type has different editable parts:
| Element type | What you can edit |
| :----------------- | :---------------------------------------------------------- |
| **Section header** | Title and description |
| **Assignment** | Title and expression (e.g., `totalScore = 0`) |
| **Decision** | Title and condition (e.g., `monthlyIncome >= 3000`) |
| **Call** | Title, target Blueprint, input mapping, and result variable |
| **Return** | Title |
| **Error** | Title and error message |
Click outside the element or press **Escape** to finish editing.
## The node toolbar
When you click an element it becomes selected (shown by a colored border) and a small **node toolbar** appears next to it.
The toolbar provides these actions:
| Icon | Action | Description |
| :---------- | :---------------- | :-------------------------------------------- |
| Copy | **Copy** | Copies the element to the clipboard |
| Paste style | **Paste style** | Applies the style from a copied element |
| Settings | **Settings** | Opens element configuration options |
| Play | **Run from here** | Runs the Blueprint starting from this element |
| Add | **Add element** | Inserts a new element after this one |
| Delete | **Delete** | Removes the element from the flow |
## Adding elements
You add new elements at **connection points** in the diagram โ the small circles between existing elements. Click one to open the [element palette](/fundamentals/leapter-canvas/controlling-the-flow), then select the element type you want to add.
The palette offers: Assignment, Decision, Loop (items), Loop (counter), Loop (while), Error, Return, and Call.
You can also add elements using the **Add** button in the node toolbar of an existing element.
## Deleting elements
To delete an element:
1. Click the element to select it
2. Click the **Delete** button (trash icon) in the node toolbar
## Editing section headers
Sections group related elements together. Each section has a **title** and a **description** that explain what that part of the logic does.
Double-click the section title or description to edit it. These labels appear in both the diagram and the [Specification view](/fundamentals/leapter-canvas/specification-view) document, so clear, descriptive names help anyone reading the project understand the logic.
## Keeping spec and logic in sync
The descriptions you edit (Blueprint descriptions, section titles, parameter descriptions) and the logic in your diagrams represent the same project from two angles. When they drift out of alignment โ you tweaked the logic but not the description, or you rewrote a description and want the logic to follow โ ask the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) to reconcile them. See [Logic & Descriptions](/fundamentals/change-your-blueprint/sync-and-suggestions).
## What to do next
* **[AI Editing](/fundamentals/change-your-blueprint/ai-editing)** โ use natural language to make changes with AI
* **[Logic & Descriptions](/fundamentals/change-your-blueprint/sync-and-suggestions)** โ keep descriptions and logic aligned with AI
* **[Controlling the Flow](/fundamentals/leapter-canvas/controlling-the-flow)** โ learn about each element type in detail
* **[Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs)** โ configure the data your project works with
# Lab Agent
Source: https://docs.leapter.com/fundamentals/change-your-blueprint/lab-agent
Build and edit Blueprints by chatting with the Lab Agent โ a conversational AI that lives in the editor, runs your tests, and proposes changes for you to approve.
The **Lab Agent** is a conversational AI built into the Blueprint Editor. Instead of clicking through
the canvas, you describe what you want in plain language and the agent builds or edits the logic for
you โ then runs your tests to check its own work. It is the fastest way to make a change when you can
say what you want in a sentence.
The agent works on the **whole project**: it can create, rename, and delete Blueprints, edit any
section, build [decision tables](/fundamentals/leapter-canvas/decision-tables) for rule-style logic, and read and write your [type definitions](/fundamentals/leapter-canvas/type-definitions).
## Opening the agent
Open the **Agent** tab in the right sidebar of the editor.
![The Lab Agent panel: a request to raise a threshold, the agent's Read / Edit / Validate / Run steps and a reply referencing the Loan Application Scorecard Blueprint, with the composer and its Approval and Quality controls below]()
Type your request in the composer at the bottom โ *"Add 15 points when the applicant has more than 5 years of employment"* or *"Explain what this Blueprint does"* โ and press Enter. The agent streams its response,
showing its reasoning ("Thought for N seconds") followed by the actions it takes.
The conversation is saved with the project โ it reloads when you come back, and is scoped to the
stream you are working on (main or a [draft](/fundamentals/track-changes/change-workflow)). Use
**Reset** to start a fresh conversation. You can also revisit the conversation behind any past change
from the [Timeline](/fundamentals/track-changes/timeline) with **View conversation**.
## @-mention pills
To point the agent at something specific, **@-mention** it. Type `@` in the composer to reference a
type definition, parameter, variable, or Blueprint, and it is inserted as an inline pill. The agent
also uses these pills in its replies, so there is no ambiguity about which element it means.
## Choosing how it works
Two controls in the composer shape how the agent behaves:
| Control | Options | What it does |
| :-------- | :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- |
| **Mode** | Approval / auto-apply | In **Approval** mode the agent proposes changes and waits for you to review and apply them; the other mode lets it write changes as it goes. |
| **Model** | Quality / Speed | **Quality** uses a stronger model for harder logic; **Speed** trades some depth for faster responses. |
A **context-usage indicator** next to these controls shows how much of the conversation window is in
use; long chats compact automatically so you can keep going.
## Reviewing and applying changes
In **Approval** mode, the agent's edits arrive as a proposed change you can inspect before they touch
your Blueprint. Apply the change to write it in, or discard it to leave your logic untouched. Because the
agent can also **run your Blueprints and test suites**, it often verifies a change itself and reports the
result inline before handing it back to you.
## Attachments
You can attach a **PDF or image** to a message โ hand the agent a requirements document, a spec, or a
screenshot of a rules table and ask it to turn it into logic.
## How the agent relates to other tools
| Tool | Reach for it when |
| :----------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------ |
| **Lab Agent** | You can describe the change in a sentence, or want AI to build across multiple Blueprints, run tests, and iterate. |
| **[Ctrl+I](/fundamentals/change-your-blueprint/ai-editing)** | You want to point the agent at a specific node fast โ Ctrl+I drops the selected node into this chat as a reference. |
| **[Inline Editing](/fundamentals/change-your-blueprint/inline-editing)** | You want to type the exact value, title, or expression yourself. |
## Tips
* **Be specific.** "Set the Approve threshold to 65 points" beats "make it stricter."
* **Stay in Approval mode** while you are learning what the agent does โ you see every change before it lands.
* **Let it test.** Ask the agent to run your test suite after a change so it catches its own mistakes.
* **@-mention to disambiguate** when your project has several similarly named elements.
## What to do next
* **[Test Suites](/fundamentals/test-suites)** โ have the agent auto-generate test cases for your Blueprint
* **[AI Editing (Ctrl+I)](/fundamentals/change-your-blueprint/ai-editing)** โ make a quick, scoped edit on the canvas
* **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ run your logic and step through the execution
# Logic & Descriptions
Source: https://docs.leapter.com/fundamentals/change-your-blueprint/sync-and-suggestions
Every Blueprint has two sides โ the plain-language descriptions and the executable logic. Keep them aligned as you edit, with help from the Lab Agent.
# Keeping logic and descriptions aligned
Every Blueprint in Leapter has two sides:
* **Descriptions** โ the project description, Blueprint descriptions, section titles, and the labels around each node, all written in plain language.
* **Logic** โ the diagram of decisions, assignments, calls, and returns that actually executes.
The [Specification view](/fundamentals/leapter-canvas/specification-view) shows both together, description next to logic. When you build a Blueprint the two are aligned, but over time they drift: you tweak a condition without updating the description, you rewrite a description without changing the logic, or a teammate edits one side without touching the other.
## Bringing the two sides back in line
The fastest way to reconcile them is to ask the **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** in plain language:
* *"Update the section descriptions to match what the logic actually does."* โ when the logic is the source of truth and the wording fell behind.
* *"Make the logic follow the description for the bulk-discount section."* โ when a domain expert updated the spec text and you want the diagram to catch up.
Because the agent edits both the diagram and the surrounding text, and can [run your tests](/fundamentals/test-your-blueprint) to check the result, it keeps the two sides consistent in one step.
For smaller, hands-on adjustments you can also:
* Make a scoped change with **[AI editing (Ctrl+I)](/fundamentals/change-your-blueprint/ai-editing)**.
* Edit a title, description, or expression yourself with **[inline editing](/fundamentals/change-your-blueprint/inline-editing)**.
## Tips
* **Reconcile before you share.** Before sending a [public link](/fundamentals/sharing) to a stakeholder, ask the agent to bring the descriptions in line with the logic so the spec they read matches what runs.
* **Reconcile after big edits.** After restructuring a diagram or rewriting a section, check that the other side hasn't fallen behind.
* **Review before applying.** In the agent's Approval mode you see every proposed change before it lands.
## What to do next
* **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** โ reconcile descriptions and logic by chatting with AI
* **[AI Editing](/fundamentals/change-your-blueprint/ai-editing)** โ make a targeted change with a natural-language prompt
* **[Inline Editing](/fundamentals/change-your-blueprint/inline-editing)** โ edit titles, descriptions, and expressions in place
# Collaborating
Source: https://docs.leapter.com/fundamentals/collaborating
Work together on shared Blueprints using comments to discuss, review, and track feedback on individual nodes.
When you work on Blueprints inside a [workspace](/fundamentals/workspaces), you can use comments to discuss specific parts of the logic with other members. Comments are attached to individual nodes, making it easy to give targeted feedback and track open discussions.
## The Comments panel
Open the **Comments** panel by clicking **Comments** in the right sidebar of the Blueprint Editor.
![The Comments panel showing tabs for All, Open, and @Me]()
The panel has three tabs that help you filter comments:
| Tab | What it shows |
| :------- | :--------------------------------------- |
| **All** | Every comment on the Blueprint |
| **Open** | Comments that have not been resolved yet |
| **@Me** | Comments where you are mentioned |
Each tab shows a count of matching comments so you can quickly see what needs attention.
## Add a comment
1. Select a node on the canvas.
2. Click **Add comment** in the Comments panel.
3. Type your comment and submit it.
Your comment is attached to the selected node. Other team members can see it when they open the same Blueprint.
## Resolve comments
When a discussion is complete or feedback has been addressed, you can resolve the comment. Resolved comments no longer appear in the **Open** tab but remain visible in the **All** tab.
## Tips for effective collaboration
* **Be specific** โ attach comments to the exact node you're discussing rather than leaving general notes.
* **Use @mentions** โ mention team members to notify them and make your comment appear in their **@Me** tab.
* **Resolve when done** โ keep the Open tab clean by resolving comments once the feedback has been addressed.
## What to do next
* **[Workspaces](/fundamentals/workspaces)** โ set up a workspace to start collaborating
* **[Personal Profile](/fundamentals/profile)** โ update your name and picture so team members can identify you
* **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ verify your Blueprint works correctly before sharing it
# Generate with AI
Source: https://docs.leapter.com/fundamentals/create-blueprint/ai-prompt
Create a Blueprint by describing your business logic in natural language โ Leapter generates the visual flow for you.
The fastest way to create a Blueprint is to describe what you need in plain language. Leapter's AI reads your description, generates a structured specification, and builds a complete, executable Blueprint โ including inputs, outputs, decision logic, and all the connecting elements.
## How it works
### Step 1: Open the Create Blueprint page
When you open an empty project โ one with no Blueprints yet โ Leapter takes you straight to the **Create a Blueprint** page, which has a prompt field in the center.
![The Create a Blueprint page with prompt field, Generate button, and suggestion chips]()
If you don't have an empty project yet, create one from the [Projects page](/fundamentals/projects).
### Step 2: Describe your logic
Type a natural language description of the logic you want to build into the text area. Be as specific as you can โ include the conditions, calculations, input values, and expected outputs.
For example:
> Loan application scorecard: score an application from the applicant's monthly income, years of employment, existing debt, and whether they have a clean credit history. Add weighted points for each factor, then return the total score and a decision โ Approve at 60 or more, Review at 35 or more, otherwise Decline
If you're not sure where to start, click one of the **Try these prompts:** suggestions below the prompt field. These fill in a ready-made description you can use as-is or edit to fit your needs:
* **Delivery fee** โ distance-based pricing with discounts and surcharges
* **Credit risk rating** โ scoring logic based on financial criteria
* **Insurance premium** โ rate calculation with age and coverage factors
* **Order routing** โ conditional routing based on order properties
![Prompt filled with a loan application scorecard description, Generate button active]()
### Step 3: Generate the Blueprint
Click the **Generate** button. Leapter processes your description through several steps โ you'll see a progress indicator showing the current stage, such as "Naming elements" or "Structuring code", and a row of dots that fills in as each stage completes.
![Generation progress with the prompt at the top, the current step ("Naming elements") below, and a row of stage dots showing progress]()
The generation typically takes 15โ30 seconds. You can click **Cancel** at any time to stop the process.
### Step 4: Review the result
Once generation completes, you land directly in the [Blueprint Editor](/fundamentals/leapter-canvas/introduction) โ the project opens in the [Specification view](/fundamentals/leapter-canvas/specification-view) with the generated Blueprint and its diagram embedded inline. Your Blueprint is ready to inspect and run.
![Generated Loan Application Scorecard blueprint in the editor]()
The AI generates a complete Blueprint with:
* **Input parameters** โ the data your Blueprint needs to run (for example: `monthlyIncome`, `employmentYears`, `existingDebt`, `hasCleanCreditHistory`)
* **Output parameters** โ the results your Blueprint returns (for example: `totalScore`, `decision`)
* **Decision nodes** โ conditional branches that route the flow based on your rules
* **Assignment nodes** โ calculations that compute values
* **Call nodes** โ reusable sub-blueprints for modular logic (when the logic is complex enough)
## Tips for better results
* **Be specific about conditions.** "Approve when the total score is 60 or more" generates better logic than "approve strong applicants."
* **Name your inputs and outputs.** If you mention "the applicant's monthly income" and "the final decision", the AI picks up those as parameter names.
* **Include edge cases.** Mention what should happen in boundary situations โ for example, "if existing debt is over 10,000, subtract 20 points."
* **Start simple, then iterate.** You can always [edit the Blueprint with AI](/fundamentals/change-your-blueprint/ai-editing) after generation to add more conditions or adjust the logic.
## What to do next
After generation, you'll typically want to:
1. **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ click the green play button on the Start node to run it with sample inputs and verify the outputs.
2. **Refine the logic** โ use [inline editing](/fundamentals/change-your-blueprint/inline-editing) to adjust individual nodes, or [AI editing](/fundamentals/change-your-blueprint/ai-editing) to make broader changes.
3. **[Deploy it](/executing-blueprints/introduction)** โ once you're satisfied, connect your Blueprint via REST API, MCP, or export it as code.
# From Scratch
Source: https://docs.leapter.com/fundamentals/create-blueprint/from-scratch
Create an empty Blueprint and build your logic step by step on the canvas.
If you prefer to build your logic manually โ or need full control from the start โ you can create an empty Blueprint and add elements one by one on the canvas.
## How to create an empty Blueprint
### Step 1: Open the Create Blueprint page
When you open an empty project โ one with no Blueprints yet โ Leapter takes you straight to the **Create a Blueprint** page. If you don't have an empty project, create one from the [Projects page](/fundamentals/projects).
### Step 2: Start with an empty Blueprint
Click the **Start with empty blueprint** button at the bottom of the page. Leapter creates a new Blueprint and opens it in the [Blueprint Editor](/fundamentals/leapter-canvas/introduction), maximized into the [Diagram view](/fundamentals/leapter-canvas/diagram-view) so you can start building right away.
![Empty Blueprint with the Start node and element palette ready next to it]()
You start with:
* A **Start node** (green circle) โ the entry point where execution begins
* An **element palette** โ a row of icons next to the Start node for adding your first element
The Contents sidebar on the left shows your project structure, including the empty **Inputs and Outputs** section โ you'll define these as you build your logic. See [Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs).
## Building your Blueprint
### Add elements
Click an icon in the element palette to add an element to the canvas. The palette has seven icons covering these element types:
| Element | Purpose |
| :-------------------------------- | :--------------------------------------------------------------- |
| **Assignment** | Perform calculations and store results in variables |
| **Decision** | Create conditional branches (if/else logic) |
| **Loop with counter** (`for`) | Repeat a section of logic over items in a list or with a counter |
| **Loop with condition** (`while`) | Repeat as long as a condition stays true |
| **Error** | End the Blueprint with an error condition |
| **Return** | End the Blueprint successfully and return output values |
| **Call** | Execute another Blueprint as a sub-routine |
After you place an element, a new palette appears at its output, letting you chain elements together. You build the flow left to right, top to bottom.
For a detailed guide on each element, see [Controlling the Flow](/fundamentals/leapter-canvas/controlling-the-flow).
### Define inputs and outputs
Your Blueprint needs data to work with. In the **Data** panel on the left side:
1. Click **Add** next to **Inputs** to define what information your Blueprint receives
2. Click **Add** next to **Outputs** to define what results it returns
3. Give each parameter a name, type, and description
For detailed guidance on configuring parameters, see [Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs).
### Configure elements
Double-click any element on the canvas to configure it:
* **Decision nodes** โ set the condition expression and define branches
* **Assignment nodes** โ write the calculation or value assignment
* **Loop nodes** โ specify what to iterate over or the loop condition
* **Call nodes** โ select which Blueprint to call and map its inputs
## When to start from scratch
Starting from scratch works best when:
* You have a clear picture of the logic and want to build it step by step
* You want to learn how Blueprint elements work by placing them yourself
* You need a very specific structure that AI generation might not produce
* You're building a small helper Blueprint (like a lookup table or simple calculation)
For most use cases, [generating with AI](/fundamentals/create-blueprint/ai-prompt) is faster โ you can always refine the result afterward.
## What to do next
1. **Add your elements** โ build out the flow by chaining decisions, assignments, and returns
2. **[Test as you go](/fundamentals/test-your-blueprint)** โ click the green play button on the Start node to run your Blueprint at any point during development
3. **Use AI to help** โ press **Ctrl+I** (**Cmd+I** on Mac) to open the [AI editing](/fundamentals/change-your-blueprint/ai-editing) prompt, which can modify selected nodes or add new logic based on your instructions
# From Example Template
Source: https://docs.leapter.com/fundamentals/create-blueprint/from-template
Get started quickly by creating a Blueprint from one of the built-in example templates.
If you want to explore how Blueprints work before building your own, start with one of the built-in example templates. Each template is a fully working Blueprint that you can run, inspect, and modify.
## How to create a Blueprint from a template
### Step 1: Open the Create Blueprint page
When you open an empty project โ one with no Blueprints yet โ Leapter takes you straight to the **Create a Blueprint** page. If you don't have an empty project, create one from the [Projects page](/fundamentals/projects).
### Step 2: Find the templates
Three example templates are available on the Create a Blueprint page. How they appear depends on which way you got there:
* **First Blueprint in a project** โ the templates are visible inline at the bottom of the page, under an **OR START WITH AN EXAMPLE** divider, alongside the **Start with empty blueprint** button.
* **Adding a Blueprint to an existing project** โ the templates are hidden behind a **Browse examples** button. Click it to reveal the cards (the button label flips to **Hide examples**).
![The Create a Blueprint page with three example template cards visible โ Hello World, Photo Price Calculator, and Extended Pizza Pricing]()
The available templates are:
* **Hello World** โ greets the user by name if provided, or falls back to a default "Hello, World!" message using simple conditional logic
* **Photo Price Calculator** โ implements multi-branch pricing to set the price per photo based on its size, including handling for unsupported dimensions
* **Extended Pizza Pricing** โ multi-stage logic that calculates the total cost of a pizza order, incorporating conditional pricing for size, premium extras, promotional codes, and weekend surcharges
### Step 3: Select a template
Click the card for the template you want to use. Leapter creates a copy of that Blueprint in your project and opens it in the [Blueprint Editor](/fundamentals/leapter-canvas/introduction).
The Blueprint is fully yours โ any changes you make only affect your copy, not the original template.
## Learning from templates
Templates are a great way to understand how Blueprints are built. When you open one, explore these areas:
* **Contents sidebar (left side)** โ see how the project is structured: Type Definitions, Inputs and Outputs, and the Blueprints
* **Inputs and Outputs section** โ see how parameters are defined and what types they use
* **Embedded diagram** โ follow the flow from the Start node through decision branches, assignments, and return nodes
* **Maximized [Diagram view](/fundamentals/leapter-canvas/diagram-view)** โ double-click a Blueprint in the Contents sidebar to fill the canvas with its diagram
To go deeper into how the editor works, see [The Blueprint Editor](/fundamentals/leapter-canvas/introduction).
## What to do next
Once you've explored a template:
1. **[Test it](/fundamentals/test-your-blueprint)** โ click the green play button to run it with sample inputs and see the outputs.
2. **Modify it** โ change a condition, add a new branch, or adjust a calculation to see how the Blueprint responds. Use [inline editing](/fundamentals/change-your-blueprint/inline-editing) or [AI editing](/fundamentals/change-your-blueprint/ai-editing).
3. **Build your own** โ when you're ready, go back to your project and [generate a Blueprint with AI](/fundamentals/create-blueprint/ai-prompt) or [start from scratch](/fundamentals/create-blueprint/from-scratch).
# Integrations
Source: https://docs.leapter.com/fundamentals/integrations
Connect external tools like Linear and GitHub so the Lab Agent can use them on your behalf โ enabled for the workspace by an owner, connected individually by each member.
Integrations let the **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** work with external tools โ reading from and writing to systems like Linear or GitHub while it helps you build. An owner turns an integration on for the workspace; then each member connects their own account, so the agent always acts with *your* identity and permissions.
This is the reverse direction from [Deploy & Integrate](/executing-blueprints/introduction), which is about calling *your* Blueprints from outside Leapter. Here, external tools are brought *in* for the Lab Agent to use.
## How integrations work
Every integration goes through three levels:
1. **Catalog** โ Leapter curates the list of available integrations. You cannot add arbitrary servers; you pick from the catalog.
2. **Workspace enablement** โ an **owner** turns an integration on for the whole workspace. It is off by default.
3. **Personal connection** โ each **member** connects their own account. The agent uses your connection, with your identity and permissions โ so a Linear issue the agent files is filed as *you*.
## Where to find integrations
Click **Integrations** in the workspace settings sidebar. The page has two parts.
![The Integrations page with the Your connections zone and the owners-only Team setup catalog listing GitHub, GitHub MCP, and Linear]()
### Your connections
Every member sees **Your connections** โ the integrations your workspace has enabled, each with a **Connect** / **Disconnect** action and a status. Connecting runs you through the tool's own sign-in so your credentials are stored against your membership, never shared with the rest of the team.
### Team setup (owners only)
Owners also see **Team setup**, the catalog of integrations the workspace can use. Each row shows:
| Column | Description |
| :-------------- | :---------------------------------------------------------------------------------------- |
| **Integration** | The tool's name and logo |
| **Team access** | Whether it is enabled for the workspace โ an owner toggle, or a managed badge (see below) |
| **Server** | The server the integration connects to (some can point at a self-hosted URL) |
| **Health** | The connection's verification status |
## What you can connect today
| Integration | How it's enabled |
| :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- |
| **Linear** | An owner toggles **Team access** on; each member then connects their Linear account. |
| **GitHub MCP** | An owner toggles it on; each member connects with a GitHub token. |
| **GitHub** (git sync) | An **Enterprise feature** โ shown with an *Enterprise feature* badge and enabled by Leapter for your workspace, not through the owner toggle. |
Some integrations are **managed for you**. GitHub git-sync shows an **Enterprise feature** badge and is enabled by Leapter; self-hosted internal servers show an **Admin managed** badge. For these, there is no owner toggle โ contact Leapter or your administrator to have them enabled.
## Connect an integration
Once an owner has enabled an integration, each member connects their own account:
1. Open **Integrations** and find the tool under **Your connections**.
2. Click **Connect**.
3. Complete the tool's sign-in (for example, authorize Linear, or paste a GitHub token).
The Lab Agent can now use that tool in your sessions. Your token is stored securely against your membership; disconnect at any time from the same page.
## What to do next
* **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** โ the AI that uses your connected tools while it builds
* **[Workspaces](/fundamentals/workspaces)** โ manage who is in your workspace and who can enable integrations
* **[API Keys](/fundamentals/api-keys)** โ the reverse direction: let outside systems call your Blueprints
# Calling Other Blueprints
Source: https://docs.leapter.com/fundamentals/leapter-canvas/calling-other-blueprints
Reuse logic by calling one Blueprint from another using Call nodes.
Call nodes let you run another Blueprint as part of your flow. They serve two key purposes:
1. **Breaking down complexity** โ split large logic into smaller, focused Blueprints instead of ending up with one giant, hard-to-maintain Blueprint. Each piece handles a specific part of the logic and can be understood on its own.
2. **Reusing logic** โ build common operations once (like a validation check or a calculation) and call them from multiple Blueprints without duplicating the logic.
Think of it as delegating a task: your Blueprint hands off data to another Blueprint, waits for it to finish, and continues with the result.
![A Call node configured to call another Blueprint, showing one input and a result variable]()
## How Call nodes work
A Call node has three parts:
1. **Target Blueprint** โ which Blueprint to call
2. **Inputs** โ the values you pass to the called Blueprint
3. **Result variable** โ where to store the result that comes back
When your Blueprint reaches a Call node during execution, it pauses, runs the called Blueprint with the inputs you provided, captures the result, and then continues.
## Adding a Call node
1. In the [Diagram view](/fundamentals/leapter-canvas/diagram-view), find an open connection point in your flow โ the [element palette](/fundamentals/leapter-canvas/controlling-the-flow) appears next to it.
2. Click the **Call** icon (the purple grid) in the palette.
![The element palette next to a connection point โ the Call icon at the right end places a Call node]()
3. The placed Call node opens a Blueprint selector. Pick which Blueprint to call.
![The Blueprint selector showing the other Blueprints available in the project]()
You can only call Blueprints within the same project. The called Blueprint must already exist.
## Mapping inputs
When you call a Blueprint, you map values from your current Blueprint to the inputs that the called Blueprint expects. For each input parameter, you enter an expression โ a variable name, calculation, or literal value.
![Input mapping and result variable configuration]()
| Target parameter | Expression | What it does |
| :--------------- | :--------------------- | :------------------------------- |
| `amount` | `orderTotal` | Passes the value of `orderTotal` |
| `taxRate` | `0.19` | Passes a fixed value |
| `price` | `basePrice * quantity` | Passes a calculated value |
## Capturing the result
After the called Blueprint finishes, it returns a result. You store this in a **result variable** so your Blueprint can use it in subsequent elements.
For example, if you call a "Calculate Tax" Blueprint, you might store the result in `taxAmount`. You can then use `taxAmount` in any element that comes after the Call node.
## Navigating to called Blueprints
Call nodes show the name of the called Blueprint as a clickable link, both in the [Specification view](/fundamentals/leapter-canvas/specification-view) document and in the maximized [Diagram view](/fundamentals/leapter-canvas/diagram-view). Click to preview it, or **Shift+click** to navigate directly to it.
## When to use Call nodes
* **Keeping Blueprints manageable** โ if your Blueprint is growing large and hard to follow, split it into smaller pieces connected by Call nodes. Each Blueprint should ideally handle one clear responsibility.
* **Reusing common logic** โ build validation, calculations, or formatting once and call from multiple Blueprints
* **Standardizing business rules** โ ensure the same logic is used consistently everywhere
* **Team collaboration** โ different team members can work on different Blueprints independently, then connect them with Call nodes
## Tips
* Name called Blueprints clearly โ the name appears in the Call node, so descriptive names like "Calculate Tax" make your flow easier to read
* Keep called Blueprints focused on a single task
* Test called Blueprints independently before calling them
* Avoid deep nesting โ while Blueprints can call other Blueprints (and so on), too many levels make the logic hard to follow. Leapter limits call depth to 10 levels.
## What to do next
* **[Controlling the Flow](/fundamentals/leapter-canvas/controlling-the-flow)** โ learn about all the element types
* **[Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs)** โ define the data contract between Blueprints
* **[Diagram view](/fundamentals/leapter-canvas/diagram-view)** โ see how Call nodes appear in the diagram
# Controlling the Flow
Source: https://docs.leapter.com/fundamentals/leapter-canvas/controlling-the-flow
Learn about the elements that make up a Blueprint โ decisions, assignments, loops, returns, and errors.
Blueprints are built from elements that you wire together to define your logic. Each element either controls the execution path or performs an action. You add elements using the **element palette** that appears at connection points in the diagram.
![The element palette showing available element types]()
## Assignment
The Assignment element performs a calculation or stores a value in a variable. It appears as a purple block on the canvas.
![An Assignment element setting pricePerPhoto to 0.19]()
An assignment has two parts:
* **Variable name** (left of `=`) โ the variable to create or update
* **Expression** (right of `=`) โ the value or calculation to assign
Expressions support standard operators (`+`, `-`, `*`, `/`), variable references, and literal values like numbers or strings.
## Decision
The Decision element creates conditional branches in your flow. It evaluates a condition and routes execution down different paths (IF/ELSE). It appears as a yellow block.
![A Decision branch checking printSize is "4x6"]()
A decision has:
* **Condition** โ a comparison expression (e.g., `printSize is "4x6"`, `cartValue >= 50`)
* **True path** โ executes when the condition is true
* **False/Else path** โ executes when the condition is false
### Multiple conditions
You can add multiple condition blocks to handle more complex scenarios. Each condition is evaluated top to bottom โ execution follows the first one that is true.
![A Tiered print size pricing decision with three IF branches and an ELSE branch routing to assignments and an error]()
Click **Create a condition** below your existing conditions to add more. You can also add an **Else** block that catches anything not handled by previous conditions.
When a rule is really a lookup โ several inputs mapping to an outcome โ a **[Decision Table](/fundamentals/leapter-canvas/decision-tables)** is often clearer than a long chain of conditions. It lays the rules out as a grid you can read at a glance.
## Loops
Loops repeat a section of your flow. There are three types:
### Loop over Items
Iterates through each item in a list. You specify:
* **Variable** โ holds the current item (e.g., `item`)
* **Collection** โ the list to iterate over (e.g., `itemValues`)
* **Counter** (optional) โ tracks the current position (e.g., `index`)
![A While loop iterating over a list with an index, summing match scores into currentSum]()
### Loop with Counter
Repeats a fixed number of times, like a classic `for` loop. You specify:
* **Variable** โ the counter with its starting value (e.g., `i=0`)
* **Condition** โ when to stop (e.g., `i < 10`)
* **Step** โ how the counter changes each iteration (e.g., `i=i + 1`)
![A While loop with a counter from 0 to 9 accumulating runningScore]()
### Loop with While Condition
Repeats as long as a condition remains true. You specify:
* **Condition** โ checked before each iteration (e.g., `debtBalance > 0`)
The loop exits when the condition becomes false.
![A While loop reducing currentBalance by paymentAmount until the balance is cleared]()
### Continue and Exit Loop
Inside any loop, two additional elements become available:
* **Continue** โ skips the rest of the current iteration and moves to the next one. Useful for filtering out items you don't want to process.
* **Exit Loop** โ stops the entire loop immediately. Useful for search operations where you can stop once you've found what you're looking for.
## Return
The Return element ends your Blueprint successfully and returns the output values. It appears as a green block with a check icon.
![A Return element labeled "Final calculated unit price"]()
You can place Return elements anywhere in the flow. When execution reaches a Return, the Blueprint stops and sends the output values back to the caller.
## Error
The Error element stops your Blueprint and returns an error message. It appears as a red block.
![An Error element with the message "The given print size is not supported"]()
You specify an **error message** that explains what went wrong. Use Error elements for input validation, business rule violations, or any situation where the Blueprint cannot continue.
## What to do next
* **[Calling Other Blueprints](/fundamentals/leapter-canvas/calling-other-blueprints)** โ reuse logic by calling one Blueprint from another
* **[Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs)** โ define the data your Blueprint works with
* **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ run your Blueprint with test inputs
# Decision Tables
Source: https://docs.leapter.com/fundamentals/leapter-canvas/decision-tables
Express first-match business rules as a grid of inputs and outcomes โ clearer and easier to review than a long chain of nested decisions.
A **decision table** captures a set of rules as a grid: a few input columns, one or more output columns, and one row per rule. When some inputs match a row, that row's outputs are produced. It is the natural way to express a lookup โ "these inputs lead to this outcome" โ where a long chain of [Decision](/fundamentals/leapter-canvas/controlling-the-flow#decision) branches would hide the structure.
Because the rules sit in a table, the inputs, the outcomes, and the order they are checked are all visible at a glance โ which makes a decision table much easier for a reviewer to read and verify than nested IF/ELSE logic.
## Where decision tables appear
A decision table is a type of element inside a Blueprint, shown as a grid with a table icon. You see it in both places you work with a Blueprint:
* In the **[Diagram view](/fundamentals/leapter-canvas/diagram-view)**, as a grid element in the flow.
* In the **[Specification view](/fundamentals/leapter-canvas/specification-view)**, as a table in the document.
![A decision table element in a Blueprint โ a grid mapping the riskCategory and hasCleanCreditHistory input columns to a reviewAction output column, with an arrow marker between them]()
## How to read a decision table
| Part | Meaning |
| :----------------- | :------------------------------------------------------------------------ |
| **Input columns** | The values a rule looks at (left of the arrow marker) |
| **Output columns** | The values a matching rule produces (right of the arrow marker `โ`) |
| **Rows** | One rule each, checked from top to bottom |
| **`any`** | A wildcard cell โ this rule does not care about that input's value |
| **First-match** | The **first** row whose inputs all match wins; no later row is considered |
The **first-match** badge on the table is a reminder that order matters: rules are evaluated top to bottom, and evaluation stops at the first row that matches. A row full of `any` at the bottom is a common way to provide a catch-all default.
An input cell matches when the input **equals** the cell's value (an enum option or a boolean), or when the cell is **`any`**. Output cells are expressions, so an outcome can be a fixed value or a small calculation.
## Creating a decision table
The quickest way to add a decision table is to ask the **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)**. Describe the rule as a mapping โ for example *"map each score band and binding flag to a legal consequence"* โ and the agent builds the table for you. When a rule is a straightforward lookup, the agent now prefers a decision table over a chain of decisions.
Decision tables are also part of the underlying Blueprint logic, so they are created and regenerated whenever your logic is generated or edited with AI.
## Editing cells
To change a decision table by hand, **maximize** it first: click its maximize icon to open the full-width view, which shows the table's name, its first-match policy, and the complete grid.
![A maximized decision table showing the name, the first-match policy, and the full grid of rules]()
On the maximized table you can:
* **Edit a value cell** โ click a cell and type a new value.
* **Toggle a wildcard** โ switch a cell to or from **`any`**.
Edits go through the same save path as any other change, so they appear in the [Timeline](/fundamentals/track-changes/timeline), can be undone, and show up in review just like edits to any other element.
Editing the compact grid in the flow, and adding or removing whole columns, are not available yet โ maximize the table to edit its cells, and use the Lab Agent to change its shape.
## Running a decision table
When you [run your Blueprint](/fundamentals/test-your-blueprint), the row that fired lights up in the table, so you can see exactly which rule applied for a given set of inputs. This makes it easy to confirm that the right rule won โ especially useful when several rows could plausibly match and first-match order decides between them.
## What to do next
* **[Controlling the Flow](/fundamentals/leapter-canvas/controlling-the-flow)** โ the other elements that make up a Blueprint
* **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** โ build and edit decision tables by describing the rules
* **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ run your logic and see which row fires
# Diagram View
Source: https://docs.leapter.com/fundamentals/leapter-canvas/diagram-view
When you maximize a Blueprint, you see it as an interactive diagram. Build, edit, and debug your logic visually.
When you focus on a single Blueprint inside the [Blueprint Editor](/fundamentals/leapter-canvas/introduction), the editor maximizes that Blueprint and fills the canvas with its diagram. This is the Diagram view โ a flowchart of connected elements that represent your business logic.
![A maximized Blueprint filling the canvas โ the Loan Application Scorecard with its Validate Inputs and Evaluate Monthly Income sections, showing decision branches and assignment nodes]()
You enter the Diagram view from the [Specification view](/fundamentals/leapter-canvas/specification-view) by:
* Double-clicking a Blueprint's entry in the Contents sidebar
* Clicking the **maximize** icon in a Blueprint's section header
* Clicking a Call node's link to open the called Blueprint
To leave it, click **Minimize** in the top toolbar (or click the **X** on the maximized blueprint pill). You return to the full Specification document with that Blueprint's diagram embedded inline at its section.
## Reading the diagram
Execution flows **top to bottom**. Each element is color-coded by type:
| Color | Element type | Purpose |
| :---------------------- | :------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------ |
| **Green** (circle icon) | Start node | The entry point where execution begins |
| **Yellow** | Decision | Conditional branching โ evaluates a condition and routes the flow (IF / ELSE) |
| **Grid icon** | [Decision Table](/fundamentals/leapter-canvas/decision-tables) | A first-match grid of rules โ inputs mapped to outcomes. Maximize it to see the full table and edit its cells |
| **Yellow** | Section header | Labeled group with a title and description that explains a part of the logic |
| **Purple** | Assignment | Performs a calculation or sets a variable value |
| **Green** (check icon) | Return | Ends execution successfully and returns output values |
| **Red** | Error | Ends execution with an error condition |
| **Blue** | Call | Calls another Blueprint as a sub-routine |
Sections can be collapsed or expanded by clicking the collapse button in their header.
## Canvas controls
View controls for the diagram โ undo and redo, zoom, fit-to-view, and canvas settings โ live in the [top toolbar](/fundamentals/leapter-canvas/introduction#top-toolbar) above the editor.
To edit with AI, select a node and press **Ctrl+I** to send it to the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) (see [Edit with Ctrl+I](/fundamentals/change-your-blueprint/ai-editing)), or open the **Agent** tab in the right sidebar for a full conversation.
## Building and editing
### Adding elements
You add new elements at **connection points** in the diagram โ the small circles between existing elements. Click one to open the element palette, then select the element type you want to add.
The palette offers: Assignment, Decision, Loop (items), Loop (counter), Loop (while), Error, Return, and Call.
For a detailed guide on each element type, see [Controlling the Flow](/fundamentals/leapter-canvas/controlling-the-flow).
### Editing elements
Double-click any element on the diagram to edit its configuration inline:
* **Decision nodes** โ edit the condition expression and branch labels
* **Assignment nodes** โ edit the calculation or variable assignment
* **Call nodes** โ select which Blueprint to call and configure input / output mapping
When you click an element, it becomes selected and a small node toolbar appears with copy, settings, run-from-here, add-element, and delete actions. See [Inline editing](/fundamentals/change-your-blueprint/inline-editing) for details.
### AI editing
Select a node and press **Ctrl+I** (or **Cmd+I** on Mac) to drop it into the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) chat as a reference, then type your instruction โ see [Edit with Ctrl+I](/fundamentals/change-your-blueprint/ai-editing). For a longer conversation that can build across Blueprints and run your tests, open the **Agent** tab in the right sidebar.
## Running and tracing
You can run the maximized Blueprint directly from the diagram. After a run, the execution path is highlighted on the canvas and the **trace controls** in the [top toolbar](/fundamentals/leapter-canvas/introduction#top-toolbar) become active โ Step in, Step out, Previous, Next โ so you can replay the execution step by step.
While [Live mode](/fundamentals/test-your-blueprint#live-mode) is running, the Blueprint re-runs automatically as you edit, and the Outputs footer at the bottom of the canvas updates continuously.
For detailed instructions, see [Test your Blueprint](/fundamentals/test-your-blueprint).
## What to do next
* **[Specification view](/fundamentals/leapter-canvas/specification-view)** โ return to the document view of your whole project
* **[Controlling the Flow](/fundamentals/leapter-canvas/controlling-the-flow)** โ learn about each element type in detail
* **[Inline editing](/fundamentals/change-your-blueprint/inline-editing)** โ edit nodes directly on the canvas
* **[AI editing](/fundamentals/change-your-blueprint/ai-editing)** โ modify your Blueprint with natural language
# Inputs and Outputs
Source: https://docs.leapter.com/fundamentals/leapter-canvas/inputs-and-outputs
How parameters work in Leapter โ every Blueprint has its own signature, and the project's external interface is the signature of the active Execution Scope.
Every Blueprint in Leapter has its own **signature** โ the inputs it expects and the outputs it returns. A project usually contains several Blueprints (an entry point and one or more sub-Blueprints called via [Call nodes](/fundamentals/leapter-canvas/calling-other-blueprints)). At runtime, only one of those Blueprints is the project's externally visible interface โ the **Execution Scope**.
This page covers both perspectives: what a Blueprint signature is, and how the Execution Scope determines the project's API.
## Per-Blueprint signature
Each Blueprint has:
* **Inputs** โ the values it receives when it runs
* **Outputs** โ the values it returns when it finishes
* **Local variables** โ internal scratch space, not visible to callers
You see and edit a Blueprint's signature in the [Contents sidebar](/fundamentals/leapter-canvas/introduction#contents-sidebar-left): click the **# N** parameters button next to the Blueprint name (where N is the count of inputs + outputs). The Blueprint expands to show its inputs and outputs in line.
![The Contents sidebar with a blueprint expanded โ green spark for the active Execution Scope, the parameter-count badge, and the Inputs and Outputs lines below with controls to set values and read results]()
Each parameter has:
* **Name** โ the identifier used to reference this value in your logic (e.g., `monthlyIncome`, `existingDebt`)
* **Type** โ what kind of data it holds: `string`, `number`, `boolean`, `date`, an `enum`, or one of your project's [Type Definitions](/fundamentals/leapter-canvas/type-definitions)
* **Description** โ explains what the value represents
* **Required** โ whether the input must be provided or is optional
* **Multiple** โ whether the parameter accepts a list of values instead of a single value
### List parameters
When you check the **Multiple** option, the parameter accepts a list of values. This is useful when your Blueprint needs to process multiple items โ like a list of order amounts or customer names. Use [Loop elements](/fundamentals/leapter-canvas/controlling-the-flow#loops) to iterate over list inputs.
### Local variables
Local variables are internal to the Blueprint that defines them. Use them for intermediate calculations, counters, or temporary values. They aren't visible to other Blueprints and aren't part of any signature.
## Execution Scope and the project's external interface
When a project runs โ whether you click run in the editor, call it via the [REST API](/executing-blueprints/connect-rest-api), or invoke it via [MCP](/executing-blueprints/connect-mcp) โ execution starts from one Blueprint: the **Execution Scope**.
The Blueprint marked as the active Execution Scope shows a green spark icon (โก) in the Contents sidebar. Its signature **is** the project's external interface:
* The inputs the project receives are this Blueprint's inputs
* The outputs the project returns are this Blueprint's outputs
A project's top-level **Inputs and Outputs** entry in the Contents sidebar is a shortcut to the Execution Scope's signature.
### Switching the Execution Scope
You can change which Blueprint is the active Execution Scope. This is useful when you want to test a sub-Blueprint in isolation, or restructure your project so a different Blueprint becomes the entry point. Other Blueprints remain in the project and can still be called via [Call nodes](/fundamentals/leapter-canvas/calling-other-blueprints).
## Why per-Blueprint signatures matter
| Context | What a signature does |
| :------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Testing in the editor** | Quick-run controls show input fields based on the Blueprint's inputs and display its outputs. While [Live mode](/fundamentals/test-your-blueprint#live-mode) is running, every change re-runs and refreshes the outputs. |
| **Call nodes** | When one Blueprint calls another, it maps values into the called Blueprint's inputs and captures its outputs โ see [Calling Other Blueprints](/fundamentals/leapter-canvas/calling-other-blueprints) |
| **REST API** | Callers send the Execution Scope's inputs as JSON and receive its outputs in the response |
| **MCP** | AI assistants use the Execution Scope's signature to understand what the project does and how to call it |
| **Specification view** | Every Blueprint's signature is visible in the document, in the Contents sidebar, and as a project-level summary at the top |
## Tips
* Use descriptive names โ `cartValue` is better than `val1`
* Write descriptions as if explaining to someone who's never seen the project โ they show up in the API surface and in any [public share](/fundamentals/sharing)
* Only mark inputs as required if the Blueprint truly cannot function without them
* Reach for [Type Definitions](/fundamentals/leapter-canvas/type-definitions) when several inputs or outputs share the same shape โ define the type once and reuse it across Blueprints
## What to do next
* **[Type Definitions](/fundamentals/leapter-canvas/type-definitions)** โ define reusable Value Types and Data Types
* **[Calling Other Blueprints](/fundamentals/leapter-canvas/calling-other-blueprints)** โ pass typed values between Blueprints
* **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ set values and run from the Contents sidebar
# The Blueprint Editor
Source: https://docs.leapter.com/fundamentals/leapter-canvas/introduction
An overview of the Blueprint Editor โ a single workspace where you read, build, run, and share the Blueprints in your project.
The Blueprint Editor is the main workspace in Leapter. Every project opens directly into the editor, and the editor shows the entire project at once: the type definitions, the project's inputs and outputs, every Blueprint in the project, and the dependencies between them.
The Blueprint Editor is a single page. There is no separate "diagram" page or "spec" page โ you work in one place that combines a structured document view ([Specification view](/fundamentals/leapter-canvas/specification-view)) with the interactive diagrams embedded inline. When you want to focus on a single Blueprint's diagram, you maximize it in place โ see [Diagram view](/fundamentals/leapter-canvas/diagram-view).
![The Blueprint Editor showing the top toolbar, Contents sidebar, document area with embedded diagram, and the tabbed right sidebar]()
## Editor layout
The editor is divided into four areas: a top toolbar, a Contents sidebar on the left, the document area in the center, and a tabbed sidebar on the right.
### Top toolbar
![The editor top toolbar โ toggle sidebar, the live-execution play/pause button with a status pill, trace controls, undo and redo, canvas settings, split-view, zoom and fit, minimize, and the Share button]()
The top toolbar runs across the top of the editor:
* **Toggle sidebar** โ collapses or expands the main app sidebar (the narrow vertical strip with Projects, Profile, and API keys).
* **Live execution** โ a **play / pause button** (with a status pill beside it) that controls [Live mode](/fundamentals/test-your-blueprint#live-mode). While it is running, your Blueprints re-execute automatically every time you change inputs or logic, so the Outputs footer in each section stays current. Pause it to stop auto-running; resume it to turn continuous execution back on.
* **Maximized blueprint pill** โ when a Blueprint is maximized to its diagram, its name appears here. Click to switch which Blueprint is maximized; click the **X** to leave the maximized view.
* **Trace controls** โ Jump to first / Previous / Step counter / Next / Jump to last, plus **Step into** and **Step out** for [Call nodes](/fundamentals/leapter-canvas/calling-other-blueprints), and **Exit trace**. These are active after you run a Blueprint and let you replay the execution step by step. See [Test your Blueprint](/fundamentals/test-your-blueprint#stepping-through-a-trace).
* **Edit and view controls** โ undo and redo, zoom, fit-to-view, and canvas display settings, for the maximized diagram.
* **Share** โ opens the [Share menu](/executing-blueprints/introduction#the-share-menu) with deployment options (Connect, n8n, Code, Embed, PNG, Export Source) and a **Link** for [public read-only links](/fundamentals/sharing).
### Contents sidebar (left)
The **Contents** sidebar shows everything in your project as a navigable table of contents:
* **Type Definitions** โ reusable Value Types and Data Types defined at the project level. Double-click to open the [Type Definitions editor](/fundamentals/leapter-canvas/type-definitions).
* **Inputs and Outputs** โ a shortcut to the project's external interface, which is the signature of the active [Execution Scope](#execution-scope-and-the-main-blueprint). See [Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs).
* **Blueprints** โ every Blueprint in the project, listed with its name. Each Blueprint shows its numbered sections (1, 1.1, 2, โฆ) when expanded. Double-click a Blueprint or section to maximize it.
* **Dependencies** โ at the bottom, a graph showing which Blueprints call which. Useful for navigating large projects and spotting circular dependencies.
Click any entry to scroll the document to that location. Double-click to maximize a Blueprint to its diagram.
#### Execution scope and the main Blueprint
A green spark icon (โก) next to a Blueprint name marks it as the active **Execution Scope** โ the entry point that runs when the project is invoked from outside. Its signature is the project's external interface (and what the **Inputs and Outputs** shortcut at the top of the sidebar points to). You can change which Blueprint is the active Execution Scope; the others remain in the project and can still be called via [Call nodes](/fundamentals/leapter-canvas/calling-other-blueprints).
#### Parameters and Quick Run
![The Contents sidebar with the Calculate Loan Application Scorecard blueprint expanded โ the green spark marks the active Execution Scope, the parameter-count badge shows the number of inputs and outputs, and the expanded inputs and outputs are listed below with controls to set values]()
Each Blueprint in the Contents sidebar has a **# N** badge โ the count of its inputs and outputs. Click it to expand the Blueprint's parameters in line:
* Each input shows its name, description, and a control to set a value (e.g. `not set` dropdown for an enum, a number field for a number)
* Each output shows its name, description, and the most recent value (after a run)
This is the **Quick Run** entry point: set values on the inputs, then run the Blueprint manually or leave **[Live mode](/fundamentals/test-your-blueprint#live-mode)** running to re-run automatically as you edit. See [Test your Blueprint](/fundamentals/test-your-blueprint).
### Document area (center)
The center area shows the project as a structured document. The top of the document shows the project's name and description, followed by Type Definitions, Inputs and Outputs, and then each Blueprint as a section with:
* A heading with the Blueprint name and description
* An interactive diagram showing the Blueprint's logic
* An Outputs footer (when [Live mode](/fundamentals/test-your-blueprint#live-mode) is running or after a manual run) showing the current output values
This is the **Specification view** โ see [Specification view](/fundamentals/leapter-canvas/specification-view) for details on navigating and editing inside it.
To focus on a single Blueprint's diagram, double-click its entry in the Contents sidebar or click its maximize icon. The diagram fills the canvas and the rest of the document is hidden โ see [Diagram view](/fundamentals/leapter-canvas/diagram-view).
### Right sidebar
![The right sidebar tab strip with Tests, Agent, Findings, Prod Runs, Comments, and Timeline]()
The right sidebar is collapsed by default. Click any tab to open it:
* **Tests** โ manage [test suites](/fundamentals/test-suites) for the active Blueprint. Create them manually or auto-generate with AI.
* **Agent** โ open the **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)**, a conversational AI that builds and edits Blueprints, runs your tests, and proposes changes for you to approve.
* **Findings** โ issues the Lab Agent surfaces when it reviews your project, recorded so you can work through them.
* **Prod Runs** โ execution logs from when your Blueprint runs in production via the [REST API](/executing-blueprints/connect-rest-api) or [MCP](/executing-blueprints/connect-mcp).
* **Comments** โ leave comments on Blueprints, sections, or nodes for [team collaboration](/fundamentals/collaborating).
* **Timeline** โ the project's change history: every version, who changed what, and the option to restore an earlier state. See [Timeline](/fundamentals/track-changes/timeline).
### Editing a maximized diagram
When a Blueprint is maximized, you edit it directly on the canvas โ double-click an element to change it (see [Inline editing](/fundamentals/change-your-blueprint/inline-editing)), or add elements at the connection points between nodes. To edit with AI, select a node and press **Ctrl+I** to send it to the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) โ see [Edit with Ctrl+I](/fundamentals/change-your-blueprint/ai-editing). Undo, redo, zoom, and canvas settings are in the [top toolbar](#top-toolbar).
## What to do next
* **[Specification view](/fundamentals/leapter-canvas/specification-view)** โ navigate and edit the project as a document
* **[Diagram view](/fundamentals/leapter-canvas/diagram-view)** โ work inside a single Blueprint's diagram
* **[Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs)** โ define what data flows through your project
* **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** โ build and edit your Blueprints by chatting with AI
# Specification View
Source: https://docs.leapter.com/fundamentals/leapter-canvas/specification-view
The structured document workspace where you read and edit your entire project โ Type Definitions, Inputs and Outputs, and every Blueprint with its diagram embedded inline.
The Specification view is the default workspace in the [Blueprint Editor](/fundamentals/leapter-canvas/introduction). It presents your entire project as a structured document โ Type Definitions, Inputs and Outputs, and each Blueprint listed in order with its interactive diagram embedded inline.
It replaces the old split between a "diagram page" and a "spec page". You read the project like a document, you edit Blueprints right where they appear, and when you want to focus on one Blueprint's diagram you maximize it in place โ see [Diagram view](/fundamentals/leapter-canvas/diagram-view).
![The Specification view showing a project as a structured document โ Type Definitions, Inputs and Outputs, and the Calculate Loan Application Scorecard blueprint with its diagram embedded inline]()
## What you see
The document is organized top to bottom:
| Section | What it contains |
| :--------------------- | :---------------------------------------------------------------------------------------------------------------------------------- |
| **Project header** | Project name and description |
| **Type Definitions** | All Value Types and Data Types defined at the project level โ see [Type Definitions](/fundamentals/leapter-canvas/type-definitions) |
| **Inputs and Outputs** | The project's inputs and outputs โ see [Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs) |
| **Blueprints** | Each Blueprint as its own section, with a name, description, numbered sub-sections, and an embedded interactive diagram |
The **Contents sidebar** on the left mirrors this structure as a navigable table of contents. Click any entry to scroll to it; double-click to maximize.
## Navigating the document
### Scroll, click, or jump
* **Scroll** through the document to read your project end to end.
* **Click** an entry in the Contents sidebar to jump to that section. The view scrolls smoothly and the entry is highlighted as the active section.
* The minimap docked to the right edge of the document gives you a compact overview of the whole project โ click anywhere on it to jump to that location.
### Maximize a Blueprint
Each Blueprint section has a **maximize** icon in its header. Click it (or double-click the Blueprint's entry in the Contents sidebar) to fill the canvas with that Blueprint's diagram.
While maximized:
* The Blueprint's name appears in the top toolbar as a pill.
* The right-edge toolbar gives you AI editing, the Lab Agent, undo / redo, and zoom controls โ see [Diagram view](/fundamentals/leapter-canvas/diagram-view).
* Click **Minimize** in the top toolbar to return to the full document.
## Editing in the Specification view
The Specification view is **fully editable**. You can:
* **Edit titles and descriptions** directly in the document โ section headings, Blueprint descriptions, and node labels are all click-to-edit.
* **Edit nodes inside the embedded diagram** โ every diagram in the document is interactive. Click a node to select it, double-click to edit. See [Inline editing](/fundamentals/change-your-blueprint/inline-editing).
* **Make a quick AI edit** โ select a section, a Blueprint, or nothing, then press **Ctrl+I** (or **Cmd+I** on Mac) to open the AI prompt for that scope. See [AI editing](/fundamentals/change-your-blueprint/ai-editing).
* **Build or edit with the Lab Agent** โ open the **Agent** tab and describe the change in plain language; the agent can build across Blueprints and run your tests. See [Lab Agent](/fundamentals/change-your-blueprint/lab-agent).
While the Blueprint is running or while AI is proposing changes, the document switches to read-only mode to prevent conflicting edits.
## Running Blueprints from the Specification view
Each Blueprint section has its own run controls. After a run, the **Outputs footer** at the bottom of the section shows the resulting output values, and the trace controls in the [top toolbar](/fundamentals/leapter-canvas/introduction#top-toolbar) become active so you can step through the execution.
Leave **[Live mode](/fundamentals/test-your-blueprint#live-mode)** running in the top toolbar and Leapter re-runs your Blueprints automatically every time you change inputs or logic โ the Outputs footer of every Blueprint updates as you edit.
## When the Specification view is most useful
| Use case | Why the Specification view helps |
| :------------------------------------- | :------------------------------------------------------------------------------------------------------------------- |
| **Onboarding to an existing project** | Read the project end to end as a document, with descriptions next to logic |
| **Reviewing logic before deployment** | The numbered sections make it easy to verify each rule |
| **Working across multiple Blueprints** | The Contents sidebar and Dependencies graph let you jump around without losing context |
| **Sharing with stakeholders** | Generate a [public read-only link](/fundamentals/sharing) โ non-technical readers see the same document you do |
| **Keeping spec and logic aligned** | Ask the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) to reconcile drift between descriptions and logic |
## What to do next
* **[Diagram view](/fundamentals/leapter-canvas/diagram-view)** โ focus on a single Blueprint's diagram
* **[Type Definitions](/fundamentals/leapter-canvas/type-definitions)** โ define reusable Value Types and Data Types
* **[Logic & Descriptions](/fundamentals/change-your-blueprint/sync-and-suggestions)** โ keep descriptions and logic in sync with AI
* **[Sharing](/fundamentals/sharing)** โ share your project as a public read-only link
# Type Definitions
Source: https://docs.leapter.com/fundamentals/leapter-canvas/type-definitions
Define reusable Value Types and Data Types at the project level so your inputs, outputs, and call signatures share a single source of truth.
Type Definitions let you describe data shapes once and reuse them across your project. They are defined at the project level โ every Blueprint in the project can reference the same types, and so can the project's [Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs).
You manage them from the **Type Definitions** entry at the top of the Contents sidebar in the [Blueprint Editor](/fundamentals/leapter-canvas/introduction). Double-click to open the dedicated Type Definitions editor.
![The Type Definitions editor in its empty state โ Define Value Type and Define Data Type buttons offer the two starting points]()
## Two kinds of type
Leapter has two flavors of type definition.
### Value Type
A **Value Type** is a constraint on a primitive value โ a string with a specific format, a number in a range, or an enumeration of allowed values.
Examples:
* `Email` โ a string that looks like an email address
* `PercentScore` โ a number between 0 and 100
* `Currency` โ an enum of `EUR`, `USD`, `GBP`
Use Value Types when you want a single name and a single set of rules for a value that appears in many places.
### Data Type
A **Data Type** is a structured record โ a named group of named fields, each with its own type. Data Types compose: a field on a Data Type can itself be a Value Type, another Data Type, or a list of either.
Examples:
* `Customer` โ a record with `id`, `name`, `email` (where `email` is the `Email` Value Type)
* `OrderLine` โ a record with `productId`, `quantity`, `unitPrice`
* `Order` โ a record with a `customer` (the `Customer` Data Type) and `lines` (a list of `OrderLine`)
Use Data Types to model the entities your project works with.
## Creating a type
1. Open the Type Definitions editor (double-click **Type Definitions** in the Contents sidebar).
2. Click **+ New** and choose **Define Value Type** or **Define Data Type**.
3. Give the type a name and configure it:
* For a **Value Type**, pick the base primitive (string, number, boolean, date) and add constraints (allowed values, regex, min / max).
* For a **Data Type**, add fields. For each field, pick its type โ primitive, an existing Value Type, an existing Data Type, or a list.
4. Add a description so the type's purpose is obvious to anyone reading the project.
## Using a type
Once defined, a type appears in every type-picker in the project:
* In **[Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs)**, when picking the type of an input or output.
* In a [Blueprint](/fundamentals/leapter-canvas/introduction)'s local variables, when picking the type of a local.
* In **[Call nodes](/fundamentals/leapter-canvas/calling-other-blueprints)**, when the called Blueprint expects an input or returns an output of this type.
Switch a parameter from a primitive type to one of your Type Definitions to give the runtime more information about the data โ and to make the spec readable: `Customer` tells the reader more than three separate `string` fields ever could.
## Why types help
* **One source of truth** โ change the rules once and every parameter that references the type updates with it.
* **Better AI generation** โ when you ask AI to [create](/fundamentals/create-blueprint/ai-prompt) or [edit](/fundamentals/change-your-blueprint/ai-editing) a Blueprint, named types let AI reason about your domain ("an `Order` has `lines`") rather than guess from primitives.
* **Better runtime validation** โ Value Type constraints reject malformed inputs at the boundary, before any logic runs.
* **Better readability** โ a Specification view that mentions `Customer` and `Order` reads like business prose; one full of `string`, `string`, `string` does not.
## Tips
* **Start without types.** New projects don't need them โ primitive inputs work fine. Reach for Type Definitions when you notice the same shape repeating.
* **Name them after domain concepts**, not implementation. `Customer` is better than `CustomerObject`; `Email` is better than `EmailString`.
* **Compose, don't duplicate.** If two Data Types share fields, extract a third type for the shared shape.
## What to do next
* **[Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs)** โ apply your types to the project's parameters
* **[Specification view](/fundamentals/leapter-canvas/specification-view)** โ see how types appear in the structured document
* **[Calling Other Blueprints](/fundamentals/leapter-canvas/calling-other-blueprints)** โ pass typed values between Blueprints
# Personal Profile
Source: https://docs.leapter.com/fundamentals/profile
Manage your Leapter profile โ update your display name and profile picture.
Your profile controls how you appear to other members in Leapter. You can update your display name and profile picture at any time.
## Access your profile
Click **Profile** in the left sidebar under **Settings**. This opens the profile settings page.
![The Profile settings page showing profile picture and name fields]()
## Update your profile picture
Your profile picture is displayed next to your name in workspace views and comments.
1. Click on your current profile picture (or the placeholder) to upload a new image.
2. Select an image file from your computer.
To remove your profile picture, click **Clear** next to the current image.
## Update your name
Your display name appears in comments, workspace member lists, and the profile menu.
1. Edit the name in the **Your Name** field.
2. Click **Update Profile** to save the change.
## What to do next
* **[Workspaces](/fundamentals/workspaces)** โ set up a workspace to share projects and collaborate with others
* **[Collaborating](/fundamentals/collaborating)** โ learn how to work together on shared Blueprints
# Projects
Source: https://docs.leapter.com/fundamentals/projects
Organize your Blueprints into projects โ create, browse, and manage your work in Leapter.
Projects are the top-level containers for your Blueprints. Every Blueprint belongs to a project, and you manage all your work through the Projects page.
## The Projects page
Click **Projects** in the left sidebar to open the Projects page. This is also the first screen you see after logging in.
Each project appears as a card showing:
| Element | Description |
| :------------------ | :---------------------------------------------------------------------------------------- |
| **Name** | The project name you chose when creating it |
| **Description** | The optional description (or "No description" if none was provided) |
| **Blueprint count** | How many Blueprints the project contains |
| **Blueprint names** | A preview of the Blueprint names inside the project |
| **Last updated** | When the project was last modified |
| **Globe icon** | Shown when the project has an active [public read-only share link](/fundamentals/sharing) |
You can **search** for projects by name using the search bar, or use **Filters** to narrow the list.
The **โฎ** menu on each card has **Edit Project**, **Share Project**, **Export Project**, and **Delete Project** entries โ **Share Project** opens the share dialog directly (see [Sharing](/fundamentals/sharing)).
## Create a project
Click **Create New** in the top-right corner of the Projects page. The **Create a Project** page opens.
![The Create a Project page with a prompt field, Create project button, and a link to start with an empty project instead]()
You have two options:
* **Describe your logic and let AI set up the project.** Type a description of what you want to build, then click **Create project**. Leapter creates the project, generates the Blueprints needed for the logic, and opens the editor.
* **Create an empty project.** Click **or create an empty project** below the prompt field. Enter a **Project name** (required) and an optional **Description**, then submit. Leapter creates the project and takes you straight to the [Create a Blueprint](/fundamentals/create-blueprint/ai-prompt) page so you can add your first Blueprint.
The new project appears on the Projects page once it's created.
## Open a project
Click a project card to enter it. The project opens directly into the [Blueprint Editor](/fundamentals/leapter-canvas/introduction) โ you see the [Specification view](/fundamentals/leapter-canvas/specification-view) with all the project's Blueprints listed in the Contents sidebar and their diagrams embedded inline.
There is no separate "blueprint list" page inside a project. To switch between Blueprints, use the Contents sidebar; to focus on one, double-click it to maximize. To add a new Blueprint, use the **+** affordance in the editor.
## Delete a project
1. Find the project on the Projects page.
2. Click the **three-dot menu** on the project card.
3. Select **Delete Project**.
Deleting a project removes it and all its Blueprints permanently. This action cannot be undone.
## What to do next
* **[Generate with AI](/fundamentals/create-blueprint/ai-prompt)** โ create your first Blueprint by describing your logic in natural language
* **[From Example Template](/fundamentals/create-blueprint/from-template)** โ start from a pre-built example Blueprint
* **[From Scratch](/fundamentals/create-blueprint/from-scratch)** โ create an empty Blueprint and build it yourself
# Sharing
Source: https://docs.leapter.com/fundamentals/sharing
Generate a public read-only link to a project so anyone can see your Specification view โ no Leapter account required.
Share a project as a **public read-only link** when you want someone to read its Specification โ a stakeholder reviewing a business rule, a teammate without a Leapter account, or a customer you want to walk through a calculation. Recipients see the same [Specification view](/fundamentals/leapter-canvas/specification-view) you do, with all the descriptions and diagrams, but cannot edit anything.
This is a separate path from the [deployment integrations](/executing-blueprints/introduction). Sharing exposes the project for **review**, not for execution from another system. To call your Blueprint from an application, use the [REST API](/executing-blueprints/connect-rest-api) or [MCP](/executing-blueprints/connect-mcp).
Public read-only sharing is rolling out behind a feature flag. If the **Link** option doesn't appear in your Share menu or in the project card's three-dot menu, the flag isn't enabled for your account yet.
## Open the share dialog
There are two ways to open the share dialog:
* From inside a project, click **Share** in the [top toolbar](/fundamentals/leapter-canvas/introduction#top-toolbar) and choose **Link**.
* From the [Projects page](/fundamentals/projects), click the **โฎ** menu on a project card and choose **Link**.
Under **General access**, the dialog has two states:
* **Private** (default) โ only workspace members can open the project. There is no public link.
* **Anyone with link** โ anyone who has the URL can open the project in read-only mode.
## Make a project public
1. Open the share dialog.
2. Under **General access**, switch from **Private** to **Anyone with link**.
3. Copy the generated URL.
4. Send the URL to the people you want to share with.
The URL opens the project's Specification view directly โ no sign-in step.
A **globe icon** appears next to the project name on the [Projects page](/fundamentals/projects) so you can tell at a glance which projects have an active public link.
## What recipients see
Visitors with the link see exactly what you see in the Specification view:
* Type Definitions, Inputs and Outputs, every Blueprint, and the Dependencies graph
* Each Blueprint's interactive diagram, embedded inline
* The full Contents sidebar for navigation
* The ability to **run** the Blueprint with their own input values, just like in [Live mode](/fundamentals/test-your-blueprint#live-mode)
What they **cannot** do:
* Edit any node, description, or heading
* Trigger AI editing or the Lab Agent โ the toolbar buttons that mutate the project are inert
* Add comments
* Open the deployment menu (Connect, n8n, Code, Embed are hidden)
If they have a Leapter account but aren't a member of the project's workspace, the same read-only experience applies; if they're a member of that workspace, full edit access returns.
## Stop sharing
Open the share dialog again and switch back to **Private**. The public URL stops working immediately โ anyone using it will get a 404. The same URL is reused if you re-enable the share later.
## Who can share
Managing a project's share is restricted to **owners** of the workspace the project belongs to โ see [Workspaces](/fundamentals/workspaces). Other members and anonymous visitors don't see the **Link** option.
## Tips
* **Reconcile before sharing.** Ask the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) to bring the descriptions in line with the logic, so the spec readers will see actually matches what you ship. See [Logic & Descriptions](/fundamentals/change-your-blueprint/sync-and-suggestions).
* **Use one share per audience.** If you need to share with multiple groups separately, that's not yet supported โ today's share is one public URL per project. If you need fine-grained control, keep the project private and add reviewers as workspace members.
* **Don't put secrets in input examples.** The shared view shows your project's structure and any default input values. Strip anything sensitive before turning the share on.
## What to do next
* **[Specification view](/fundamentals/leapter-canvas/specification-view)** โ the experience your share recipients see
* **[Logic & Descriptions](/fundamentals/change-your-blueprint/sync-and-suggestions)** โ keep your spec readable before you share
* **[Deploy & Integrate](/executing-blueprints/introduction)** โ for runtime integrations rather than review-only sharing
# Test Suites
Source: https://docs.leapter.com/fundamentals/test-suites
Create test suites to systematically validate your Blueprint โ manually or auto-generated with AI for maximum coverage.
A test suite is a collection of test cases that validate your Blueprint against different scenarios. Instead of manually running your Blueprint with one set of inputs at a time, test suites let you define multiple scenarios and run them all at once.
## Opening the Tests panel
Click the **Tests** button in the right sidebar of the editor to open the Tests panel.
![The Tests panel showing "No Test Suites" with Create Empty and Auto-Generate buttons]()
## Creating a test suite
You have two options:
### Auto-Generate with AI
Click **Auto-Generate** to let the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) analyze your Blueprint and create a comprehensive test suite automatically. It examines your logic โ decision branches, boundary conditions, error paths โ and generates test cases that cover each scenario.
For example, for the Loan Application Scorecard, the AI might generate tests like:
* **Strong applicant approved** โ high income and a clean credit history produce an Approve decision
* **Approve boundary** โ tests the boundary at totalScore = 60
* **Review band** โ tests a borderline score of 35 or more but below 60
* **High existing debt penalty** โ debt over 10,000 subtracts points
* **Clean credit bonus** โ a clean credit history adds points
* **Low income, short employment โ Decline** โ exercises the decline path
This is the fastest way to get thorough test coverage. The AI typically generates 8โ12 test cases that exercise all major paths through your Blueprint.
### Create Empty
Click **Create Empty** to start with a blank test suite, then add test cases manually using the **Add Test** button. This is useful when you want to test very specific scenarios or edge cases.
## Running tests
### Run all tests
Click **Run All** to execute every test case in the suite. The results appear immediately:
![Test suite results for the Loan Application Scorecard โ 6 tests at an 83% pass rate, grouped into negative, edge, and positive cases with Passed and Error statuses]()
The summary bar shows:
* **Total tests** โ how many test cases are in the suite
* **Passed** โ tests where the actual output matched the expected output
* **Failed** โ tests where the output didn't match
* **Pass rate** โ the percentage as a progress bar (e.g., 90%)
### Run individual tests
Each test case has its own **Run** button, so you can re-run a single test without running the entire suite.
## Understanding test results
Each test case shows one of three statuses:
| Status | Meaning |
| :----------------- | :-------------------------------------------------- |
| **Passed** (green) | The actual output matched the expected output |
| **Failed** (red) | The actual output differed from the expected output |
| **Not Run** (gray) | The test hasn't been executed yet |
### Investigating failures
When a test fails, it expands to show the **Output Mismatch** โ a table comparing the expected and actual values for each output field that differs.
For example, an "Approve boundary" test might show:
| Field | Expected | Actual |
| :------- | :------- | :----- |
| decision | Approve | Review |
This tells you exactly which output value was wrong and by how much, helping you pinpoint the issue in your logic.
You can also click **Run** on a failed test to execute it individually, then use the [trace controls](/fundamentals/test-your-blueprint#stepping-through-a-trace) to step through the execution and understand where the logic diverged from your expectations.
## Managing test suites
### Adding tests
Click **Add Test** in the test suite header to add a new test case manually. You define the input values and the expected output values.
### Adding tests with AI
Click the **Auto-Generate** (sparkles) button next to "Add Test" to have the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent) suggest additional test cases based on your Blueprint's logic. This is useful for improving coverage after you've already created a suite.
### Filtering tests
Use the **Filter** dropdown to show only specific test statuses:
* **All** โ shows every test
* **Passed** โ shows only passing tests
* **Failed** โ shows only failing tests
* **Not Run** โ shows tests that haven't been executed
## What to do next
* **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ run individual tests and use Replay to debug
* **[Inline Editing](/fundamentals/change-your-blueprint/inline-editing)** โ fix issues found during testing
# Test your Blueprint
Source: https://docs.leapter.com/fundamentals/test-your-blueprint
Set inputs in the Contents sidebar, run manually or with Live mode, and step through any execution to debug.
You test Blueprints directly in the [Blueprint Editor](/fundamentals/leapter-canvas/introduction). The Contents sidebar is the entry point: expand any Blueprint's parameters, set its input values, and run.
## Quick Run from the Contents sidebar
![The Contents sidebar with a blueprint expanded โ each input has a control for setting its value, and the outputs show their current values after a run]()
1. **Open the Contents sidebar** on the left of the editor.
2. **Click the `# N` badge** next to a Blueprint โ N is the count of its parameters. The Blueprint expands to show its inputs and outputs in line.
3. **Set values for the inputs.** Each input has a control matching its type โ a dropdown for enums, a number field for numbers, a text field for strings, and so on. Required inputs are marked.
4. **Run the Blueprint.** Either run it once, or leave [Live mode](#live-mode) running and the Blueprint re-runs automatically every time you change an input or edit the logic.
5. **Read the outputs.** Each output shows its current value next to its name in the Contents sidebar, and the **Outputs footer** at the bottom of the Blueprint's section in the document does too.
After a run:
* The **execution path** is highlighted on the embedded diagram, showing which branches and elements were visited.
* Each visited element shows a **step number** so you can see the order of execution.
* The **trace controls** in the [top toolbar](/fundamentals/leapter-canvas/introduction#top-toolbar) become active for stepping through the execution.
The Blueprint you set values on doesn't have to be the active [Execution Scope](/fundamentals/leapter-canvas/inputs-and-outputs#execution-scope-and-the-projects-external-interface) โ you can quick-run any Blueprint in isolation to test it.
## Live mode
![The execution path highlighted with step numbers on an embedded diagram, and the Outputs footer showing the current values (totalScore = 75, decision = Approve)]()
The **live-execution control** in the [top toolbar](/fundamentals/leapter-canvas/introduction#top-toolbar) is a **play / pause button** that runs your Blueprints continuously. While live execution is running (the button shows a pause icon), Leapter re-runs the Blueprint automatically every time you change an input value or edit the logic, and the Outputs footer of every section updates as you edit. Pause it to stop auto-running; resume it to turn continuous execution back on.
Live mode is most useful for:
* **Tweaking values** โ adjusting a threshold or rate and seeing every output update at once
* **Reviewing edge cases** โ flipping a boolean input and watching which branch becomes active
* **Pair-editing with AI** โ applying [AI changes](/fundamentals/change-your-blueprint/ai-editing) and confirming the outputs immediately
* **Reading an unfamiliar project** โ turn it on and you can see real values flowing through every Blueprint as you scroll the document
Pause it when you want to make several edits without intermediate runs.
## Stepping through a trace
![Top toolbar after a run โ the blueprint pill shows the successful execution and the trace controls (jump-first, previous, step counter, next, jump-last, step-into, step-out) are enabled for stepping through the execution]()
After any run, the **trace controls** in the [top toolbar](/fundamentals/leapter-canvas/introduction#top-toolbar) become active. They let you replay the execution one step at a time across every Blueprint that ran.
| Control | Action |
| :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Jump to first step** | Go to the first step of the trace |
| **Previous step** | Go back one step |
| **Step counter** | Shows the current step number โ click to jump to a specific step |
| **Next step** | Advance one step |
| **Jump to last step** | Go to the final step |
| **Step into** | When the current step is on a [Call node](/fundamentals/leapter-canvas/calling-other-blueprints), descend into the called Blueprint and continue stepping there |
| **Step out** | When you're inside a sub-Blueprint, return to the parent and continue stepping there |
| **Exit trace** | Exit replay mode and return to editing |
While stepping, the active node is highlighted on whichever diagram contains it. Variable values at the current step are visible on the embedded diagram and in the Outputs footer.
The editor is **read-only** while a trace is active โ exit the trace to resume editing.
### Autoplay
The trace toolbar also has a **play / pause** button and a **playback speed** control for animating through the trace automatically:
* **Play** โ auto-advance through every step in order. The button toggles to a pause icon while running.
* **Pause** โ stop the auto-advance at the current step. The button toggles back to the play icon.
* **Speed** โ adjust how fast autoplay moves through the trace.
Autoplay pauses on its own as soon as you take manual control โ clicking a step in the diagram, hitting prev / next, jumping to start or end, or stepping in or out. It also pauses automatically when the trace reaches its last step.
The same play / pause + speed controls appear in [embedded viewers](/executing-blueprints/embed) (where you can opt-in via the `autoplay` attribute on ``) and in [public read-only shares](/fundamentals/sharing).
## What to do next
* **[Test Suites](/fundamentals/test-suites)** โ create and auto-generate test suites for systematic testing
* **[Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs)** โ see how Blueprint signatures work
* **[Logic & Descriptions](/fundamentals/change-your-blueprint/sync-and-suggestions)** โ let AI catch drift between your descriptions and your logic
# Change Workflow
Source: https://docs.leapter.com/fundamentals/track-changes/change-workflow
Choose how edits to a project are saved โ applied immediately, or held as pending changes on a draft until you save them.
Every project has a **change workflow** that decides what happens when you edit it. You can let edits apply immediately, or hold them as pending changes on a **draft** so you can review before they reach everyone. The workflow you choose changes what you see in the editor โ including whether drafts and the [Review & Delivery](/fundamentals/track-changes/review-and-approvals) tools are available at all.
## Where to find the change workflow
The change workflow is a **per-project** setting:
1. Go to the **Projects** page.
2. Click the **โฎ** menu on the project card.
3. Select **Settings**.
4. Open the **Change Workflow** tab.
![The project Change Workflow settings with the workflow dropdown open, showing Saved directly, Pending changes + Save, and two Git-based options that require a Git integration]()
## The workflow options
| Workflow | What it does |
| :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Saved directly** | Every edit updates the saved version immediately. There is no Save button. |
| **Pending changes + Save** | Edits stay as pending changes on a draft until you save them. [Approval rules](/fundamentals/track-changes/review-and-approvals) can require review first. |
| **Saved directly + Git** | Like *Saved directly*, but changes are also delivered to a connected Git repository. **Requires a Git integration.** |
| **Pending changes + Git PR** | Like *Pending changes + Save*, but saving opens a pull request in a connected Git repository. **Requires a Git integration.** |
The two Git options are unavailable until a Git integration is connected for the project.
New projects start on **Saved directly**.
## Saved directly
In **Saved directly** mode, editing *is* saving. Each change you make โ by hand, with the [Lab Agent](/fundamentals/change-your-blueprint/lab-agent), or with [Ctrl+I](/fundamentals/change-your-blueprint/ai-editing) โ updates the project's saved version straight away and appears on the [Timeline](/fundamentals/track-changes/timeline) as a new change on **main**.
This is the fastest way to work, and it is a good fit when you are exploring on your own. There are no drafts and no Save step, so the **New draft** action and the Review & Delivery tools are not shown.
## Pending changes + Save
In **Pending changes + Save** mode, your edits are collected on a **draft** โ a separate stream that forks from main โ and are not visible to the rest of your team until you save. This gives you a place to work through a change, test it, and (optionally) have it reviewed before it lands.
### Create a draft
With this workflow active, a **+ New draft** action appears at the top of the [Timeline](/fundamentals/track-changes/timeline) panel. Click it to start a draft. Leapter names the draft for you and switches you onto it โ the stream indicator at the bottom of the editor shows which draft you are on.
### Work on the draft
Edit as usual. Every change you make now belongs to the draft, not to main. You can switch back to main at any time from the Timeline, and switch between streams to compare.
### Save the draft to main
When the draft is ready, save it. Leapter merges your draft's changes into main as a new version for everyone, and the Timeline records an **Apply *\*** entry showing where the draft merged back.
Saving runs through the **Review & Delivery** panel, where any [approval rules](/fundamentals/track-changes/review-and-approvals) are checked first. See [Review & Approvals](/fundamentals/track-changes/review-and-approvals) for the full flow.
Changing a project's workflow does not touch its history. Switching from *Saved directly* to *Pending changes + Save* simply makes drafts available from that point on.
## What to do next
* **[Review & Approvals](/fundamentals/track-changes/review-and-approvals)** โ assign reviewers and require checks before a draft reaches main
* **[Timeline](/fundamentals/track-changes/timeline)** โ follow drafts and applies in the change graph
* **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ verify a draft before you save it
# Review & Approvals
Source: https://docs.leapter.com/fundamentals/track-changes/review-and-approvals
Gate changes before they reach main โ assign reviewers, require checks like four-eyes approval or passing tests, and save a draft with confidence.
When a project uses the **Pending changes + Save** [change workflow](/fundamentals/track-changes/change-workflow), saving a draft to main runs through **Review & Delivery**. This is where you see what changed, assign reviewers, and satisfy any **approval rules** the project requires before the change can land โ the controls that let a regulated team prove every change was checked before it went live.
## Prerequisites
* The project's [change workflow](/fundamentals/track-changes/change-workflow) is set to **Pending changes + Save** (or the Git PR variant).
* You are working on a **draft** with at least one pending change.
## The Review & Delivery panel
While you are on a draft, the **Review & Delivery** panel appears at the bottom of the editor.
![The Review & Delivery panel showing What's changed, a Reviewers section with Assign reviewer, a Checks section, and Review, Save, and Discard actions]()
| Section | What it shows |
| :----------------- | :------------------------------------------------------------------------------------------------------------- |
| **What's changed** | A summary of the updates on this draft since the last saved version |
| **Reviewers** | Who is reviewing the draft, and whether their approval is required โ assign reviewers with **Assign reviewer** |
| **Checks** | The [approval rules](#approval-rules) that apply to this draft and whether they pass |
| **Actions** | **Review** the changes in detail, **Save** the draft to main, or **Discard** it |
Saving prompts you to confirm โ it applies your pending changes as the new version for everyone.
## Approval rules
Approval rules gate a draft's readiness to reach main. You set them per project, in the same **Change Workflow** settings where you choose the [workflow](/fundamentals/track-changes/change-workflow), under **Review rules**.
![The Review rules list with Four-eyes approval enabled, showing its Enforce toggle, minimum approvals, exclude-author, and require-assigned-reviewers options]()
Each rule can be set to **Enforce** or left as advisory:
* **Enforce** โ the rule **hard-gates** apply-to-main. The draft cannot be saved until the rule passes.
* **Advisory** โ the rule only **warns**. It surfaces a problem but does not block saving.
### Available rules
| Rule | What it checks |
| :---------------------------- | :------------------------------------------------------------------------------------- |
| **Four-eyes approval** | A minimum number of non-stale approvals, optionally from someone other than the author |
| **Test execution success** | The project's [test suites](/fundamentals/test-suites) pass |
| **Review comment resolution** | Open [review comments](/fundamentals/collaborating) have been resolved |
| **AI semantic validation** | An AI check of whether the change is internally consistent |
| **Test coverage threshold** | Test coverage meets a set minimum |
| **Syntax validation** | The Blueprint is structurally valid |
Enable a rule to configure it. For example, **Four-eyes approval** lets you set:
* **Minimum approvals** โ how many approvals are needed
* **Exclude author** โ approvers must differ from the stream author, so no one can approve their own work
* **Require assigned reviewers** โ every assigned reviewer must approve before the rule passes
## Save a reviewed draft
1. On the draft, open the **Review & Delivery** panel.
2. Check **What's changed** and, if needed, click **Review** to inspect the diff.
3. Assign reviewers under **Reviewers** if the project requires approval.
4. Make sure every enforced rule under **Checks** passes.
5. Click **Save** and confirm.
Leapter merges the draft into main and records an **Apply *\*** entry on the [Timeline](/fundamentals/track-changes/timeline).
With **Four-eyes approval** enforced and **Exclude author** on, you cannot approve your own draft โ a second team member has to. Make sure your project has more than one member before enforcing it, or you will not be able to save.
## What to do next
* **[Change Workflow](/fundamentals/track-changes/change-workflow)** โ the setting that turns on drafts and this review flow
* **[Timeline](/fundamentals/track-changes/timeline)** โ see applied drafts and every version in the change graph
* **[Collaborating](/fundamentals/collaborating)** โ leave and resolve review comments on Blueprints
# Timeline
Source: https://docs.leapter.com/fundamentals/track-changes/timeline
See every change to a project over time โ who changed what, when, and on which stream โ and restore an earlier version whenever you need to.
The Timeline is your project's change history. It records every version of the project as a change you can inspect, compare, and restore โ so you always know how the logic reached its current state, and you can go back if you need to.
## Where to find the Timeline
Open the **Timeline** tab in the right sidebar of the [Blueprint Editor](/fundamentals/leapter-canvas/introduction). It sits alongside Tests, Agent, Prod Runs, and Comments.
![The Timeline panel showing a multi-lane change graph with branch pills, apply entries, and struck-through closed drafts]()
Each row is one change, newest at the top. The panel shows:
| Element | Description |
| :--------------- | :-------------------------------------------------------------------------------------------------------------- |
| **Change title** | A short summary of what happened โ for example *Apply zen\_bohr* or *Create project* |
| **Branch pill** | A colored label (such as **main** or **draft / โฆ**) marking which stream the change belongs to |
| **Graph** | The colored line on the left connects related changes and shows where drafts fork from and merge back into main |
| **Time** | When the change was made, shown as a relative time (*3h ago*) |
The collapsed list does **not** show who made each change. To see the author, open the change card.
## Streams and the change graph
A **stream** is a line of changes. Every project has a **main** stream, and โ depending on your [change workflow](/fundamentals/track-changes/change-workflow) โ you can also create **drafts**, which are separate streams that fork from main and merge back when saved.
The graph makes this visible:
* **Fork baseline** marks where a draft branched off main.
* **Apply *\*** marks where a draft's changes were merged back into main.
* **Closed streams are struck through** โ once a draft has been applied, its history stays visible but is crossed out.
Each stream has its own color, so you can follow a draft from where it forked to where it merged.
## Open a change to see the detail
Click any change to expand its card.
![An expanded change card showing the author, timestamp, project version, and the View conversation, Open this version, and Restore this version actions]()
The card shows:
* **What happened** โ a description and status badges (for example **Applied to main**), the origin of the change, and the stream it belongs to
* **Who and when** โ the author, the exact timestamp, and the **project version** the change produced
* **Actions** โ inspect, restore, or compare the change
Timestamps in the collapsed list are rounded (*3h ago*). The exact time โ down to the minute โ is only shown in the expanded card. Two people working minutes apart can look like a single moment until you open the cards.
### Actions on a change
| Action | What it does |
| :----------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- |
| **View conversation** | Opens the Lab Agent transcript that produced this change, when one exists โ so you can read the reasoning behind an edit, not just the result |
| **Open this version** | Loads the project as it looked at this change, read-only, so you can look around without altering anything |
| **Restore this version** | Brings the project back to this state |
### Compare changes
Use the **Compare** section of a change card to see exactly what a change altered:
* **Compare with previous** โ diff this change against the one before it
* **Compare with target stream** โ on a draft, diff it against the stream it will merge into (usually main)
* **Select for compareโฆ** โ pick this change as one side of a comparison, then choose another change (or another stream) as the other side
### Reading a comparison
Once you pick two versions, the editor enters **compare mode** and shows the difference between them.
![The compare view โ the version header main v3 to main v4, the document with an inline diff on the Determine Lending Decision section, and the Diff Summary listing the changes]()
* The header names the two versions being compared โ for example **main v3 โ main v4**.
* The document highlights every change **in place**: removed values are struck through in red, added values are highlighted in green. In the example above, the Approve threshold changes from `60` to `65`.
* The **Diff Summary** at the bottom lists every change, grouped by Blueprint and element, with a count of what was added, changed, or removed.
Click **Close compare** to leave compare mode and return to the current version.
## Restore an earlier version
If a change introduced a problem, you can roll the project back:
1. Open the change you want to return to.
2. Click **Restore this version**.
Restoring brings the project back to how it looked at that change. Leapter records the restore as a **new** entry at the top of the Timeline, so the history in between is never lost โ you can always move forward again.
## What to do next
* **[Change Workflow](/fundamentals/track-changes/change-workflow)** โ choose how edits are saved, and turn on drafts for safer changes
* **[Review & Approvals](/fundamentals/track-changes/review-and-approvals)** โ require review before changes reach main
* **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** โ the conversations behind your changes, available from **View conversation**
# Workspaces
Source: https://docs.leapter.com/fundamentals/workspaces
Every project in Leapter lives in a workspace. Create workspaces, invite members, and manage roles to collaborate on shared projects.
A **workspace** is where your projects live and where you collaborate. Everything you create in Leapter โ projects, Blueprints, tests โ belongs to a workspace, and everyone you invite to that workspace can work on it together.
You can belong to several workspaces and switch between them at any time. Each keeps its own projects, members, and settings.
## Switch workspaces
The **workspace switcher** sits at the bottom of the left sidebar, showing the current workspace's name. Click it to see every workspace you belong to and switch between them โ the sidebar and Projects page update to the workspace you pick.
## Create a workspace
1. Click the **workspace switcher** at the bottom of the sidebar.
2. Select **Create a Workspace**.
3. Enter a **Workspace Name** โ something your members will recognize.
4. Click **Create Workspace**.
![The Create Workspace dialog with a Workspace Name field]()
Leapter switches you into the new workspace. You can now create projects and invite members.
## Invite members
1. Switch to the workspace you want to manage.
2. Click **Members** in the settings sidebar.
3. Click **Invite Members**.
4. Enter the member's **email address**.
5. Select a **role**: **Owner** or **Member**.
6. Click **Send Invites**.
![The Invite Members dialog with email and role fields]()
You can invite several people at once by adding another row before sending.
## Manage members
The **Members** page lists everyone in the workspace:
![The Members page showing workspace members and their roles]()
| Column | Description |
| :------------ | :--------------------------------- |
| **Name** | The member's display name |
| **Email** | The email on their Leapter account |
| **Role** | Owner or Member |
| **Joined at** | When they joined the workspace |
Below the table, **Pending Invites** shows invitations that haven't been accepted yet, with their status and expiry.
## Roles
| Role | What they can do |
| :--------- | :----------------------------------------------------------------------------------------------------------------------------------------- |
| **Owner** | Full access โ manage workspace settings, invite and remove members, enable [integrations](/fundamentals/integrations), and manage projects |
| **Member** | Create and edit projects and Blueprints in the workspace |
The person who creates a workspace is its **Primary Owner**. Changing the workspace's name or logo is restricted to owners.
## Workspace settings
Click **Settings** in the sidebar to manage the workspace's identity (owners only):
* **Workspace Name** โ the display name shown in the switcher
* **Workspace Logo** โ an image to make the workspace easy to recognize
![The workspace Settings page showing the name and logo fields]()
## What to do next
* **[Collaborating](/fundamentals/collaborating)** โ work together on shared Blueprints with comments
* **[Integrations](/fundamentals/integrations)** โ connect external tools for the Lab Agent to use
* **[Sharing](/fundamentals/sharing)** โ share a project read-only with someone outside the workspace
* **[Personal Profile](/fundamentals/profile)** โ update your own display name and picture
# Key Concepts
Source: https://docs.leapter.com/get-started/key-concepts
A guided overview of how Leapter works โ from Blueprints and Projects to testing, deploying, and collaborating.
This page walks you through the core ideas behind Leapter, following the journey from creating your first Blueprint to deploying it in production. Each section links to the detailed documentation where you can learn more.
Build a Blueprint with AI, from a template, or from scratch
Modify your logic inline or with AI assistance
Run your Blueprint and verify it works correctly
Connect via API, export to n8n, embed, or generate code
## Blueprints
A **Blueprint** is the central building block in Leapter. It is a visual, executable representation of your business logic โ displayed as a flowchart-like diagram that you can run, test, and deploy.
Unlike logic written inside AI prompts, a Blueprint executes **deterministically**: the same inputs always produce the same outputs. This makes Blueprints reliable enough for billing, compliance, risk calculations, and any other scenario where "close enough" is not acceptable.
## Projects
A **[Project](/fundamentals/projects)** is a container that groups related Blueprints together. For example, a **Loan Decisioning** project might contain Blueprints for application scoring, affordability checks, and risk rating.
One Blueprint in a project is the active **Execution Scope** โ the entry point that runs when the project is invoked from outside. Its [signature](/fundamentals/leapter-canvas/inputs-and-outputs) is the project's external interface, exposed to the [REST API](/executing-blueprints/connect-rest-api), [MCP](/executing-blueprints/connect-mcp), and other integrations. The other Blueprints in the project are reusable sub-routines that the Execution Scope calls via [Call nodes](/fundamentals/leapter-canvas/calling-other-blueprints).
Projects are also the unit of sharing โ every project lives in a [workspace](/fundamentals/workspaces), and all workspace members can access its projects and the Blueprints inside them. To share a project read-only with someone outside your workspace, generate a [public link](/fundamentals/sharing).
## Creating a Blueprint
Leapter gives you three ways to create a Blueprint:
* **[Generate with AI](/fundamentals/create-blueprint/ai-prompt)** โ describe your logic in plain language and Leapter builds the full Blueprint for you. This is the fastest way to get started.
* **[From Example Template](/fundamentals/create-blueprint/from-template)** โ start from a pre-built example (like a pricing calculator or greeting logic) and customize it.
* **[From Scratch](/fundamentals/create-blueprint/from-scratch)** โ create an empty Blueprint and build every node yourself.
## The Blueprint Editor
The **[Blueprint Editor](/fundamentals/leapter-canvas/introduction)** is a single workspace where you build, inspect, and run every Blueprint in your project. The editor opens directly into a structured document โ the **[Specification view](/fundamentals/leapter-canvas/specification-view)** โ that shows your project's [Type Definitions](/fundamentals/leapter-canvas/type-definitions), [Inputs and Outputs](/fundamentals/leapter-canvas/inputs-and-outputs), and each Blueprint with its interactive diagram embedded inline.
To focus on a single Blueprint, you maximize it in place and the canvas fills with its **[Diagram view](/fundamentals/leapter-canvas/diagram-view)**. There is no separate "diagram page" โ the diagram view is just one mode of the same editor.
## Blueprint Elements
Blueprints are made up of different types of nodes, each with a specific purpose. Here is a real Blueprint showing several element types working together โ a Call node and an Assignment node (blue/purple), Decision nodes (yellow), and a Return node (green), organized into group boxes:
![The Calculate Loan Application Scorecard Blueprint showing a Call node to a sub-Blueprint, an Assignment node, Decision nodes, a Return node, and group boxes]()
| Element | What it does |
| :------------- | :------------------------------------------------------------------------------------ |
| **Assignment** | Performs calculations and stores results in variables |
| **Decision** | Creates conditional branches โ routes the flow based on true/false conditions |
| **Loop** | Repeats a section of logic (over items, with a counter, or while a condition is true) |
| **Return** | Ends execution โ either successfully or with an error |
| **Call** | Calls another Blueprint as a sub-routine, enabling modular, reusable logic |
Learn more in [Controlling the Flow](/fundamentals/leapter-canvas/controlling-the-flow) and [Calling Other Blueprints](/fundamentals/leapter-canvas/calling-other-blueprints).
## Editing a Blueprint
Once a Blueprint exists, you can modify it several ways:
* **[Lab Agent](/fundamentals/change-your-blueprint/lab-agent)** โ open the **Agent** tab and describe the change in plain language. The agent builds and edits across your Blueprints, runs your tests, and proposes changes for you to approve. This is the main way to make AI-assisted changes.
* **[Inline Editing](/fundamentals/change-your-blueprint/inline-editing)** โ click on any node, description, or heading to edit it in place.
* **[AI Editing](/fundamentals/change-your-blueprint/ai-editing)** โ select a node, press **Ctrl+I** (**Cmd+I** on Mac), and describe a quick, scoped change in natural language.
* **[Logic & Descriptions](/fundamentals/change-your-blueprint/sync-and-suggestions)** โ the descriptions you write and the logic in your diagrams describe the same thing; when they drift apart, ask the Lab Agent to bring them back in line.
## Testing
Before deploying, you can verify your Blueprint works correctly:
* **[Test your Blueprint](/fundamentals/test-your-blueprint)** โ run your Blueprint with sample inputs directly in the editor and inspect the outputs step by step.
* **[Test Suites](/fundamentals/test-suites)** โ create reusable sets of test cases that you can run repeatedly to catch regressions. You can also auto-generate test cases with AI.
## Deploying
Once tested, you can connect your Blueprint to the outside world through multiple channels:
| Method | Description |
| :----------------------------------------------------------- | :----------------------------------------------------------------------------------------------------- |
| **[AI Protocol (MCP)](/executing-blueprints/connect-mcp)** | Connect AI assistants like Claude Desktop or Cursor to your Blueprint using the Model Context Protocol |
| **[Web API (REST)](/executing-blueprints/connect-rest-api)** | Call your Blueprint through a standard REST API from any application |
| **[n8n Workflows](/executing-blueprints/n8n-http)** | Export ready-made n8n workflows that call or embed your Blueprint logic |
| **[Export as Code](/executing-blueprints/export-code)** | View your Blueprint transpiled to JavaScript or Python |
| **[Embed in Websites](/executing-blueprints/embed)** | Embed an interactive, read-only Blueprint viewer in any webpage |
All API-based integrations require an **[API Key](/fundamentals/api-keys)** for authentication.
After deployment, you can monitor executions in the **Prod Runs** panel inside the editor โ see inputs, outputs, and replay any run. Learn more in [Deploy & Integrate](/executing-blueprints/introduction).
## Teams and Collaboration
Leapter supports working together through **[Workspaces](/fundamentals/workspaces)**. Create a workspace, invite members, and share projects. Inside shared projects you can use **[Comments](/fundamentals/collaborating)** to discuss specific nodes, mention members, and track open feedback. To share a project with someone outside your workspace, generate a **[public read-only link](/fundamentals/sharing)** โ the recipient sees the same Specification view you do, no account required.
## What to do next
Ready to build? Head to **[Generate with AI](/fundamentals/create-blueprint/ai-prompt)** to create your first Blueprint in minutes.
# What is Leapter
Source: https://docs.leapter.com/get-started/what-is-leapter
Leapter is an agentic development platform for business logic โ describe your rules in plain language, get executable diagrams your team can inspect, test, and approve before they run deterministically in production.
**Agentic when you build. Deterministic when it runs.**
AI builds software fast โ but the **business logic** disappears into code that only developers can read. Leapter makes that logic **visible and changeable**.
You describe the rules your software needs in plain language. Leapter's AI turns them into **executable diagrams** โ called **Blueprints** โ that your team can inspect, test, refine, and approve *before* they ever run in production. At runtime, those Blueprints execute **deterministically**: there is no language model in the live decision path, so the same inputs always produce the same outputs.
![The Blueprint Editor showing the Loan Application Scorecard โ the Contents sidebar, the project's Blueprint, and its logic as executable diagrams with decision branches and assignments]()
## The problem with probabilistic logic
When multi-step business logic is executed by a probabilistic model, even a small per-step error rate โ *drift across steps* โ quickly compounds into an unacceptable failure rate. When the outcome truly matters โ **billing, compliance, risk, pricing** โ "close enough" is not acceptable.
This is an architectural problem, not a prompting problem: you are relying on a probabilistic tool to do a deterministic job. It forces teams to babysit AI automations with human review, which prevents them from safely scaling into production.
## What Leapter gives you
Leapter reverses the control. Instead of asking an agent to *invent* the logic each time, **you** define it once as a visual, executable Blueprint โ and it runs the same way every time.
| Pillar | What it means |
| :-------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Readable logic** | Business rules stay visible as executable diagrams, not buried in code. Domain experts can read, design, and own them without waiting on developers. |
| **Traceable logic** | Every decision is auditable. You can trace each branch that led to an outcome โ built-in evidence for compliance and debugging. |
| **No AI in live decisions** | Blueprints run deterministically. The AI helps you *build*; it never sits in the live execution path, so there is no LLM uncertainty when the logic runs. |
## Who it's for
* **Heads of Compliance & Risk** โ auditable, deterministic decisions you can defend.
* **Domain experts** โ own and approve the rules in plain language, without code.
* **CIOs & Heads of AI** โ put agentic automation into production safely.
* **Engineering leaders** โ stop hand-coding and babysitting brittle business logic.
## New to Leapter? Your next steps
| Next step | Goal |
| :--------------------------------------------------------------- | :---------------------------------------------------------------------------------------------- |
| **[Key Concepts](/get-started/key-concepts)** | Understand the building blocks โ Blueprints, nodes, inputs, outputs, and how they fit together. |
| **[Generate with AI](/fundamentals/create-blueprint/ai-prompt)** | Build your first Blueprint in minutes by describing your logic in plain language. |
| **[Deploy & Integrate](/executing-blueprints/introduction)** | Connect your Blueprint to AI agents, REST APIs, n8n workflows, and more. |