Framework Integration

Invarium works with any AI agent framework. Here is how to describe your agent regardless of what you built it with.

The Invarium blueprint format is framework-agnostic — it describes what your agent does, not how it is implemented. However, different frameworks have different conventions for tools, workflows, and agent composition. This guide shows you how to map your framework’s concepts to an Invarium blueprint.

Framework overview

Framework	Agent model	Tool definition	Multi-agent
LangChain	AgentExecutor, LCEL chains	`@tool` decorator, Tool class	LangGraph
CrewAI	Crew of agents with roles	`@tool` decorator	Built-in (crews)
AutoGen	Conversable agents	Function definitions	Built-in (group chat)
Custom	Any implementation	Any callable	Varies

LangChain

Mapping LangChain concepts

LangChain concept	Blueprint field
Agent name	`agent_name`
`@tool` functions	`tools[]`
System prompt rules	`constraints[]`
Chain / graph steps	`workflows[]`
LangGraph nodes	`workflows[].steps[]`

Example: LangChain agent blueprint

Given this LangChain agent:

@tool
def search_products(query: str) -> str:
    """Search the product catalog by name or category."""
    # ...
 
@tool
def check_inventory(product_id: str) -> dict:
    """Check current inventory levels for a product."""
    # ...
 
@tool
def place_order(product_id: str, quantity: int, customer_id: str) -> str:
    """Place an order for a product."""
    # ...

The blueprint would be:

{
  "agent_name": "ecommerce-assistant",
  "framework": "langchain",
  "description": "An e-commerce assistant that helps customers search products, check availability, and place orders.",
  "tools": [
    {
      "name": "search_products",
      "description": "Search the product catalog by name or category.",
      "parameters": {
        "query": "string — product name, category, or search terms"
      },
      "returns": "List of matching products with name, price, and ID.",
      "side_effects": "none"
    },
    {
      "name": "check_inventory",
      "description": "Check current inventory levels for a specific product.",
      "parameters": {
        "product_id": "string — the unique product identifier"
      },
      "returns": "Object with product_id, available_quantity, and warehouse_location.",
      "side_effects": "none"
    },
    {
      "name": "place_order",
      "description": "Place an order for a product on behalf of the customer.",
      "parameters": {
        "product_id": "string — the product to order",
        "quantity": "integer — number of units",
        "customer_id": "string — the customer placing the order"
      },
      "returns": "Order confirmation with order_id and estimated delivery date.",
      "side_effects": "payment"
    }
  ],
  "constraints": [
    "Always check inventory before placing an order",
    "Never place an order without the customer's explicit confirmation",
    "Do not recommend products that are out of stock",
    "Only discuss products available in our catalog"
  ],
  "workflows": [
    {
      "name": "purchase-flow",
      "trigger": "Customer wants to buy a product",
      "steps": [
        "Search for the product in the catalog",
        "Check inventory for the matching product",
        "If in stock, confirm the order details with the customer",
        "Place the order after customer confirmation"
      ]
    }
  ]
}

LangChain tips

Map each @tool decorated function to a tools[] entry
Extract constraints from your system prompt — every rule in the system prompt should be a constraint
If you use LangGraph, map each node to a step in a workflows[] entry
Include tool side_effects for any tool that writes data or triggers external actions

CrewAI

Mapping CrewAI concepts

CrewAI concept	Blueprint field
Crew name	`agent_name`
Agent roles + tools	`tools[]` (combine across agents)
Agent backstories / rules	`constraints[]`
Task sequences	`workflows[]`
Crew process type	`workflows[].steps[]`

Example: CrewAI crew blueprint

Given a CrewAI crew with two agents:

researcher = Agent(
    role="Research Analyst",
    goal="Find accurate market data",
    tools=[search_web, analyze_data],
)
 
writer = Agent(
    role="Content Writer",
    goal="Write clear reports from research data",
    tools=[format_report, check_grammar],
)
 
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
)

The blueprint would be:

