Build AI Integrations with App Builder

Deploy AI-powered integrations in minutes, not weeks. App Builder provides zero-infrastructure, enterprise-grade hosting for AI agents, MCP servers, and intelligent workflows—with built-in security, authentication, and auto-scaling.

Why App Builder for AI?

Stop managing infrastructure. Start building intelligent experiences.

Enterprise Security Built-In

AI Use Cases on App Builder

1. MCP (Model Context Protocol) Servers

Host standardized MCP servers that expose Adobe data and capabilities to AI assistants through the official MCP TypeScript SDK.

What is MCP?

The Model Context Protocol is an open standard that enables AI assistants (Claude, Cursor, etc.) to securely interact with external systems. Instead of hardcoding API credentials in AI configs, MCP servers act as secure intermediaries.

Architecture:

AI Tool (Claude Desktop/Cursor)
    ↓ MCP protocol request
Your MCP Server (hosted on App Builder)
    ↓ Authenticated API call (OAuth S2S)
Adobe APIs (Analytics, AEM, Assets, etc.)
    ↓ Structured response
AI Tool (formats for user)

What You Can Build:

Features:

Quick Start:

# Initialize App Builder project
aio app init my-mcp-server
cd my-mcp-server

# Install MCP SDK (only needed for MCP servers)
npm install @modelcontextprotocol/sdk

# Deploy to App Builder
aio app deploy

Note: The MCP SDK is only required if you're building an MCP server. Other AI use cases (DocuBot, LangChain agents, etc.) use different packages.

Configure in Your AI Assistant:

Add your deployed MCP server URL to your AI assistant's configuration (Claude Desktop, Cursor, or other MCP-compatible tools).

After deployment, your MCP server URL will be:

https://<namespace>-<workspace>.adobeioruntime.net/api/v1/web/mcp/server

Example:

https://52381-myproject-stage.adobeioruntime.net/api/v1/web/mcp/server

Refer to your AI assistant's documentation for specific configuration steps.

Example Use Cases:

Security Benefits:

2. Documentation Assistants

Build AI-powered chatbots that answer developer questions based on your documentation, GitHub issues, and internal knowledge bases.

Example: DocuBot - AI Slack Assistant

What It Does:

Features:

Architecture:

User asks question in Slack
    ↓
App Builder action processes request
    ↓
Vector search against indexed docs
    ↓
LLM generates answer with citations
    ↓
Formatted response in Slack

Quick Start:

# Clone the DocuBot example
git clone https://github.com/rokapooradobe/adobe-docubot
cd adobe-docubot

# Install dependencies
npm install

# Configure environment variables
cp .env.example .env
# Edit .env with your API keys (Slack, AI provider, Adobe OAuth)

# Deploy to App Builder
aio app deploy

See the DocuBot README for complete setup instructions.

3. AI Agent Hosting

Host AI agents and autonomous workflows on App Builder without managing containers or orchestration.

What You Can Build:

Benefits:

4. Content Analysis & Auto-Tagging

Build intelligent content processing pipelines using AI models to analyze, categorize, and enrich assets.

Use Cases:

Example Flow:

Asset uploaded to AEM
    ↓ (webhook trigger)
App Builder action receives event
    ↓
Calls vision API (Google Vision, AWS Rekognition)
    ↓
Tags extracted & written back to AEM

5. Predictive Workflows & Forecasting

Use machine learning models to power intelligent business workflows.

Use Cases:

Example:

// App Builder action with ML inference
async function predictChurn(params) {
  const customerData = await fetchCustomerData(params.customerId);
  const prediction = await callMLModel(customerData);
  
  if (prediction.churnRisk > 0.7) {
    await triggerMarketoCampaign({ customerId: params.customerId });
  }
  
  return prediction;
}

Quick Start: Deploy Your First AI Integration

Prerequisites

Step 1: Create & Initialize Project

Initialize App Builder Project:

# Create new App Builder project
aio app init my-ai-app

# Select template based on your use case:
# - "All Actions" - For backend-only (MCP servers, APIs)
# - "All Extensions" - For UI extensions (Unified Shell, Workfront, AEM)

cd my-ai-app

Project Structure:

my-ai-app/
├── src/
│   ├── dx-excshell-1/         # Unified Shell (if selected)
│   │   ├── actions/           # Backend actions
│   │   ├── web-src/           # Frontend UI
│   │   └── ext.config.yaml    # Extension configuration
│   ├── workfront-ui-1/        # Workfront (if selected)
│   │   └── ext.config.yaml    # Extension configuration
│   └── ...                    # Other extension points
├── app.config.yaml            # App configuration
├── package.json
└── .env                       # Local secrets

Step 2: Configure, Code & Deploy

1. Add API Keys (stored securely, never in code):

