Skip to main content
Version: 1.x

Integrating with AI Agent Frameworks

:::info Roadmap Native integrations with the frameworks below are on the Praman roadmap. The architecture and adapter contracts described on this page reflect the planned design. Community contributions and early feedback are welcome — open a discussion on GitHub. :::

Praman is designed from the ground up as an AI-first plugin. Its structured outputs — AiResponse<T> envelopes, IntentDescriptor payloads, capability manifests, and vocabulary graphs — map naturally onto the tool-call and agent-step patterns used by modern AI orchestration frameworks.

This page describes the planned integration model for five major frameworks, explains what each integration will look like in practice, and lists the capabilities each adapter will expose.

Integration Architecture​

All framework adapters will follow the same two-layer model:

┌──────────────────────────────────────────────────────────────┐
│  AI Agent Framework (LangGraph / AutoGen / OpenAI Agents…)   │
│                                                              │
│  ┌────────────────────────────────────────────────────────┐  │
│  │  Praman Adapter (playwright-praman/ai)                 │  │
│  │                                                        │  │
│  │  Tool: navigateTo(intent)  →  ui5.press / page.goto    │  │
│  │  Tool: fillField(id, val)  →  ui5.fill + waitForUI5    │  │
│  │  Tool: readControl(id)     →  ui5.getValue / getProperty│  │
│  │  Tool: waitForStable()     →  ui5.waitForUI5           │  │
│  │  Tool: getCapabilities()   →  CapabilityRegistry.list  │  │
│  └────────────────────────────────────────────────────────┘  │
│                                                              │
│  ┌────────────────────────────────────────────────────────┐  │
│  │  Playwright Browser  ←  Praman Fixtures + Bridge       │  │
│  └────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────┘

Each adapter will expose Praman's SAP operations as typed tool definitions that the framework's orchestrator can call, chain, and retry. The browser state (Playwright Page) is kept alive across agent steps using the same fixture injection model Praman already uses.

LangGraph​

LangGraph (LangChain) models multi-step agent workflows as typed state machines where each node is a callable tool or sub-graph. Praman maps directly onto this model — each UI5 operation is a node with clearly typed inputs and outputs.

Planned Capabilities​

LangGraph ConceptPraman Mapping
State nodeOne test.step() → one SAP UI interaction
Tool nodenavigateTo, fillField, selectOption, assertControl
Conditional edgeBranch on AiResponse.status (success / error / partial)
Interrupt + resumeCheckpoint serialization via Praman's CheckpointState type
Human-in-the-loopPause on SAP validation error, surface to operator, resume

What the Adapter Will Provide​

// Planned API — not yet available
import { createLangGraphAdapter } from 'playwright-praman/ai/langgraph';

const tools = createLangGraphAdapter(page, ui5);

// tools exposes: navigateTo, fillField, readControl,
//                waitForStable, openValueHelp, selectFromTable,
//                assertFieldValue, getCapabilities

Example Agent Flow (Planned)​

import { StateGraph } from '@langchain/langgraph';
import { createLangGraphAdapter } from 'playwright-praman/ai/langgraph';

const graph = new StateGraph({ channels: { messages: { value: [] } } })
  .addNode('navigate', tools.navigateTo)
  .addNode('openDialog', tools.press)
  .addNode('fillMaterial', tools.fillField)
  .addNode('fillPlant', tools.fillField)
  .addNode('submit', tools.press)
  .addConditionalEdges('submit', (state) =>
    state.lastResult.status === 'success' ? 'verify' : 'handleError',
  )
  .addNode('verify', tools.assertControl)
  .addNode('handleError', tools.gracefulCancel)
  .compile();

:::tip Why LangGraph fits SAP workflows SAP processes are inherently stateful and branching — a BOM creation may succeed, fail with a validation error, or require a different plant/material combination. LangGraph's conditional edges and interrupt/resume model handles this naturally without hard-coded if/else chains in test scripts. :::

AutoGen (Microsoft)​

AutoGen is Microsoft's open-source framework for building multi-agent systems where specialized agents collaborate to complete complex tasks. Its conversational agent model aligns with Praman's planner → generator → healer pipeline.

Planned Capabilities​