{
  "agent_name": "market-research-crew",
  "framework": "crewai",
  "description": "A two-agent crew that researches market data and produces formatted reports. The researcher gathers data, and the writer creates the final report.",
  "tools": [
    {
      "name": "search_web",
      "description": "Search the web for market data, news, and competitor information.",
      "parameters": {
        "query": "string — search terms for market research"
      },
      "returns": "List of relevant web results with titles, snippets, and URLs.",
      "side_effects": "none"
    },
    {
      "name": "analyze_data",
      "description": "Perform statistical analysis on collected market data.",
      "parameters": {
        "data": "array — raw data points to analyze",
        "analysis_type": "string — type of analysis (trend, comparison, forecast)"
      },
      "returns": "Analysis results with key metrics and insights.",
      "side_effects": "none"
    },
    {
      "name": "format_report",
      "description": "Format research findings into a structured report document.",
      "parameters": {
        "content": "string — raw content to format",
        "template": "string — report template to use (summary, detailed, executive)"
      },
      "returns": "Formatted report as markdown.",
      "side_effects": "none"
    },
    {
      "name": "check_grammar",
      "description": "Check report text for grammar and style issues.",
      "parameters": {
        "text": "string — text to check"
      },
      "returns": "Corrected text with list of changes made.",
      "side_effects": "none"
    }
  ],
  "constraints": [
    "Research data must come from the web search tool, not from training data",
    "Reports must cite all sources used",
    "Do not include speculative information without labeling it as speculation",
    "Reports must follow the specified template format"
  ],
  "workflows": [
    {
      "name": "market-report",
      "trigger": "User requests a market research report on a topic",
      "steps": [
        "Research agent searches the web for relevant market data",
        "Research agent analyzes the collected data",
        "Writer agent formats the analysis into a report",
        "Writer agent checks grammar and style",
        "Final report is delivered to the user"
      ]
    }
  ]
}

CrewAI tips

List tools from all agents in the crew in a single tools[] array
Include constraints from each agent’s backstory and goal
Map the crew’s task sequence to workflows[].steps[]
Note the process type (sequential vs. hierarchical) — this affects workflow structure

AutoGen

Mapping AutoGen concepts

AutoGen concept	Blueprint field
Agent group name	`agent_name`
Function definitions	`tools[]`
System messages	`constraints[]`
Conversation flow	`workflows[]`

Example: AutoGen agent blueprint

Given an AutoGen setup:

assistant = AssistantAgent(
    name="code_reviewer",
    system_message="You review code for bugs, security issues, and style.",
    llm_config={"functions": [
        {
            "name": "run_linter",
            "description": "Run a linter on the provided code",
            "parameters": {"code": {"type": "string"}, "language": {"type": "string"}}
        },
        {
            "name": "run_security_scan",
            "description": "Run a security vulnerability scan on the code",
            "parameters": {"code": {"type": "string"}}
        }
    ]}
)

The blueprint would be:

{
  "agent_name": "code-reviewer",
  "framework": "autogen",
  "description": "Reviews code submissions for bugs, security vulnerabilities, and style issues. Uses automated linting and security scanning tools.",
  "tools": [
    {
      "name": "run_linter",
      "description": "Run a code linter to check for syntax errors, style issues, and common bugs.",
      "parameters": {
        "code": "string — the source code to lint",
        "language": "string — programming language (python, javascript, typescript, etc.)"
      },
      "returns": "List of linting issues with line numbers, severity, and descriptions.",
      "side_effects": "none"
    },
    {
      "name": "run_security_scan",
      "description": "Run a security vulnerability scan to detect common security issues like SQL injection, XSS, and hardcoded secrets.",
      "parameters": {
        "code": "string — the source code to scan"
      },
      "returns": "List of security findings with severity, CWE ID, and remediation suggestions.",
      "side_effects": "none"
    }
  ],
  "constraints": [
    "Always run both the linter and security scan before providing a review",
    "Never modify the submitted code — only report findings",
    "Classify every finding by severity: critical, high, medium, low",
    "Do not approve code with critical security findings"
  ],
  "workflows": [
    {
      "name": "code-review",
      "trigger": "User submits code for review",
      "steps": [
        "Run the linter on the submitted code",
        "Run the security scan on the submitted code",
        "Compile findings from both tools",
        "Provide a summary with severity-ranked findings and an approve/reject recommendation"
      ]
    }
  ]
}

