Can an AI Agent Carry a Deal from Demo to Signature? (2026 Architecture)

import os
import json
from typing import TypedDict, Optional, Dict, Any, List
from pydantic import BaseModel, Field
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
import requests

# ---------------------------------------------------------------------------
# 1. State Definition & Pydantic Extraction Schemas
# ---------------------------------------------------------------------------

class DealTerms(BaseModel):
    client_name: str = Field(description="Full legal name of the client company")
    signer_name: str = Field(description="Full name of the authorized signing officer")
    signer_email: str = Field(description="Corporate email address of the signer")
    tier_plan: str = Field(description="Product tier: Starter, Professional, or Enterprise")
    seat_count: int = Field(description="Number of licensed user seats")
    annual_price_usd: float = Field(description="Agreed annual contract value in USD")
    discount_percentage: float = Field(default=0.0, description="Discount granted (0 to 100)")
    payment_terms: str = Field(default="Net-30", description="Agreed payment terms: Due Upon Receipt, Net-30, Net-60")
    custom_commitments: List[str] = Field(default_factory=list, description="Custom agreed SLA or onboarding terms")

class AgentDealState(TypedDict):
    demo_transcript: str
    crm_lead_id: str
    seller_name: str
    seller_email: str
    terms: Optional[DealTerms]
    contract_markdown: Optional[str]
    guardrail_passed: bool
    hitl_required: bool
    hitl_approved: bool
    document_id: Optional[str]
    signing_url: Optional[str]
    audit_hash: Optional[str]
    error_message: Optional[str]

# ---------------------------------------------------------------------------
# 2. Node Implementations
# ---------------------------------------------------------------------------

llm = ChatAnthropic(model="claude-3-7-sonnet-20250219", temperature=0.0)

def extract_deal_terms_node(state: AgentDealState) -> Dict[str, Any]:
    """Parses transcript using structured output to extract exact commercial parameters."""
    extractor_llm = llm.with_structured_output(DealTerms)
    
    prompt = f"""
    You are an expert Sales Operations Officer. Ingest the following sales demo transcript and 
    extract the exact commercial terms agreed upon by the prospect and the sales rep.
    
    Transcript:
    {state['demo_transcript']}
    """
    
    extracted_terms = extractor_llm.invoke([
        SystemMessage(content="Extract accurate, verified B2B deal parameters. Never invent terms."),
        HumanMessage(content=prompt)
    ])
    
    return {"terms": extracted_terms}

def draft_contract_markdown_node(state: AgentDealState) -> Dict[str, Any]:
    """Compiles structured parameters into deterministic, professional Markdown legal agreement."""
    terms = state["terms"]
    
    markdown_contract = f"""# Master Software License & Services Agreement

**Effective Date:** August 3, 2026  
**Document Reference:** AGR-{state['crm_lead_id']}

---

### 1. Parties & Authorization
* **Provider:** Signbee Ltd ("Provider"), represented by {state['seller_name']} ({state['seller_email']})
* **Customer:** {terms.client_name} ("Customer"), represented by {terms.signer_name} ({terms.signer_email})

---

### 2. Subscription Scope & Commercial Terms

| Commercial Parameter | Agreed Specification |
| :--- | :--- |
| **Subscription Plan** | {terms.tier_plan} Tier (Enterprise Cloud) |
| **Authorized Seats** | {terms.seat_count} Named Users |
| **Annual Contract Value** | ${terms.annual_price_usd:,.2f} USD |
| **Discount Applied** | {terms.discount_percentage:.1f}% |
| **Payment Terms** | {terms.payment_terms} via Automated Invoicing |

---

### 3. Service Level Commitments & Custom Addenda
{chr(10).join([f"- {c}" for c in terms.custom_commitments]) if terms.custom_commitments else "- Standard 99.9% Uptime Guarantee and 24/7 Enterprise Support."}

---

### 4. Terms of Governance & Execution
This Agreement constitutes a legally binding instrument under the United States ESIGN Act, the EU eIDAS Regulation, and the UK Electronic Communications Act 2000. Both parties acknowledge electronic signature validity.

**Signatures Authorized Below:**
"""
    return {"contract_markdown": markdown_contract}