AutoGen ConceptPraman Mapping
AssistantAgentPraman planner — discovers SAP UI, produces test plan
UserProxyAgentPraman executor — runs Playwright actions, reports results
GroupChatPlanner + Generator + Healer collaborate on a test suite
Tool registrationSAP UI tools registered on the executor agent
Code executionGenerated .spec.ts runs via npx playwright test

What the Adapter Will Provide​

// Planned API — not yet available
import { createAutoGenTools } from 'playwright-praman/ai/autogen';

const sapTools = createAutoGenTools(page, ui5);
// Register on your AutoGen UserProxyAgent's function map

Planned Agent Topology​

┌─────────────────┐     instructions      ┌──────────────────┐
│  PlannerAgent   │ ──────────────────►   │  ExecutorAgent   │
│  (AssistantAgent│     test steps        │  (UserProxyAgent) │
│   + SAP skills) │                       │  + Praman tools  │
└─────────────────┘                       └────────┬─────────┘
        ▲                                          │
        │          result + errors                 │
        └──────────────────────────────────────────┘
              HealerAgent joins on failure

Microsoft Agent Framework (Semantic Kernel)​

Semantic Kernel is Microsoft's SDK for building AI-powered applications with plugins, planners, and memory. Praman's capability registry and vocabulary system are designed to expose as Semantic Kernel plugins.

Planned Capabilities​

Semantic Kernel ConceptPraman Mapping
Native pluginSapUi5Plugin — exposes all ui5.* fixtures as SK functions
PlannerAuto-plans multi-step SAP workflows from a natural language goal
MemoryStores discovered control maps between agent sessions
Function callingEach Praman tool becomes a describable SK kernel function
FiltersPre/post hooks map to Praman's BeforeAction / AfterAction lifecycle

What the Adapter Will Provide​

// Planned API — not yet available
import { SapUi5Plugin } from 'playwright-praman/ai/semantic-kernel';
import { Kernel } from '@microsoft/semantic-kernel';

const kernel = new Kernel();
kernel.addPlugin(new SapUi5Plugin(page, ui5), 'SapUI5');

// Kernel can now plan: "Fill the BOM creation form and submit"
// and call SapUI5.fillField, SapUI5.press, SapUI5.waitForStable

Plugin Functions (Planned)​

FunctionDescription
navigateToApp(appName)FLP navigation to a named Fiori app
fillField(controlId, value)ui5.fill() with SAP field binding
pressButton(controlId)ui5.press() with stability wait
readFieldValue(controlId)ui5.getValue()
openValueHelp(controlId)Open and enumerate value help table
selectFromValueHelp(index)Pick row by OData binding index
waitForStableUI()ui5.waitForUI5()
getAvailableApps()Queries FLP tile catalog

OpenAI Agents SDK​

The OpenAI Agents SDK (previously Swarm) provides a lightweight framework for building agents that hand off between each other and call registered tools. Praman tools map directly onto the SDK's function-tool model.

Planned Capabilities​

OpenAI Agents SDK ConceptPraman Mapping
AgentOne agent per Praman role (planner, executor, healer)
function_toolEvery ui5.* fixture becomes a callable tool definition
HandoffsPlanner → Generator → Healer pipeline with structured handoff context
Structured outputAiResponse<T> maps to Pydantic / Zod response schemas
TracingPlaywright test.info().annotations surface in OpenAI trace UI

What the Adapter Will Provide​

// Planned API — not yet available
import { createOpenAITools } from 'playwright-praman/ai/openai-agents';

const tools = createOpenAITools(page, ui5);
// tools: array of OpenAI function_tool definitions
// ready to pass to new Agent({ tools })

Planned Tool Schema Example​

{
  "name": "fill_sap_field",
  "description": "Fill a SAP UI5 input field and fire the change event. Use for SmartField, MDC Field, and sap.m.Input controls.",
  "parameters": {
    "type": "object",
    "properties": {
      "controlId": { "type": "string", "description": "Stable SAP UI5 control ID from discovery" },
      "value": { "type": "string", "description": "Value to set" },
      "searchOpenDialogs": { "type": "boolean", "default": true }
    },
    "required": ["controlId", "value"]
  }
}