# For Adobe APIs (required)
aio app config set ADOBE_CLIENT_ID your-client-id
aio app config set ADOBE_CLIENT_SECRET your-client-secret
aio app config set ADOBE_IMS_ORG_ID your-org-id

# For AI providers (if using LLMs)
aio app config set OPENAI_API_KEY your-openai-key
# or
aio app config set ANTHROPIC_API_KEY your-anthropic-key

2. Write Your Action Code:

Use AI assistants to help you! See the AI Coding Developer Tooling guide for tips on using Cursor, GitHub Copilot, and Claude with App Builder.

Example Action:

// src/workfront-ui-1/actions/fetch-tasks/index.js
const { Core } = require('@adobe/aio-sdk');
const fetch = require('node-fetch');

async function main(params) {
  const logger = Core.Logger('fetch-tasks', { level: params.LOG_LEVEL || 'info' });
  
  try {
    const { projectId } = params;
    
    if (!projectId) {
      return {
        statusCode: 400,
        body: { error: 'projectId parameter required' }
      };
    }
    
    // Query Workfront API
    const response = await fetch(
      `https://${params.WORKFRONT_DOMAIN}/attask/api/v21.0/task/search?projectID=${projectId}&status=NEW,INP&$$LIMIT=100`,
      {
        headers: {
          'Sessionid': params.WORKFRONT_API_KEY
        }
      }
    );
    
    if (!response.ok) {
      throw new Error(`Workfront API error: ${response.statusText}`);
    }
    
    const data = await response.json();
    
    // Sort by due date
    const tasks = (data.data || []).sort((a, b) => 
      new Date(a.plannedCompletionDate) - new Date(b.plannedCompletionDate)
    );
    
    logger.info(`Fetched ${tasks.length} tasks for project ${projectId}`);
    
    return {
      statusCode: 200,
      body: { tasks }
    };
    
  } catch (error) {
    logger.error(error);
    return {
      statusCode: 500,
      body: { error: error.message }
    };
  }
}

exports.main = main;

3. Test Locally:

# Start local development server
aio app dev

# Test your action (in another terminal)
curl http://localhost:9080/api/v1/web/fetch-tasks \
  -H "Content-Type: application/json" \
  -d '{"projectId": "abc123"}'

4. Deploy:

# Deploy to Adobe I/O Runtime
aio app deploy

# Your action is now live at:
# https://your-namespace.adobeioruntime.net/api/v1/web/fetch-tasks

5. View Logs:

# View recent logs
aio app logs

# Stream logs in real-time
aio app logs --tail

Next Steps

  1. Add More Actions: Build additional actions for different Adobe products
  2. Configure AI Assistant: Connect Claude Desktop or Cursor to your MCP server (if applicable)
  3. Set Up CI/CD: Automate deployments with GitHub Actions
  4. Monitor Usage: Track action invocations and errors in logs
  5. Iterate with AI: Use AI assistants to refine and extend your actions

Agent Skills Specification Reference

Note: Agent Skills are an open standard for AI-discoverable capabilities. While App Builder doesn't have pre-built Adobe Skills templates yet, we will be building a skills library and CLI tooling to make it easy to discover and install Adobe integration patterns. In the meantime, you can build custom skills using the MCP protocol or by following the Agent Skills specification.

What Are Agent Skills?

Agent Skills use a standardized directory structure and metadata format that makes capabilities discoverable to AI assistants. Think of them as "API documentation for AI agents."

Installing Skills with aio CLI

Similar to playwright-cli install --skills, App Builder can install pre-built skills directly into your project:

# Install Adobe product skills
aio skill install workfront-task-query
aio skill install aem-content-fragments
aio skill install analytics-query

# Install all recommended skills for an extension point
aio skill install --all --extension workfront-ui-1

# List available skills
aio skill list --available

# List installed skills in current project
aio skill list --installed

Benefits:

Example: Skill with Known Issue

---
name: aem-content-fragments
description: Query and manage AEM Content Fragments using OpenAPI
known-issues:
  - api: "AEM Assets HTTP API"
    status: deprecated
    recommendation: "Use AEM OpenAPI - better coverage for Content Fragments"
    migration: "https://developer.adobe.com/experience-manager/docs/openapi/"
---

When an AI assistant tries to use the deprecated HTTP API, the skill automatically suggests the OpenAPI alternative.

Directory Structure

my-app-builder-project/
├── actions/
│   └── skills/                    # Skills directory
│       ├── adobe-analytics-query/
│       │   ├── SKILL.md           # Skill definition (metadata + docs)
│       │   └── index.js           # Implementation (App Builder action)
│       ├── adobe-assets-search/
│       │   ├── SKILL.md
│       │   └── index.js
│       └── registry.js            # Skills discovery endpoint
├── app.config.yaml
└── package.json

SKILL.md Format

