CAMEL-AI & OWL Agents: Autonomous Multi-Agent Contract Signing (2026)

import asyncio
import os
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.models import ModelFactory
from camel.toolkits import MCPToolkit
from camel.types import ModelPlatformType, ModelType

async def run_signbee_mcp_agent() -> None:
    # Configure Signbee MCP server over stdio
    mcp_config = {
        "mcpServers": {
            "signbee": {
                "command": "npx",
                "args": ["-y", "signbee-mcp"],
                "env": {
                    "SIGNBEE_API_KEY": os.environ["SIGNBEE_API_KEY"],
                },
            }
        }
    }

    # Connect MCPToolkit and introspect Signbee tools
    async with MCPToolkit(config_dict=mcp_config) as mcp_toolkit:
        signbee_tools = mcp_toolkit.get_tools()

        model = ModelFactory.create(
            model_platform=ModelPlatformType.OPENAI,
            model_type=ModelType.GPT_4O,
            model_config_dict={"temperature": 0.1},
        )

        system_msg = BaseMessage.make_assistant_message(
            role_name="Legal Execution Officer",
            content=(
                "You are an autonomous Legal Execution Officer. Draft crystal-clear commercial "
                "agreements in CommonMark markdown with structured tables and dispatch them for "
                "two-party SHA-256 electronic signature using your Signbee MCP tools."
            ),
        )

        agent = ChatAgent(
            system_message=system_msg,
            model=model,
            tools=signbee_tools,
        )

        user_prompt = (
            "Draft a Mutual Non-Disclosure Agreement (mNDA) governed by the laws of England and Wales "
            "between 'B2bee Ltd' (Michael Beckett, michael@b2bee.ai) and 'Vanguard Robotics GmbH' "
            "(Lukas Weber, l.weber@vanguard-robotics.de) with a 36-month confidentiality term, "
            "and send it immediately via Signbee."
        )

        response = await agent.astep(user_prompt)
        print("Agent Output:\n", response.msgs[0].content)
        print("Tool Calls Executed:", response.info.get("tool_calls", []))

if __name__ == "__main__":
    asyncio.run(run_signbee_mcp_agent())

import os
import requests
from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.societies.workforce import Workforce
from camel.tasks import Task
from camel.toolkits import FunctionTool
from camel.types import ModelPlatformType, ModelType


def dispatch_verified_contract_to_signbee(
    title: str,
    markdown_contract: str,
    audit_status: str,
    sender_name: str,
    sender_email: str,
    recipient_name: str,
    recipient_email: str,
    expires_in_days: int = 14,
) -> dict:
    """Dispatches an audited CommonMark contract via Signbee POST /api/v1/send.

    Args:
        title: Official title of the commercial agreement.
        markdown_contract: Full CommonMark markdown body of the contract.
        audit_status: Must equal 'PLAYBOOK_APPROVED' from the Risk & Playbook Auditor agent.
        sender_name: Full legal name of Party A (Authorized Corporate Signer).
        sender_email: Verified corporate email address of Party A.
        recipient_name: Full legal name of Party B (Vendor Counterparty).
        recipient_email: Email address of Party B where the signing link is delivered.
        expires_in_days: Days until signing link expiration (default 14).

    Returns:
        Dictionary containing Signbee document_id, status, and SHA-256 verification URL.
    """
    if audit_status.strip().upper() != "PLAYBOOK_APPROVED":
        raise PermissionError(
            f"Execution blocked: audit_status is '{audit_status}', expected 'PLAYBOOK_APPROVED'."
        )

    response = requests.post(
        "https://signb.ee/api/v1/send",
        json={
            "title": title,
            "markdown": markdown_contract,
            "sender_name": sender_name,
            "sender_email": sender_email,
            "recipient_name": recipient_name,
            "recipient_email": recipient_email,
            "expires_in_days": expires_in_days,
        },
        headers={
            "Authorization": f"Bearer {os.environ['SIGNBEE_API_KEY']}",
            "Content-Type": "application/json",
        },
        timeout=20,
    )
    response.raise_for_status()
    return response.json()


