The accounts payable automation landscape just got a major upgrade. Aito's latest releases introduce game-changing capabilities that solve one of the most persistent challenges in invoice processing: making accurate predictions when you have limited historical data.

Whether you're dealing with a new vendor, an unfamiliar expense category, or a recently hired employee, traditional ML approaches often struggle. Today, we're excited to show you how Aito's enhanced prediction capabilities automatically leverage entity properties and enterprise-scale performance optimization change the game entirely.

The Challenge: Making Smart Predictions with Limited Context

Let's start with a real scenario every accounting team faces:

It's Monday morning, and your automated invoice processing system encounters an invoice from a new cloud services vendor. The system has never seen this vendor before, but it needs to assign a GL code, predict the appropriate approver, and route it to the right department. Traditional rule-based systems would fail here, and most ML models would make random guesses.

This is where Aito's automatic property-based predictions become invaluable.

How Aito Makes Intelligent Predictions for Unknown Entities

Instead of requiring explicit prior configuration, Aito automatically uses the properties of entities to make intelligent predictions. Think of it like an experienced accountant who uses what they know about a vendor's industry, size, and service type to make smart categorization decisions.

Here's how it works in practice:

The Problem: Unknown Vendor Scenario

Your system encounters a new vendor "NewCloudTech Solutions" with no historical data:

{
  "from": "invoices",
  "where": {
    "VendorName": "NewCloudTech Solutions",
    "Amount": 2400,
    "Description": "Monthly cloud infrastructure"
  },
  "predict": "GLCode"
}

Traditional ML: Would make a random guess because this vendor has never been seen before.

The Aito Solution: Automatic Property-Based Intelligence

Instead of requiring manual configuration, Aito automatically leverages vendor properties to make intelligent predictions. If your vendor table includes properties like this:

// Vendor table entry for the new vendor
{
  "VendorName": "NewCloudTech Solutions",
  "Industry": "Technology",
  "ServiceType": "Cloud Infrastructure",
  "CompanySize": "Medium"
}

Aito automatically uses these properties to find similar vendors and their GL code patterns. The prediction query remains simple:

{
  "from": "invoices", 
  "where": {
    "VendorName": "NewCloudTech Solutions",
    "Amount": 2400,
    "Description": "Monthly cloud infrastructure",
    "VendorIndustry": "Technology",
    "VendorServiceType": "Cloud Infrastructure"
  },
  "predict": "GLCode"
}

Result: Aito automatically uses all fields from the where clause (VendorName, Amount, Description, VendorIndustry, VendorServiceType) to find similar patterns in historical data, maintaining high accuracy (85-90%) even for completely new vendors - a significant improvement over traditional ML which typically drops below 50% accuracy for unknown entities.

Real-World Impact: Enterprise-Scale Invoice Processing

Let's examine how these improvements transform high-volume invoice processing in production environments:

Scenario 1: New Employee Onboarding

Challenge: Bob, a new IT manager, joins the company. He has zero historical invoice approvals.

Traditional approach: All invoices default to a senior manager, creating bottlenecks.

Aito's automatic approach: Uses Bob's employee properties to make intelligent assignments. If your employee table has:

// Employee record for Bob
{
  "Email": "bob@company.com",
  "Role": "Manager", 
  "Department": "IT",
  "ApprovalLimit": 10000,
  "Seniority": "Mid-level"
}

The prediction query automatically leverages these properties:

{
  "from": "invoices",
  "where": {
    "Department": "IT",
    "Amount": 3500,
    "InvoiceType": "Software License"
  },
  "predict": "Approver"
}

Result: Aito automatically uses all fields from the where clause (Department, Amount, InvoiceType) to find similar patterns in historical data. The system learns from how other IT managers with similar roles and approval limits have been assigned invoices, ensuring Bob gets appropriate assignments despite having no historical data.

Scenario 2: Seasonal Expense Categories

Challenge: Holiday season brings unique expenses (catering, gifts, events) that appear infrequently.

Aito's approach: Automatically uses descriptive keywords and timing to find similar expense patterns:

{
  "from": "invoices",
  "where": {
    "Description": "Holiday catering services",
    "Month": "December", 
    "Amount": 1200,
    "VendorCategory": "Food Service"
  },
  "predict": "GLCode"
}

Outcome: Aito automatically uses all the fields from the where clause (Description, Month, Amount, VendorCategory) to find similar patterns in historical data, matching this to similar event-related expenses from previous years and other catering services, achieving 90%+ accuracy on seasonal expenses compared to 60% with rule-based systems.

Enterprise Scale Performance: Processing Millions of Invoices

Aito's enhanced predict endpoint is optimized for large-scale financial operations:

Performance at Scale

Based on our performance benchmarks:

• Query Response Time: 20-168ms for predictions (scales with data size)
• Dataset Scale: Tested up to 10 million invoice records
• Reliability: 100% uptime across all test scenarios

What This Means for Your Accounting Team

With Aito's enhanced predict endpoint, you can now leverage all available metadata to make intelligent predictions, even for entities with no historical data. The system automatically uses linked table attributes when making predictions, eliminating the cold start problem.

Implementation Guide: Complete Setup and Prediction

