> ## Documentation Index
> Fetch the complete documentation index at: https://docs.stardeck.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Cross-App Communication

> Connect your apps so they can call each other's APIs, share data, and work together as a system

When you build multiple apps in your organization, they often need to talk to each other. A POS that sends orders to a kitchen display. A CRM that creates invoices when a deal closes. A booking app that triggers confirmation emails through a notification service.

Cross-app communication lets your apps call each other through the Stardeck platform. You don't need to manage URLs, secrets, or authentication between apps — the platform handles all of that.

## How It Works

Apps call each other by name, not by URL. The platform sits in the middle and handles routing, authentication, and permissions. Your apps never talk to each other directly.

```mermaid theme={null}
flowchart TB
    subgraph setup [Setup - automatic]
        direction LR
        B_build[App B deploys] -- provides schema and endpoints --> Platform_reg[Platform registers endpoints]
        Platform_reg -- broadcasts availability --> A_discover[Other apps and agents can discover endpoints]
    end

    subgraph runtime [Every cross-app call]
        direction LR
        A[App A] -- call by name --> Platform[Stardeck Platform]
        Platform -- signed request --> B[App B]
        B -- response --> Platform
        Platform -- response --> A
    end

    setup --> runtime
```

On every call, the platform checks permissions, authenticates the request, routes to the right deployment, and logs the call.

Your apps never need to know each other's URLs or secrets. When an app deploys, the platform automatically detects its API endpoints and makes them discoverable to other apps and agents. On every call, the platform checks permissions, authenticates the request, routes to the right deployment, and logs everything.

Here's an example of what that looks like in practice — a POS sending orders to a kitchen display, with the kitchen sending status updates back:

```mermaid theme={null}
flowchart LR
    POS["📱 POS App"]
    Platform["☁️ Stardeck Platform"]
    Kitchen["🍳 Kitchen Display"]

    POS -- "new order" --> Platform
    Platform -- "new ticket" --> Kitchen
    Kitchen -- "order ready" --> Platform
    Platform -- "ready for pickup" --> POS
```

This gives you:

* **Stable connections** — apps find each other by project slug, so redeploying doesn't break anything
* **No shared secrets** — the platform authenticates every call on behalf of both apps
* **Permission control** — you decide which apps can talk to each other
* **Call logs** — every cross-app call is logged so you can see what's happening

## Getting Started

### 1. Set Up the APIs

Open the project chat for the app you want to make callable and ask the agent to expose APIs. You don't need to specify routes or technical details:

```
Set up APIs so other apps can check order status and create new orders
```

The agent designs the endpoints, handles the documentation, and the platform automatically detects them.

### 2. Grant Access

Go to the app's **Settings** tab and open the **Cross-App** section. You have two options:

* **Allow all apps** — any app in the org can read data from this app (quick for getting started)
* **Explicit grant** — grant a specific app access, with control over whether it can read, write, or both

See [Permissions & Grants](/cross-app/permissions) for details.

### 3. Connect the Apps

Open the project chat for the app that needs to call the other, and tell the agent what should happen:

```
When a new order is placed, send it to the kitchen display app
```

The agent wires up the cross-app call in your code.

### 4. Test It

You can test from the project chat:

```
Place a test order and check that it showed up on the kitchen display
```

Or ask Starcat from the org dashboard to coordinate across both apps.

## Agent Calling

You don't have to set up cross-app calls through code at all. Starcat can discover endpoints, call APIs, and orchestrate data flows across your apps through conversation.

Ask Starcat things like:

* "What can I call on the invoicing app?"
* "Get the latest orders from the POS app"
* "Check inventory on the warehouse app and update the storefront if anything is out of stock"

For Starcat to operate an app, that app needs **Allow agent access** turned on in its Cross-App settings. See [Agent Cross-App Calling](/cross-app/agent-calling) for the full guide.

## Next Steps

<CardGroup cols={2}>
  <Card title="Permissions & Grants" icon="shield" href="/cross-app/permissions">
    Control which apps can talk to each other
  </Card>

  <Card title="Agent Calling" icon="robot" href="/cross-app/agent-calling">
    Let the AI agent make cross-app calls for you
  </Card>
</CardGroup>