> For the complete documentation index, see [llms.txt](https://docs.autommate.com/userguide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.autommate.com/userguide/mcp-and-ai-reference/native-app-trigger-and-data-discovery.md).

# Discover native apps, triggers and data

Find the installed application, reusable action and supported event before creating a new integration. Read the actual contracts and preserve their scope. A familiar app name is not proof that a particular action, event or lookup exists in the connected environment.

**Scope:** This guide uses Autom Mate New declarations and read-only discovery observed on **21 October 2026**. Availability depends on the connected account, tenant and installed library versions. The examples below do not prove execution or availability in every installation.

## Follow the discovery chain

```mermaid
flowchart TD
    A[Business outcome and active context] --> B[Find application and installed libraries]
    B --> C[Find reusable actions and Work Items]
    C --> D[Inspect inputs and outputs]
    D --> E[Discover native event]
    D --> F[Inspect Data Manager configuration]
    F --> G{Actual source data needed?}
    G -->|Yes| H[Authorized native read or documented API read]
    G -->|No| I[Resolve known context and mappings]
    H --> I
    E --> I
    I --> J[Build a reviewed service plan]
```

### 1. Find the application and library

Use `applications_search` to resolve the application ID and visible deployment/status information. Use `libraries_search` to inspect integrations available in the current context. A platform application and a library action are different objects; do not substitute their IDs.

Search existing Hyperflows, Work Items and Services as appropriate. Reuse a reviewed component when its behavior and contract satisfy the task. Avoid creating another integration merely because the first search returned no exact name match; inspect pagination and scope notes.

### 2. Read the action contract

Find actions with `library_search_actions`, then pass the returned `action_ref` to `library_get_action`. Keep the exact reference; display labels alone are not identifiers.

Read required inputs, their types, declared defaults and outputs. An empty declared input list differs from an unavailable contract. Do not infer output properties from an output variable named `output` or from the action name.

For example, a read-only discovery of a Jira Create Issue action returned required `summary`, `issuetype` and `project` inputs, plus an Object output. That metadata alone did not establish the valid project choices, issue-type dependencies or output property schema. Resolve these from a supported source before generating mappings.

### 3. Keep canonical identifiers distinct

Some operations consume an `action_ref`; Data Manager tools consume an `action_id`. Library and library-version IDs have separate purposes. Use only identifiers returned by the supported discovery route.

If an action contract does not return the canonical ID needed by the next tool, inspect the supported version/action listing. If that route does not provide it, identify the missing reference and stop that dependent step. Do not manufacture a UUID, convert a label into an ID or create a duplicate action to obtain a new ID.

A read-only sample on 21 October found an existing Jira action, but its action response did not provide the `action_id` required for Data Manager inspection; the inspected store listings also lacked version rows. This establishes a limit of that discovery path, not absence of the action or Data Manager in the product.

## Discover an event before designing a trigger

Use `trigger_events_search` for the actual application or library version. Inspect:

* Delivery mode and supported trigger modes.
* Whether registration is automatic, manual or not applicable.
* Setup fields, required values, dependent options and help cards.
* Available sample payload fields and their limitations.

For an advertised event, follow `automs_set_trigger` and its current schema. The event determines App Trigger mode; do not invent a hybrid mode. Check verification status where webhook verification is pending. Saving a trigger can register it in the external application, so review that side effect before apply.

**Scoped example:** The Jira event search in the 21 October read-only check returned no events. An Xurrent application result also reported `has_trigger_events: false`. This means those reads did not establish an available native event in that context. It does not prove that all installations, library versions or product interfaces lack one.

When no suitable event is visible, explain the gap and choose only a documented, authorized alternative. Do not claim that a `saas` Service Engage label connects an arbitrary application event. Confirm how the supported event or caller reaches the Service.

## Data Manager configuration is not a lookup result

| Tool                          | What it establishes                                                                   |
| ----------------------------- | ------------------------------------------------------------------------------------- |
| `data_manager_get`            | The stored wizard model for an action; advanced unknown keys can be read-only.        |
| `data_manager_set`            | Saves a validated wizard model on a draft action version.                             |
| `data_manager_capture_sample` | Stores a real response previously obtained elsewhere; it does not execute the action. |

To obtain actual source values, prefer an exposed native read operation whose contract fits the lookup. If no such operation is available, a documented `api_explore` GET/HEAD path can be considered within the authorized application's scope. Use an established endpoint and schema; do not guess API routes or field mappings.

Keep configuration, sample data and current source data separate. A sample describes a shape; it is not proof that the same record or option exists now. Record the source, type, scope and relevant freshness when using a lookup result. If several valid options remain, ask for the business decision rather than choosing arbitrarily.

## Keep credentials and side effects explicit

Use stored credential references through the active tool's discovery and selection process. Preserve existing authorized credentials. Do not request or copy secret values into prompts or reusable examples.

`api_explore` GET/HEAD executes immediately; POST/PUT/PATCH/DELETE use preview/apply. A read can still retrieve sensitive application data, so keep its scope relevant. Trigger registration, sample capture and configuration saves are mutations even when they do not run the final business service.

Once discovery is complete, carry the actual component references and unresolved gaps into [structured service authoring](https://docs.autommate.com/userguide/mcp-and-ai-reference/structured-service-authoring). Resolve known values using [deployment input resolution](https://docs.autommate.com/userguide/mcp-and-ai-reference/deployment-input-resolution), and consult the [AI entry index](https://docs.autommate.com/userguide/mcp-and-ai-reference/for-ai-agents-read-this-first) for the exact reference needed next.

## Require complete contracts for system actions too

Validate system/library actions with the same rigor as custom integrations. Database Connect/Select, directory operations, Python/PowerShell and Teams card steps can require target variables, connection dependencies, response/result fields or conditional inputs. Obtain those fields from the installed action contract and supported implementation; do not infer them from a display name or an old screenshot.

If metadata is incomplete, identify the exact action and missing fields. Do not use a generic script as a silent substitute for an available native operation. Conversely, a native action that cannot implement the required dynamic callback or approval does not become sufficient merely because its label sounds similar. Document the concrete gap before choosing a supported REST alternative.
