AIP Logic Getting started

Getting started with AIP Logic – a quick guide to opening the tool, building a Logic function with LLM blocks, and inspecting the LLM’s chain‑of‑thought (CoT) in the Debugger.

AIP Logic can be opened from the platform’s workspace navigation bar or via the quick‑search shortcuts CMD + J (macOS) / CTRL + J (Windows).
You can also create a new Logic function from Files → +New → AIP Logic, as shown below.

Create new AIP Logic window.

Note: Logic files must be saved in a project folder, not in your home folder.

The interface consists of three main components (left‑to‑right in the screenshot):

1. Inputs, blocks, and outputs configuration – see the Inputs, blocks, and outputs configuration section.
2. Debugger – displays the LLM’s CoT and lets you inspect each step.
3. Run panel – runs the Logic, shows recent runs, and lets you create unit tests.

AIP Logic interface

A typical workflow:

1. Configure inputs (A), blocks (B), and outputs (C) on the left panel.
2. Use the Run panel (right) to generate a sample output.
3. Inspect the LLM’s chain‑of‑thought in the Debugger and view the steps taken.
4. Optionally visualize the final output in the Debugger combined with the Run panel.
5. Use the right‑hand sidebar for extra functionality, such as integrating Logic with the Automate application.

When you first open AIP Logic, the Run panel appears on the right while three boards appear on the left:

• Inputs – choose an object and its properties (or none).
• Blocks – define the Logic instructions.
• Outputs – specify the desired result of the Logic function.

The output of one block can be fed into subsequent blocks.

Input, blocks, and Output configuration view.

The Inputs board (label “A” in the interface guide) lets you name an input and select its type. Supported types include:

• array, boolean, date, double, float, integer, long, media reference, model, object, object list, object set, short, string, struct, timestamp

A Logic function is composed of blocks (label “B”). Common block types:

• Create variable – [create variable]
• Apply action – [apply action]
• Execute function – [execute function]
• Use LLM – [use LLM]

The output of a block can be used by later blocks. Detailed block documentation is available under Blocks.

Outputs are defined for each block and for the overall Logic function (label “C”).

• Block output – intermediate values passed between blocks (primitive or object).
• Logic function output – the final value returned by the function, either a Value (primitive/object) or the set of Ontology edits made by the function.

After composing a Logic function, click Run on the right. The Debugger opens and displays the LLM’s chain‑of‑thought (CoT).

Debugger view with example.

Features:

• Expand/collapse block cards
• Clear tool calls
• Review generated prompts for easier interpretation of the CoT

The Run panel lets you:

• Execute and evaluate your Logic
• Review recent runs and run history
• Set unit tests
• Launch automations (via Automate)

Run view with flight example in result box.

At the bottom, select any recent run to view its output and debug log.

Run and Run history view

Click the unit tests icon (Unit tests icon.) to save a version of your input for performance evaluation.

Unit tests examples featuring notional flight changes.

Logic functions behave like regular functions on objects (FoO).

• Back an action – call the Logic function from a Workshop action.

  Create a new action type window with function and inputs selected from dropdown menus.

• Back a Markdown widget – the Logic function’s output must be a string.

  Example showing Markdown widget setup popover in Workshop application.

• Call from other Logic functions – use the Ontology function tool within AIP Logic.

In the Uses tab, copy the generated curl request to run the Logic outside of Foundry. (Not available for Logics that return ontology edits.)

Command line request

When a Logic function proposes Ontology edits, they appear in the Debugger but are not applied automatically. To apply edits:

1. Call the Logic function from an action or from an automation (create a new automation via the Automations Automate icon option).

2. Ensure the Logic function includes an Apply actions tool inside a Use LLM block, enabling the LLM to edit the Ontology.

   Example showing Apply actions tool with prompt to "Make changes to the flight as described" where an action has been preselected from a dropdown menu.

3. After finalizing the Logic, select Publish next to Save.

4. Create a new action backed by the published Logic function.

   Example of wrapping your logic function into an action.

5. Use the new action in a Workshop module to power an operational workflow.

   Workshop configuration panel with Flight Change action selected from dropdown.

The Version history tab lets you compare two Logic versions, highlighting added, removed, or edited blocks.

Logic comparison

If you have access to AIP Logic:

• Experiment with LLM blocks to interact with your Ontology.
• Build a use case tailored to your domain.
• Review the platform’s Functions documentation for deeper integration.

• AIP Logic is accessed via the workspace bar, quick‑search, or Files → +New.
• The interface centers on Inputs/Blocks/Outputs, a Debugger, and a Run panel.
• Blocks can be chained; their outputs feed subsequent blocks.
• The Debugger visualizes the LLM’s chain‑of‑thought, aiding troubleshooting.
• To apply Ontology edits, embed an Apply actions tool in a Use LLM block and run the Logic from an action or automation.