def legal_guardrail_node(state: AgentDealState) -> Dict[str, Any]:
    """Deterministic validation of pricing, discounts, and payment terms."""
    terms = state["terms"]
    
    # Rule 1: Max autonomous discount is 20%
    if terms.discount_percentage > 20.0:
        return {"guardrail_passed": False, "hitl_required": True, "error_message": f"Discount of {terms.discount_percentage}% exceeds autonomous 20% limit."}
        
    # Rule 2: Minimum deal threshold for enterprise tier
    if terms.tier_plan.lower() == "enterprise" and terms.annual_price_usd < 12000:
        return {"guardrail_passed": False, "hitl_required": True, "error_message": "Enterprise plan price is below $12,000 threshold."}
        
    # Rule 3: Payment terms must not exceed Net-60
    if terms.payment_terms not in ["Due Upon Receipt", "Net-30", "Net-45", "Net-60"]:
        return {"guardrail_passed": False, "hitl_required": True, "error_message": f"Payment terms '{terms.payment_terms}' require CFO review."}
        
    return {"guardrail_passed": True, "hitl_required": False}

def dispatch_signbee_mcp_node(state: AgentDealState) -> Dict[str, Any]:
    """Calls the Signbee API / MCP Server tool to initiate legal signing."""
    api_key = os.environ.get("SIGNBEE_API_KEY", "sb_live_production_key")
    terms = state["terms"]
    
    payload = {
        "title": f"Services Agreement — {terms.client_name}",
        "markdown": state["contract_markdown"],
        "sender_name": state["seller_name"],
        "sender_email": state["seller_email"],
        "recipient_name": terms.signer_name,
        "recipient_email": terms.signer_email,
        "metadata": {
            "crm_lead_id": state["crm_lead_id"],
            "tier": terms.tier_plan,
            "acv": terms.annual_price_usd,
            "agent_initiated": "true"
        }
    }
    
    # In an MCP host environment, the LLM calls signbee_send_contract tool.
    # Under the hood, it executes a single POST request to the Signbee endpoint:
    response = requests.post(
        "https://signb.ee/api/v1/send",
        headers={
            "Content-Type": "application/json",
            "Authorization": f"Bearer {api_key}"
        },
        json=payload,
        timeout=10
    )
    
    if response.status_code != 200:
        raise RuntimeError(f"Signbee API error: {response.text}")
        
    res_data = response.json()
    return {
        "document_id": res_data.get("document_id"),
        "signing_url": res_data.get("signing_url"),
        "audit_hash": res_data.get("sha256_hash")
    }

# ---------------------------------------------------------------------------
# 3. StateGraph Wiring with Human-in-the-Loop Interrupts
# ---------------------------------------------------------------------------

def router_guardrail_check(state: AgentDealState) -> str:
    if state["hitl_required"] and not state.get("hitl_approved", False):
        return "human_approval_checkpoint"
    return "dispatch_signbee_mcp"

builder = StateGraph(AgentDealState)

builder.add_node("extract_terms", extract_deal_terms_node)
builder.add_node("draft_contract", draft_contract_markdown_node)
builder.add_node("evaluate_guardrails", legal_guardrail_node)
builder.add_node("dispatch_signbee_mcp", dispatch_signbee_mcp_node)

builder.set_entry_point("extract_terms")
builder.add_edge("extract_terms", "draft_contract")
builder.add_edge("draft_contract", "evaluate_guardrails")
builder.add_conditional_edges(
    "evaluate_guardrails",
    router_guardrail_check,
    {
        "human_approval_checkpoint": END,  # Pauses execution for human intervention
        "dispatch_signbee_mcp": "dispatch_signbee_mcp"
    }
)
builder.add_edge("dispatch_signbee_mcp", END)

# Compile graph with persistence memory
memory = MemorySaver()
sales_agent_app = builder.compile(checkpointer=memory)