AutoGen tips

Map each function in llm_config.functions to a tools[] entry
Extract constraints from the system_message
For multi-agent conversations, describe the full conversation flow in workflows[]
If using GroupChat, list all agents’ tools in the single blueprint

Custom agents

Any agent works

If your agent is built with a custom framework or no framework at all, you can still create a blueprint. The key is to identify:

What functions/APIs can your agent call? — These are your tools.
What rules should your agent follow? — These are your constraints.
What multi-step processes does your agent perform? — These are your workflows.

Example: Custom REST API agent

{
  "agent_name": "internal-ops-bot",
  "framework": "custom",
  "description": "An internal operations bot that manages deployments, monitors services, and handles incident response through REST API calls.",
  "tools": [
    {
      "name": "deploy_service",
      "description": "Trigger a deployment for a specified service to a target environment.",
      "parameters": {
        "service_name": "string — name of the service to deploy",
        "environment": "string — target environment (staging, production)",
        "version": "string — version tag to deploy"
      },
      "returns": "Deployment status with deployment_id and estimated completion time.",
      "side_effects": "Triggers a deployment pipeline. Production deployments require approval."
    },
    {
      "name": "check_service_health",
      "description": "Check the health status of a running service.",
      "parameters": {
        "service_name": "string — name of the service to check"
      },
      "returns": "Health status (healthy, degraded, down) with metrics.",
      "side_effects": "none"
    },
    {
      "name": "create_incident",
      "description": "Create an incident ticket in the incident management system.",
      "parameters": {
        "title": "string — incident title",
        "severity": "string — P1, P2, P3, or P4",
        "affected_services": "array of strings — list of affected services"
      },
      "returns": "Incident ticket ID and link.",
      "side_effects": "Creates a ticket and pages the on-call team for P1/P2 incidents."
    }
  ],
  "constraints": [
    "Never deploy to production without explicit user confirmation",
    "Always check service health before deploying",
    "P1 incidents must be created immediately, not queued",
    "Never deploy to production during an active P1 incident",
    "Log all deployment actions for audit purposes"
  ],
  "workflows": [
    {
      "name": "deploy",
      "trigger": "User requests a service deployment",
      "steps": [
        "Check the health of the target service",
        "If deploying to production, request explicit user confirmation",
        "Trigger the deployment",
        "Monitor deployment status and report result"
      ]
    },
    {
      "name": "incident-response",
      "trigger": "Service health check returns degraded or down",
      "steps": [
        "Identify affected services",
        "Create an incident ticket with appropriate severity",
        "Notify the on-call team",
        "Monitor for resolution"
      ]
    }
  ]
}

Custom agent tips

Set framework to "custom" when not using a standard framework
Be extra detailed in tool descriptions since there is no framework convention for Invarium to infer from
Include side effects for every tool that changes state
Document all implicit rules your agent follows as explicit constraints

Common patterns

Regardless of framework, these patterns apply:

Every callable function is a tool. If your agent can call it, list it in tools[].
Every rule is a constraint. System prompts, guardrails, and business rules all become constraints[].
Every multi-step process is a workflow. If your agent follows a sequence of steps to complete a task, describe it in workflows[].
Be specific about side effects. Tools that only read data have "side_effects": "none". Tools that write data, send messages, or trigger external systems need their side effects documented. Use specific values like database_write, api_call, email_send, payment, etc.

Not sure if your blueprint is complete? Upload it and generate a small set of tests (5-10). If the tests feel generic or miss important behaviors, your blueprint needs more detail.

Was this page helpful?

CI/CD Quality Gates Rate Limits