Google Agent Development Kit (ADK)​

Google's Agent Development Kit (ADK) is Google's open-source framework for building and deploying multi-agent systems, with first-class support for tool use, multi-agent pipelines, and Vertex AI integration. The ADK's BaseTool interface is a natural fit for Praman's typed SAP tools.

Planned Capabilities​

Google ADK ConceptPraman Mapping
BaseToolEach ui5.* fixture becomes an ADK tool with typed schema
LlmAgentSAP planner, generator, and healer as ADK agents
SequentialAgentPlan → Generate → Heal pipeline
ParallelAgentConcurrent discovery of multiple Fiori apps
Vertex AI backendCloud-hosted planning with Gemini models
Session stateShared control map and vocabulary across agent steps

What the Adapter Will Provide​

// Planned API — not yet available
import { createADKTools } from 'playwright-praman/ai/google-adk';
import { LlmAgent } from '@google/adk';

const sapTools = createADKTools(page, ui5);

const plannerAgent = new LlmAgent({
  name: 'SapTestPlanner',
  model: 'gemini-2.0-flash',
  tools: sapTools,
  instruction: 'Discover the SAP UI5 app and produce a structured test plan.',
});

ADK Pipeline (Planned)​

SequentialAgent
├── SapPlannerAgent   → discovers UI5 controls, writes test plan
├── SapGeneratorAgent → converts plan to playwright-praman spec
└── SapHealerAgent    → runs test, reads failure, iterates

:::tip Vertex AI + SAP The ADK integration will support Vertex AI backends, enabling teams to run the planning and generation pipeline entirely within Google Cloud — useful for enterprises with data residency requirements. :::

Comparison​

FrameworkBest ForOrchestration ModelPraman Fit
LangGraphComplex branching SAP workflows, human-in-the-loopState machine graphExcellent — maps to test.step()
AutoGenMulti-agent collaboration (planner + healer)Conversational agentsExcellent — mirrors Praman pipeline
Semantic KernelMicrosoft ecosystem, enterprise .NET/PythonPlugin + plannerGood — capability registry as plugin
OpenAI Agents SDKLightweight, fast iteration, OpenAI modelsFunction tools + handoffsGood — clean tool schema mapping
Google ADKVertex AI, Gemini models, GCP-native pipelinesSequential/parallel agentsGood — structured ADK tool definitions

Playwright CLI Integration​

In addition to the framework adapters above, Praman supports a Playwright CLI integration path. The CLI is a token-efficient alternative to MCP where agents invoke npx playwright commands directly instead of connecting through a persistent server.

IntegrationConnection ModelToken EfficiencyBest For
MCP ServerPersistent WebSocketModerateReal-time agent loops, VS Code extensions
Playwright CLIStateless commandsHighCI/CD pipelines, token-constrained agents
Framework AdaptersNative SDK toolsVariesMulti-agent orchestration, complex workflows

The CLI works with any agent framework that can execute shell commands — including LangGraph, AutoGen, and OpenAI Agents SDK — without requiring a native adapter.

See the CLI Agents Guide for building agent loops with the CLI, and MCP vs CLI for a detailed comparison.

Current Workaround: Use Praman Agents Directly​

While framework-native adapters are in development, you can orchestrate Praman's three agents today using Claude Code MCP, Playwright CLI, or GitHub Copilot Agent Mode with the included agent definitions:

.github/agents/praman-sap-planner.agent.md
.github/agents/praman-sap-generator.agent.md
.github/agents/praman-sap-healer.agent.md

See Running Your Agent for the First Time for the complete pipeline.

Contribute or Follow Progress​

  • GitHub Discussions: Share your framework preference and use case
  • Issues: Track individual adapter issues under the ai-adapters label
  • Roadmap: The order of delivery will reflect community demand — upvote your framework
Planned delivery order (subject to change):
  1. OpenAI Agents SDK adapter   ← lightest surface area
  2. LangGraph adapter           ← most requested for SAP workflows
  3. Google ADK adapter          ← Vertex AI enterprise demand
  4. AutoGen adapter             ← multi-agent collaboration
  5. Semantic Kernel plugin      ← Microsoft ecosystem