# Instantiate shared LLM backbone
model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_4O,
    model_config_dict={"temperature": 0.1},
)

# 1. Commercial & Legal Drafter Agent (Zero external tools)
drafter_agent = ChatAgent(
    system_message=(
        "You are Senior Commercial Counsel. Draft comprehensive CommonMark Statements of Work "
        "(SOWs) including milestone payment tables, IP assignment, and limitation of liability."
    ),
    model=model,
)

# 2. Risk & Playbook Auditor Agent (Zero external tools)
auditor_agent = ChatAgent(
    system_message=(
        "You are Corporate Risk Auditor. Inspect drafted CommonMark contracts. Verify that "
        "(a) total liability is capped at 100% of fees paid, (b) IP is assigned to Client upon payment, "
        "and (c) milestone sums match the header total. If compliant, output 'PLAYBOOK_APPROVED'."
    ),
    model=model,
)

# 3. Signbee Execution Dispatcher Agent (Holds the Signbee FunctionTool)
signbee_tool = FunctionTool(dispatch_verified_contract_to_signbee)
dispatcher_agent = ChatAgent(
    system_message=(
        "You are the Contract Execution Dispatcher. Only invoke dispatch_verified_contract_to_signbee "
        "after the Risk Auditor outputs 'PLAYBOOK_APPROVED'."
    ),
    model=model,
    tools=[signbee_tool],
)

# Assemble the CAMEL Workforce
workforce = Workforce("Autonomous B2B Procurement & E-Signature Workforce")
workforce.add_single_agent_worker(
    "Commercial & Legal Drafter that writes CommonMark SOWs",
    worker=drafter_agent,
).add_single_agent_worker(
    "Risk & Playbook Auditor that validates liability caps and IP clauses",
    worker=auditor_agent,
).add_single_agent_worker(
    "Contract Execution Dispatcher that sends approved contracts via Signbee",
    worker=dispatcher_agent,
)

if __name__ == "__main__":
    procurement_task = Task(
        content=(
            "Create, audit, and dispatch a Statement of Work titled 'Cloud Security Penetration Test SOW — Q4 2026' "
            "between Client 'B2bee Ltd' (Michael Beckett, michael@b2bee.ai) and Provider 'Aegis Cyber Defense Ltd' "
            "(Hannah Vance, hannah@aegiscyber.io). Milestones: Phase 1 Infrastructure Audit ($9,500 due Oct 15, 2026) "
            "and Phase 2 Remediation Retest ($6,500 due Nov 1, 2026). Total: $16,000. Ensure full IP assignment "
            "and 12-month fee liability cap, audit compliance, and dispatch via Signbee."
        ),
        id="PROC-2026-0920",
    )
    completed_task = workforce.process_task(procurement_task)
    print("Workforce Final Result:\n", completed_task.result)

import os
import requests
from camel.toolkits import FunctionTool


def verify_signbee_execution_certificate(document_id: str) -> dict:
    """Queries Signbee GET /api/v1/documents/{id} to verify two-party signature status and SHA-256 digest.

    Args:
        document_id: Unique Signbee document identifier returned at dispatch (e.g., 'cm8x9k2p0001...').

    Returns:
        Dictionary containing lifecycle status, signer timestamps, SHA-256 hash, and public verify URL.
    """
    api_key = os.environ["SIGNBEE_API_KEY"]
    url = f"https://signb.ee/api/v1/documents/{document_id}"

    res = requests.get(
        url,
        headers={"Authorization": f"Bearer {api_key}"},
        timeout=15,
    )
    res.raise_for_status()
    data = res.json()

    return {
        "document_id": data.get("id", document_id),
        "title": data.get("title"),
        "status": data.get("status"),
        "sha256_hash": data.get("sha256_hash"),
        "verify_url": f"https://signb.ee/verify/{document_id}",
        "signed_at": data.get("signed_at"),
    }


verify_tool = FunctionTool(verify_signbee_execution_certificate)