Here's how to implement contextual GL code prediction for your invoice processing:

Step 1: Define Your Schema

First, create a schema that includes your invoice data and any linked tables (vendors, employees):

{
  "schema": {
    "invoices": {
      "type": "table",
      "columns": {
        "InvoiceID": {"type": "String"},
        "VendorName": {"type": "String", "link": "vendors.VendorName"},
        "Amount": {"type": "Decimal"},
        "Description": {"type": "Text"},
        "Department": {"type": "String"},
        "GLCode": {"type": "String"},
        "Approver": {"type": "String", "link": "employees.Email"}
      }
    },
    "vendors": {
      "type": "table", 
      "columns": {
        "VendorName": {"type": "String"},
        "Industry": {"type": "String"},
        "ServiceType": {"type": "String"},
        "CompanySize": {"type": "String"}
      }
    },
    "employees": {
      "type": "table",
      "columns": {
        "Email": {"type": "String"},
        "Department": {"type": "String"},
        "Role": {"type": "String"},
        "ApprovalLimit": {"type": "Decimal"}
      }
    }
  }
}

Step 2: Upload Your Data

Upload your historical invoice data along with vendor and employee metadata:

# Upload schema
curl -X PUT https://your-instance.api.aito.ai/api/v1/schema \
  -H "x-api-key: YOUR_API_KEY" \
  -H "content-type: application/json" \
  -d @schema.json

# Upload data
curl -X POST https://your-instance.api.aito.ai/api/v1/data/invoices/batch \
  -H "x-api-key: YOUR_API_KEY" \
  -H "content-type: application/json" \
  -d @invoices.json

Step 3: Make Intelligent Predictions

Now you can predict GL codes for new invoices, leveraging all available metadata:

{
  "from": "invoices",
  "where": {
    "VendorName": "NewCloudTech Solutions",
    "Amount": 2400,
    "Description": "Monthly cloud infrastructure",
    "Department": "IT"
  },
  "predict": "GLCode"
}

The enhanced predict endpoint automatically uses the vendor's properties (Industry, ServiceType) from the linked vendors table to make an informed prediction, even though this vendor has never been seen before.

Step 4: Handle Predictions with Confidence

# Python SDK example
from aito import AitoClient

client = AitoClient(api_key="YOUR_API_KEY", instance_url="YOUR_INSTANCE_URL")

# Make prediction
result = client.predict(
    from_table="invoices",
    where={
        "VendorName": "Unknown Vendor",
        "Description": "Miscellaneous expense",
        "Amount": 150
    },
    predict="GLCode"
)

# Use confidence to determine automation level
if result.hits[0]["$p"] > 0.85:
    # High confidence: Auto-assign
    gl_code = result.hits[0]["GLCode"]
    process_automatically(gl_code)
elif result.hits[0]["$p"] > 0.70:
    # Medium confidence: Flag for review
    queue_for_quick_review(result.hits[0]["GLCode"])
else:
    # Low confidence: Manual processing
    route_to_accounting_team()

Leveraging Metadata for Intelligent Predictions

The key innovation in Aito's enhanced predict endpoint is how it automatically leverages metadata from linked tables. When predicting a GL code for an invoice from a new vendor, the system:

1. Identifies linked relationships: Recognizes that VendorName links to the vendors table
2. Retrieves metadata: Automatically pulls in Industry, ServiceType, and other vendor properties
3. Applies pattern matching: Finds similar vendors based on these properties
4. Makes informed predictions: Assigns GL codes based on how similar vendors were categorized

This approach solves the cold start problem - new vendors get accurate predictions from day one based on their metadata, not random guesses.

ROI Impact: Quantifying the Business Value

Based on production implementations in enterprise accounting environments:

Time Savings

• Manual GL coding: 2-3 minutes per invoice
• With contextual predictions: 10-15 seconds per invoice
• Monthly savings: 40-60 hours for teams processing 1,000+ invoices

Accuracy Improvements

• Rule-based systems: 70-80% accuracy
• Traditional ML: 85-90% accuracy (drops to <50% for new vendors)
• Aito with metadata-driven predictions: 90-95% accuracy (maintains 85%+ even for new vendors)

Cost Reduction

• Reduced manual review: 70% fewer invoices requiring intervention
• Faster processing: 3x improvement in throughput
• Error prevention: 85% reduction in mis-coded expenses

What's Next: The Future of Accounting Intelligence

These prediction enhancements represent just the beginning. Here's what we're seeing in the accounting automation space:

1. Real-time anomaly detection using confidence scoring
2. Predictive cash flow analysis with automatic seasonal pattern recognition
3. Intelligent vendor risk assessment based on payment patterns
4. Automated compliance checking with regulatory context

Getting Started Today

Ready to transform your invoice processing with contextual predictions? Here's how to begin:

1. Try the enhanced predictions with your existing invoice data
2. Download our Invoice Processing Starter Kit with ready-to-use examples
3. Schedule a demo to see these features in action with your specific use cases

The future of accounting automation isn't just about speed—it's about intelligence that adapts, learns, and makes smart decisions even when facing the unknown.

Have questions about implementing contextual predictions for your accounting workflows? Reach out to our team - we're here to help you build the intelligent accounting platform your team deserves.