Quick Start (SaaS)

AI Agent Assembly is a SaaS-only product. Choose the tier that matches your team size and compliance requirements, then follow the path below to connect your first AI agent.

Self-hosted deployment is not available. There is no self-hosted, on-premises, or bring-your-own-infrastructure option. All governance, policy evaluation, and audit logging run in the AI Agent Assembly cloud. See Open Core Boundary for the licensing model.

LangChain: Zero-to-Governance in Under 5 Minutes

This end-to-end example takes a LangChain agent from zero to fully governed in under 5 minutes using any SaaS tier.

Prerequisites: Python 3.12+, an OpenAI API key, and a Pro (or higher) workspace.

Step 1 — Install packages

pip install agent-assembly langchain langchain-openai langchain-core

Step 2 — Set credentials

export AAA_WORKSPACE_ID="<your-workspace-id>"   # from Settings → Workspace
export AAA_API_KEY="<your-api-key>"             # from Settings → API Keys
export OPENAI_API_KEY="<your-openai-key>"

Step 3 — Instrument your LangChain agent

import os
from agent_assembly import AgentAssembly
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool

aaa = AgentAssembly()

@tool
def summarise_text(text: str) -> str:
    """Return a one-sentence summary of the provided text."""
    return text[:200] + "..." if len(text) > 200 else text

@aaa.agent(name="langchain-research-agent")
def run_agent(question: str) -> str:
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    tools = [summarise_text]

    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful research assistant."),
        ("human", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ])

    agent = create_openai_tools_agent(llm, tools, prompt)
    executor = AgentExecutor(agent=agent, tools=tools, verbose=False)
    result = executor.invoke({"input": question})
    return result["output"]

if __name__ == "__main__":
    answer = run_agent("What is AI Agent Assembly and why does it matter for enterprise governance?")
    print(answer)

The @aaa.agent decorator registers langchain-research-agent with the gateway, wraps every invocation with pre-execution policy evaluation, and emits an audit event for every LangChain call — without modifying LangChain internals.

Step 4 — Activate a starter policy

In the console, open Policies → New Policy and apply the starter template (allow all, audit all). This takes under 30 seconds. Every subsequent call from langchain-research-agent is now governed, audited, and visible in the Audit Log panel.

What governance looks like at runtime

[AAASM] Agent registered: langchain-research-agent (workspace: ws-a1b2...)
[AAASM] Policy check: ALLOW  event=llm_call  agent=langchain-research-agent
[AAASM] Audit event written: id=evt_01j...  latency=2ms

Pro Tier

Signup: self-serve at https://app.agent-assembly.io/signup

Included features: up to 10 agents, basic policy engine (allow/deny/audit), 30-day audit log retention, community forum support.

Expected onboarding time: ~10 minutes from signup to first governed agent call.

Primary contact channel: self-serve; community forum at https://community.agent-assembly.io.

Navigate to https://app.agent-assembly.io/signup and create an account with your work email.
Verify your email address.
On the Workspace Setup page, enter a workspace name (e.g., acme-ai-ops) and select your primary region.
Copy your Workspace ID and generate an API Key under Settings → API Keys.
Install the SDK:

pip install agent-assembly          # Python
pnpm add @agent-assembly/sdk        # TypeScript
go get github.com/agent-assembly/go-sdk  # Go

Set credentials:

export AAA_WORKSPACE_ID="<your-workspace-id>"
export AAA_API_KEY="<your-api-key>"

Instrument your agent entry point:

from agent_assembly import AgentAssembly

aaa = AgentAssembly()

@aaa.agent(name="my-first-agent")
def run_agent(prompt: str) -> str:
    import openai
    client = openai.OpenAI()
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
    )
    return response.choices[0].message.content

Open Policies → New Policy in the console and activate a starter policy. Your agent is now governed.

Business Tier

Signup: self-serve at https://app.agent-assembly.io/signup — select Business during workspace setup.

Included features: up to 50 agents, full policy engine, SSO (SAML 2.0 / OIDC), 90-day audit log retention, SIEM export, business-hours support (24h response).

Expected onboarding time: ~30 minutes, including SSO connect.

Primary contact channel: support ticket via https://app.agent-assembly.io/support.

Sign up at https://app.agent-assembly.io/signup, select the Business tier.
On the Billing page, enter your credit card details (processed via Stripe).
Complete workspace setup (name, region) as in the Pro flow above.
Connect SSO: navigate to Settings → Authentication → SSO and follow the SAML 2.0 or OIDC setup steps. SSO is optional at the Business tier but recommended for teams.
Invite your team under Settings → Users — assign roles (Admin, Developer, Viewer).
Instrument agents and create policies as in the Pro flow.

Enterprise Tier

Signup: form-driven via https://app.agent-assembly.io/contact-sales.

Included features: unlimited agents, dedicated region (data residency), SCIM provisioning, tamper-evident audit log, audit log retention up to 1 year, 99.9% SLA, 24/7 support (4h response), dedicated SRE contact.

Expected onboarding time: 1–3 weeks, driven by procurement and security review.

Primary contact channel: your assigned Sales Engineer (SE).

Enterprise procurement timeline

Week	Activity
Week 1	Submit the `/contact-sales` form → initial SE call (30 min) → receive the Enterprise Order Form and DPA/BAA templates
Week 2	Legal review of DPA / BAA → IT security review → contract signature
Week 3	SE-led workspace provisioning → SSO + SCIM setup with your IdP team → pilot agent onboarding

Enterprise-specific steps

Submit the contact form at https://app.agent-assembly.io/contact-sales. Include estimated agent count, primary region preference, and compliance requirements (SOC 2, HIPAA, GDPR).
During the SE call, confirm your IdP (Okta, Azure AD, PingFederate, etc.) and data residency requirement.
After contract signature, the SE provisions your workspace in the selected dedicated region and sends your Workspace ID and initial API key.
Configure SSO (SAML or OIDC) per Cloud Deployment → SSO Configuration.
Configure SCIM provisioning per Cloud Deployment → SCIM User Provisioning for automated user lifecycle management.
Configure budgets per Cloud Deployment → Budget Configuration for per-team LLM spend caps.
Instrument agents and create policies as in the Pro flow.

Next Steps

Cloud Deployment — SSO/SCIM deep-dive, region selection, billing, SLA tiers
Policy Reference — full policy rule schema
Open Core Boundary — what's in the OSS core vs enterprise tier

Last reviewed: 2026-05-10 · AI Agent Assembly Team

AI Agent Assembly — Enterprise Documentation