Each skill has a SKILL.md file with YAML frontmatter + Markdown description following the Adobe Skills specification:

---
name: workfront-task-query
description: Query and analyze Workfront tasks by team, status, or priority. Helps identify overdue tasks, resource allocation, and project health.
---

# Workfront Task Query

Query Adobe Workfront to retrieve task information based on natural language criteria.

## When to Use This Skill

Use this skill when:
- You need to find tasks by assignee, team, or status
- You want to identify overdue or high-priority work
- You're analyzing project health and resource allocation
- You need task data for reporting or dashboards

**Example queries:**
- "Show my open tasks due this week"
- "What high-priority tasks are overdue?"
- "List all tasks assigned to the Marketing team"

## Prerequisites

To use this skill, you need:
- ✅ Adobe Workfront instance URL
- ✅ OAuth Server-to-Server credentials with Workfront API access
- ✅ Valid access token from App Builder authentication
- ✅ Workfront API v21.0 OpenAPI specification for complete endpoint details

## Related Skills

- **workfront-project-status** - Get overall project health metrics
- **workfront-resource-allocation** - Analyze team capacity and workload
- **workfront-time-tracking** - Query logged hours and time entries

## Workflow

### Step 1: Parse Natural Language Query

Convert user's natural language request into Workfront API parameters:

```javascript
// Input: "Show my open tasks due this week"
// Output:
{
  filters: {
    status: "INP",  // In Progress
    assignedToID: "<current-user-id>",
    plannedCompletionDate: {
      gte: "2026-02-25",
      lte: "2026-03-03"
    }
  }
}
```

### Step 2: Query Workfront API

Call Workfront API v21.0 with constructed filters:

```bash
GET https://your-instance.workfront.com/attask/api/v21.0/task/search
```

### Step 3: Format Response

Transform API response into human-readable results:

```json
{
  "tasks": [
    {
      "name": "Design homepage mockup",
      "dueDate": "2026-02-28",
      "priority": "high",
      "assignee": "John Doe",
      "project": "Website Redesign"
    }
  ],
  "summary": {
    "total": 5,
    "overdue": 1,
    "dueThisWeek": 4
  }
}
```

## Example Usage

**Query 1: High-priority overdue tasks**
```
User: "What high-priority tasks are overdue?"

Response:
Found 3 high-priority overdue tasks:
1. "Update brand guidelines" - Due: Feb 20 (5 days overdue) - John Doe
2. "Review Q1 budget" - Due: Feb 22 (3 days overdue) - Jane Smith
3. "Finalize campaign creative" - Due: Feb 23 (2 days overdue) - Mike Johnson
```

**Query 2: Team workload**
```
User: "List all tasks assigned to the Marketing team"

Response:
Marketing team has 12 active tasks:
- 8 in progress
- 3 not started
- 1 overdue
```

## Authentication

Requires OAuth Server-to-Server credentials:
- Store `ADOBE_CLIENT_ID`, `ADOBE_CLIENT_SECRET` in App Builder environment
- Fetch access token using client credentials flow
- Include token in Workfront API requests

## Error Handling

Handle common errors:
- **401 Unauthorized**: Refresh OAuth token
- **403 Forbidden**: User lacks Workfront permissions
- **404 Not Found**: Invalid task or project ID
- **Rate Limit**: Implement retry with backoff

Progressive Disclosure Concept

Agent Skills use progressive disclosure to provide the right level of detail based on AI context:

  1. Skill Registry - High-level list of available skills (names + 1-line descriptions)
  2. Skill Definition (SKILL.md frontmatter) - Concise name and description
  3. Full Documentation (SKILL.md body) - When to use, workflow, examples, error handling

AI assistants first see the registry, then request specific skill details only when needed.

Learn More

Resources

Next Steps

  1. Explore Templates: Run aio app init and browse AI-focused templates
  2. Join Community: Adobe Developer Forums
  3. Read Guides: App Builder Guides
  4. Watch Demos: App Builder on YouTube
  5. Contribute Your Skills: Help grow the App Builder Agent Skills ecosystem by sharing your custom skills

Ready to build? Start with one command:

aio app init --template @adobe/generator-app-agent-skills

Contribute Your App Builder Skills

We welcome contributions from the community! If you've built Agent Skills for App Builder, share them with other developers.

How to Contribute:

  1. Create your skill following the Agent Skills specification
  2. Test your skill with AI assistants (Claude, Cursor, GitHub Copilot)
  3. Document your skill with clear examples and use cases
  4. Submit to the community via the Adobe Skills repository

What Skills to Contribute:

Adobe API Integrations:

Developer Tools:

Business Workflows:

Contribution Benefits:

How to Submit Your Skills:

Share your App Builder skills with the community:

We'll review community contributions and feature the best skills in our documentation and examples.

Last updated: February 2026