Platform Documentation

Getting Started

New to Blackstone? These guides provide a foundational understanding of the platform and help you build your first automation.

Developer Guides

Technical documentation for developers building custom solutions, integrations, and extensions on the Blackstone platform. Dive deep into our SDKs, API capabilities, and custom connector framework.

SDKs

Leverage our Software Development Kits (SDKs) to interact with the platform programmatically from your preferred language environment. Our SDKs provide convenient wrappers around the Blackstone REST API, simplifying authentication, request formation, and response handling. Obtain the SDK packages through your private client portal.

Python SDK

• Setup: Instructions on setting up your Python environment and installing the SDK package provided privately.
• Authentication: Examples using API Keys and OAuth 2.0 helper methods after obtaining the SDK.
• Core Functionality:
  • Triggering workflows: client.workflows.trigger(workflow_id='wf_abc', inputs={'invoice_id': '123'})
  • Retrieving document data: data = client.documents.get_data(document_id='doc_xyz')
  • Managing tasks: tasks = client.tasks.list(status='pending')
• Advanced Usage: Handling pagination, error handling, asynchronous operations.
• See Python SDK Examples Below

Java SDK

• Setup: Integrating the SDK library (obtained via client portal) into your Maven or Gradle project build configuration.
• Client Initialization: Creating and configuring the BlackstoneClient.
• Workflow Interaction: Examples for triggering and monitoring workflows.
• Document Management: Uploading documents and retrieving results.
• See Java SDK Examples Below

.NET SDK

• Setup: Adding the SDK library (obtained via client portal) reference to your .NET project (e.g., .csproj file).
• Configuration: Setting up the client with credentials in C# or VB.NET.
• Usage Examples: Integrating with ASP.NET applications, interacting with platform resources.
• See .NET SDK Examples Below

Custom Connectors

Extend the platform's connectivity by building your own connectors for internal systems or third-party applications not covered by our pre-built library. This allows seamless data flow within your workflows.

• Connector Development Framework: Understanding the architecture, required interfaces (e.g., IConnector, IAuthenticationProvider), and lifecycle methods. Access the framework components via the client developer portal.
• Building a REST-Based Connector: Step-by-step guide covering HTTP methods, request/response mapping, pagination handling, and authentication (Basic Auth, OAuth, API Key). Includes code samples.
• Building a Database Connector: Connecting to SQL (JDBC/ODBC) and NoSQL databases, query parameterization, result set handling. Security considerations for database credentials.
• Handling Authentication and Security: Best practices for securely managing credentials within connectors, using platform secrets vault, implementing secure communication protocols (TLS).
• Testing and Debugging Connectors: Using the local development environment and testing tools provided in the developer toolkit to simulate workflow execution with your connector.
• Deploying and Versioning Connectors: Packaging connectors (e.g., JAR, DLL), deploying them to your Blackstone instance via the Admin console, managing updates and version compatibility.

Embedding Automation

Integrate Blackstone's automation power directly into your existing business applications, providing a seamless experience for your users.

• Using Platform APIs for Embedding: Triggering specific Blackstone workflows or actions from your application's backend via REST API calls. Example: initiating document verification from within your CRM, retrieving workflow status updates.
• Embedding the Workflow Designer: Using iframe or web components (details provided in developer toolkit) to embed the visual workflow builder into your application, allowing users to customize automations (requires specific licensing). Handling communication between the host app and the embedded designer.
• Embedding Task Lists: Displaying and allowing users to action Human-in-the-Loop tasks directly within your application interface using dedicated API endpoints and potentially UI component libraries provided.
• White-labeling Options: Customizing the appearance (logo, colors) of embedded components to match your application's branding (Enterprise plans). Configuration options in the Admin console.

Python SDK Examples

Detailed examples demonstrating common use cases.

# Example: Triggering a workflow and checking status
# Ensure SDK is obtained and configured in your environment
from blackstone_sdk import BlackstoneClient # Assuming this structure

client = BlackstoneClient(api_key="YOUR_PRIVATE_API_KEY")

try:
    trigger_response = client.workflows.trigger(
        workflow_id='wf_invoice_approval',
        inputs={'invoice_pdf_url': 'https://internal.example.com/docs/invoice_123.pdf'}
    )
    execution_id = trigger_response['execution_id']
    print(f"Workflow triggered with execution ID: {execution_id}")

    # Implement robust polling or use webhooks for status updates in production
    import time
    status = 'running'
    retries = 0
    max_retries = 12 # Example: Check for 1 minute
    while (status == 'running' or status == 'pending') and retries < max_retries:
        time.sleep(5)
        status_response = client.workflows.get_execution(execution_id)
        status = status_response['status']
        print(f"Current status: {status}")
        retries += 1

    print(f"Final status: {status}")
    if status == 'completed':
        print("Workflow completed successfully.")
        # Potentially retrieve outputs if configured
        # outputs = client.workflows.get_execution_outputs(execution_id)
        # print(f"Outputs: {outputs}")
    else:
        print(f"Workflow ended with status {status}. Check logs for details.")
        error_details = status_response.get('error')
        if error_details:
            print(f"Error Details: {error_details}")

except Exception as e:
    print(f"An error occurred: {e}")

                

More Python Examples

• Uploading a local file for document processing.
• Listing pending HITL tasks and completing one.
• Executing a decision model with multiple inputs.
• Handling specific API exceptions.

Java SDK Examples

Illustrative examples for Java developers using the privately provided SDK.

// Example: Initializing client and getting document data
// Ensure SDK JAR is obtained and added to your project classpath/build system
import com.blackstoneintl.sdk.BlackstoneClient;
import com.blackstoneintl.sdk.BlackstoneConfig;
import com.blackstoneintl.sdk.models.DocumentData;
import com.blackstoneintl.sdk.exceptions.BlackstoneApiException;

// Placeholder structure - adapt to actual SDK
public class DocumentProcessor {

    public static void main(String[] args) {
        BlackstoneConfig config = new BlackstoneConfig.Builder()
            .apiKey("YOUR_PRIVATE_API_KEY")
            // .baseUrl("https://api.blackstoneai.co.uk") // Usually default
            .build();

        BlackstoneClient client = new BlackstoneClient(config);

        String documentId = "doc_abc456";

        try {
            System.out.println("Fetching data for document: " + documentId);
            DocumentData docData = client.documents().getData(documentId); // Assuming method exists
            System.out.println("Document Status: " + docData.getStatus());

            if ("completed".equals(docData.getStatus())) {
                // Assuming a structure like Map for extracted data
                var extracted = docData.getExtractedData();
                if (extracted != null && extracted.containsKey("invoice_number")) {
                     System.out.println("Extracted Invoice Number: " +
                        extracted.get("invoice_number").getValue() +
                        " (Confidence: " + extracted.get("invoice_number").getConfidence() + ")");
                }
                // Process other extracted fields...
                 System.out.println("Full Extracted Data: " + extracted);
            } else if ("failed".equals(docData.getStatus())) {
                 System.err.println("Document processing failed. Check platform logs.");
                 // Potentially retrieve error details if available in docData
            }

        } catch (BlackstoneApiException e) {
            System.err.println("API Error: " + e.getStatusCode() + " - " + e.getMessage());
            // Handle specific API errors
        } catch (Exception e) {
            System.err.println("An unexpected error occurred: " + e.getMessage());
            e.printStackTrace();
        }
    }
}
                

More Java Examples

• Triggering a workflow with complex nested inputs.
• Handling specific API exceptions (e.g., NotFoundException, RateLimitException).
• Uploading documents using InputStream.

.NET SDK Examples (C#)

Code snippets for .NET developers using the privately provided SDK library.

// Example: Listing workflows using the .NET SDK
// Ensure SDK DLL is obtained and referenced in your project
using Blackstone.Sdk; // Assuming root namespace
using Blackstone.Sdk.Models; // Assuming model namespace
using System;
using System.Threading.Tasks;

public class WorkflowService
{
    private readonly IBlackstoneClient _client; // Assuming an interface

    // Obtain API key securely (e.g., config, secrets manager)
    public WorkflowService(string apiKey)
    {
        // Assuming client initialization - adapt to actual SDK structure
        _client = BlackstoneClientFactory.Create(apiKey);
    }

    public async Task ListWorkflowsAsync()
    {
        Console.WriteLine("Fetching workflows...");
        try
        {
            // Assuming ListAsync exists and returns a response object with Data and TotalCount
            var workflowsResponse = await _client.Workflows.ListAsync(limit: 50);
            Console.WriteLine($"Found {workflowsResponse.TotalCount} workflows:");

            if (workflowsResponse.Data != null) {
                foreach (var workflow in workflowsResponse.Data)
                {
                    Console.WriteLine($"- ID: {workflow.Id}, Name: {workflow.Name}, Status: {workflow.Status}");
                }
            } else {
                 Console.WriteLine("No workflows returned in the response data.");
            }
        }
        catch (BlackstoneApiException ex) // Assuming a specific exception type
        {
            Console.WriteLine($"API Error ({ex.StatusCode}): {ex.ErrorDetails?.Message ?? ex.Message}");
            // Handle error (e.g., log, retry)
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An unexpected error occurred: {ex.Message}");
        }
    }
}
                

More .NET Examples

• Uploading files using Stream for document processing.
• Interacting with the Decision Engine and handling different outcome types.
• Managing HITL tasks assigned to users within an application.
• Integrating with dependency injection frameworks.

API Reference

Detailed reference for the Blackstone Platform REST APIs. Automate tasks, manage resources, and integrate Blackstone functionality into your applications using standard HTTP requests.

Authentication

All API requests must be authenticated. We support two primary methods:

• API Keys:
  • Generate keys from the Admin console under 'API Credentials'. Keys are typically prefixed (e.g., bsk_live_..., bsk_test_...).
  • Include the key in the Authorization header: Authorization: Bearer YOUR_API_KEY.
  • Best suited for server-to-server integrations. Keep keys secure and consider using separate keys for different applications or environments.
  • API keys inherit the permissions of the user or service account that created them.
• OAuth 2.0:
  • Supports Authorization Code flow (for user-delegated permissions) and Client Credentials flow (for application permissions).
  • Requires registering your application in the Admin console ('Applications' section) to get a Client ID and Client Secret.
  • Follow standard OAuth 2.0 procedures to obtain access tokens. Use the appropriate grant type based on your use case.
  • Include the obtained access token in the Authorization header: Authorization: Bearer YOUR_ACCESS_TOKEN.
  • Access tokens are typically short-lived; use refresh tokens (obtained during Authorization Code flow) to get new access tokens without re-prompting the user.
  • Refer to the detailed OAuth 2.0 Guide below for endpoints and parameters.

Core API Endpoints

Interact with the core functionalities of the platform via these REST endpoints. Base URL: https://api.blackstoneai.co.uk (or your dedicated instance URL).

Workflows API (/v1/workflows)

Manage and execute automation workflows.

• GET /v1/workflows: List available workflows accessible by the authenticated user/key.
  • Query Parameters: limit (int, default 20, max 100), offset (int, default 0), name (string, filter by name contains), status (string, active | inactive).
  • Response: Paginated list of workflow objects.
• GET /v1/workflows/{id}: Retrieve details of a specific workflow, including its structure (steps, configuration) and status.
  • Path Parameter: id (string, workflow ID).
  • Response: Workflow object.
• POST /v1/workflows/{id}/trigger: Asynchronously trigger a workflow execution.
  • Path Parameter: id (string, workflow ID).
  • Request Body (JSON): { "inputs": { ... }, "callback_url": "..." } where inputs matches the workflow's trigger schema. callback_url is optional for webhook notification on completion.
  • Response Body (JSON): { "execution_id": "exec_abc123", "status": "pending" }
• POST /v1/workflows/{id}/triggerSync: Synchronously trigger a workflow and wait for completion (subject to timeout limits, typically 30-60 seconds). Suitable for short-running workflows where an immediate result is needed. Response body includes final status and outputs.
• GET /v1/workflows/executions: List recent workflow executions.
  • Query Parameters: workflow_id, status (pending|running|completed|failed|cancelled), created_after (ISO 8601 timestamp), created_before (ISO 8601 timestamp), limit, offset.
  • Response: Paginated list of execution objects.
• GET /v1/workflows/executions/{execution_id}: Get the status, start/end times, inputs, outputs (if completed successfully), and error details (if failed) for a specific execution.
• GET /v1/workflows/executions/{execution_id}/logs: Retrieve detailed step-by-step logs for a workflow execution (useful for debugging). Supports pagination.
• POST /v1/workflows/executions/{execution_id}/cancel: Attempt to cancel a running workflow execution. Returns success if cancel request accepted, but doesn't guarantee immediate termination.
• POST /v1/workflows: Create a new workflow (typically done via UI, but API available for programmatic creation). Requires workflow definition JSON in request body.
• PUT /v1/workflows/{id}: Update an existing workflow definition. Requires full workflow definition JSON.
• DELETE /v1/workflows/{id}: Delete a workflow definition (use with caution).

Documents API (/v1/documents)

Manage document processing tasks.

• POST /v1/documents: Upload a document for processing. Request uses multipart/form-data.
  • Form Fields: file (binary file data), model_id (string, optional, specific model to use), classification_hint (string, optional, e.g., 'invoice', 'contract'), metadata (JSON string, optional, key-value pairs for custom tags), callback_url (string, optional).
  • Response Body (JSON): { "document_id": "doc_xyz789", "status": "pending" }
• GET /v1/documents/{id}: Get the current status of document processing (pending, uploading, classifying, extracting, validating, review_pending, completed, failed) and basic metadata.
• GET /v1/documents/{id}/data: Retrieve extracted data (JSON format), confidence scores for each field, and potentially bounding box coordinates (bbox: [x_min, y_min, x_max, y_max]). Includes document metadata.
• GET /v1/documents/{id}/text: Retrieve the full plain text content extracted by OCR, often structured by page.
• GET /v1/documents/{id}/pages/{page_number}/image: Retrieve an image representation of a specific page (e.g., PNG format). Query parameter format=png|jpg.
• POST /v1/documents/{id}/validate: (For HITL) Submit validated/corrected data after human review. Request body contains the updated JSON data structure.
• GET /v1/documents/models: List available document processing models (pre-built and custom) accessible to the user/key.
• DELETE /v1/documents/{id}: Delete a processed document and its associated data (subject to permissions and retention policies).

Decisions API (/v1/decisions)

Execute decision logic models (rule sets, ML models).

• GET /v1/decisions/models: List available decision models.
• GET /v1/decisions/models/{model_id}: Get details about a specific decision model, including its expected input schema (JSON Schema format).
• POST /v1/decisions/models/{model_id}/execute: Execute a decision model synchronously.
  • Request Body (JSON): { "inputs": { ... } } where inputs match the model's schema.
  • Response Body (JSON): { "decision_id": "dec_abc123", "model_id": "...", "outcome": "...", "confidence": 0.95, "reasoning": [...], "outputs": { ... } }. outcome is the primary result, outputs contains any additional data generated, reasoning provides explanation (if available).

Users API (/v1/admin/users) - Admin Only

Placeholder: Detailed endpoints for listing, creating, updating, deleting users and managing group memberships.

Tasks API (/v1/tasks) - Human-in-the-Loop

Placeholder: Detailed endpoints for listing tasks (by user, group, status), claiming tasks, retrieving task details (including context/data), and submitting task completion/outcomes.

Connectors API (/v1/connectors)

Placeholder: Detailed endpoints for listing available connector types, creating/managing specific connection instances (storing credentials securely), testing connections.

Webhooks

Configure webhooks in the Admin console under 'API Settings' -> 'Webhooks'. Provide your HTTPS endpoint URL and select the events you wish to subscribe to.

• Supported Events: workflow.execution.started, workflow.execution.completed, workflow.execution.failed, document.processing.completed, document.processing.failed, document.review.required, task.assigned, task.completed, user.created (admin), connection.status.changed etc. (Refer to specific event list in Admin console).
• Payload Structure: Standard JSON structure with event_id, event_type, timestamp, version, and a nested data object containing event-specific details.
• Signature Verification: Each request includes a Blackstone-Signature-v1 header. Verify using HMAC SHA-256 with your webhook secret key and the raw request body concatenated with the timestamp from the header. Detailed steps and code examples are available in the Developer Guides section.
• Retries & Idempotency: Expect potential duplicate deliveries. Design your endpoint to be idempotent using the event_id. Failed deliveries are retried up to 5 times with exponential backoff. Monitor webhook delivery status in the Admin console.

Rate Limits & Errors

API usage is subject to rate limits based on your subscription tier. Exceeding these limits will result in a 429 Too Many Requests error.

• Default Limits (Illustrative): Check your specific plan agreement. Limits may vary per endpoint category (e.g., workflow triggers vs. data retrieval).
• Response Headers: Use X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset headers to monitor your usage and implement client-side throttling or backoff.
• Handling Rate Limits: Implement exponential backoff with jitter in your client-side code when encountering 429 errors to avoid overwhelming the API.
• Common Errors: Understand standard HTTP status codes and check the JSON error body for specific type, code, and message details to aid debugging.

{
  "error": {
    "type": "invalid_request_error",
    "code": "validation_failed",
    "message": "Input validation failed for 'email' field.",
    "param": "inputs.email",
    "request_id": "req_lmn456pqr"
  }
}

OAuth 2.0 Guide (Endpoints)

Key endpoints for OAuth 2.0 flows:

• Authorization URL: https://auth.blackstoneai.co.uk/authorize (Parameters: response_type=code, client_id, redirect_uri, scope, state).
• Token URL: https://auth.blackstoneai.co.uk/oauth/token (Parameters: grant_type (authorization_code or client_credentials or refresh_token), code (if auth code grant), redirect_uri (if auth code grant), client_id, client_secret, refresh_token (if refresh grant)).
• Required Scopes (Examples): workflows:read, workflows:trigger, documents:read, documents:write, tasks:read, tasks:complete. Consult specific endpoint documentation for required scopes.

Administrator Guides

Guides for platform administrators on setup, configuration, security, and maintenance. Ensure your Blackstone instance runs smoothly and securely.

User & Role Management

Control who has access to the platform and what they can do.

• Inviting New Users: Access the 'Users' section in the Admin Console. Click 'Invite User', enter email address, select initial role. Manage license counts and pending invitations.
• Default Roles:
  • Admin: Full platform access, including user management, security settings, billing.
  • Developer: Can build/edit workflows, manage API keys (own), create models, but cannot manage users or core settings.
  • Business User: Can typically trigger/monitor specific workflows, view dashboards, complete assigned tasks. Cannot build/edit workflows or models.
  • Reviewer: Limited access, primarily focused on completing Human-in-the-Loop tasks assigned to them.
• Defining Custom Roles: Navigate to 'Roles & Permissions'. Create a new role, give it a name (e.g., "AP Clerk"), and select specific granular permissions (e.g., 'View Invoices', 'Validate Extracted Data', 'Trigger AP Workflow', 'Complete AP Review Tasks'). Assign users or groups to custom roles.
• Single Sign-On (SSO) Integration:
  • Configuring SAML 2.0 Integration with providers like Okta, Azure AD, PingFederate.
  • Configuring OpenID Connect (OIDC) Integration.
  • Just-In-Time (JIT) Provisioning: Automatically creating Blackstone accounts for users logging in via SSO for the first time (assign a default role for JIT users).
  • Mapping SSO groups to Blackstone roles for automatic role assignment.
• Setting up Multi-Factor Authentication (MFA): Enforcing MFA policies for all users or specific roles (supports TOTP apps like Google Authenticator, Authy).
• Managing User Groups: Creating groups (e.g., "Finance Team", "HR Department") for easier permission assignment and task routing.
• Deactivating and Deleting Users: Best practices for offboarding users. Transfer ownership of workflows/models before deletion if needed.

Security & Compliance

Configure security settings to meet your organization's policies and ensure compliance.

• Data Encryption: Details on TLS 1.2+ for data in transit and AES-256 for data at rest. Options for customer-managed encryption keys (Enterprise plans) - contact support for details.
• Network Security:
  • Configuring IP Whitelisting for restricting access to the platform UI and API in 'Settings' -> 'Network Security'.
  • Setting up VPC Peering or PrivateLink for secure connections (Cloud deployments, Enterprise feature).
  • On-Premise Agent Firewall Rules: Ensure agents can establish outbound HTTPS connections to necessary Blackstone endpoints.
• Audit Logs: Accessing and exporting detailed audit logs via 'Admin Console' -> 'Audit Logs'. Filter by user, date range, event type. Configure log export frequency and destination (e.g., S3, SIEM integration). Set log retention period.
• Data Retention Policies: Define rules in 'Settings' -> 'Data Management'. Set policies based on data type (e.g., processed documents, execution logs) and age. Apply policies globally or per workspace.
• Compliance Center: Information on accessing relevant compliance documents (SOC 2, HIPAA BAA, GDPR DPA) via the client portal or upon request.
• Secrets Management: Securely storing credentials (API keys, passwords) in the encrypted vault ('Settings' -> 'Credentials'). Assign permissions for credential usage in workflows.
• Session Management: Configure session timeout duration and idle timeout settings in 'Settings' -> 'Security'.

Monitoring & Maintenance

Keep your Blackstone instance running optimally.

• Admin Dashboard Overview: Monitoring license usage, workflow execution volume/success rates, document processing stats, agent status, system health.
• System Performance Metrics: Understanding CPU/Memory (on-prem), API Latency, Queue Depths. Setting thresholds for alerts.
• Configuring Alerts: Setting up email or webhook notifications for critical system or workflow events in 'Settings' -> 'Alerts'.
• Backup and Recovery: Understanding cloud backup policies or documenting on-premise backup procedures.
• Platform Updates: Reviewing release notes. Managing maintenance windows (cloud) or applying updates (on-premise).
• Agent Management: Monitoring status, version, logs, and connectivity of on-premise agents via 'Admin Console' -> 'Agents'.

Environment Management

Manage separate environments for development, testing, and production, ensuring safe deployment practices.

• Setting up Sandbox Environments: Information on requesting and accessing non-production instances (availability depends on plan).
• Promotion Process: Recommended practices using export/import features for workflows, models, configurations. Utilizing version control externally. Guidance on testing strategies.
• Environment Variables: Defining and using environment-specific variables (e.g., API endpoints, credentials) within workflows and connections.
• User Access Control Across Environments: Assigning appropriate roles and permissions specific to each environment (Dev, Staging, Prod).

User Guides & Tutorials

Learn how to use the Blackstone platform effectively, build workflows, and manage your automations with these step-by-step guides.

Platform Basics

Get acquainted with the main components and navigation of the Blackstone platform interface.

Building Workflows - Step-by-Step Tutorials

Follow these detailed tutorials to automate common business processes.

Best Practices

Setup & Configuration (User)

Quick guides for connecting common user resources.

• Connecting Your Email Account (Gmail, Outlook 365) - Using OAuth 2.0 authentication flow within the platform.
• Setting up Cloud Storage Connections (Google Drive, OneDrive, Dropbox, Box) - Authorizing access via OAuth.
• Configuring Personal Notification Preferences - Setting up email/platform alerts for task assignments or workflow outcomes.
• Basic Troubleshooting for User Connections - Common issues like expired tokens or permission errors.

Troubleshooting & FAQ

Find solutions to common problems and answers to frequently asked questions encountered while using the platform.

Common Issues & Solutions

• Issue: Workflow Stuck in 'Running' State
  • Check logs for long-running steps (e.g., complex API call, large document processing).
  • Verify external system availability if the workflow is waiting for a response.
  • Check for infinite loops in the workflow logic.
  • Review resource limits (CPU/memory) if using on-premise agents.
  • Contact support if the issue persists beyond expected processing times, providing the Execution ID.
• Issue: Incorrect Data Extracted from Document
  • Open the document in the Document Studio and verify the template's field boundaries. Adjust if needed.
  • Provide more diverse training examples for the document type, especially examples similar to the problematic one. Retrain the model.
  • Check if pre-processing (like deskew or despeckle) might improve OCR quality for that document.
  • Implement post-extraction validation rules to catch inconsistencies (e.g., date formats, sum checks).
  • Use regular expressions within the template for more specific pattern matching if applicable.
• Issue: Connector Action Fails (e.g., Salesforce, SAP)
  • Verify connection credentials are correct and haven't expired. Re-authenticate the connection in 'Settings' -> 'Connections'.
  • Check if the user account associated with the connection has the necessary permissions in the target system (e.g., create record, read data).
  • Ensure input data matches the expected format and data types for the target system's API.
  • Check the target system's status page or API documentation for known issues or maintenance.
  • Review detailed error messages returned by the connector in the workflow execution logs.
• Issue: Email Trigger Not Firing
  • Confirm the email account connection is active and authorized ('Settings' -> 'Connections').
  • Double-check the trigger's filter conditions (sender, subject, folder). Ensure they exactly match incoming emails (case sensitivity might apply).
  • Verify the email is arriving in the specified folder being monitored (not Junk, not automatically moved by another rule).
  • Check if there are conflicting rules in your email client moving the email before the trigger can process it.
  • Review platform audit logs ('Admin Console' -> 'Audit Logs') for any errors related to the email connection or trigger processing.
• Issue: Decision Engine Returns Unexpected Outcome
  • Use the Decision Modeler's testing feature ('Test' tab) to simulate the execution with the exact input data that caused the issue.
  • Review the decision table or rule set logic for correctness, completeness, and rule priority (if applicable).
  • Ensure input data types match the expected types in the decision model (e.g., sending a string when a number is expected).
  • Check if the correct version of the decision model is published and being called by the workflow step.
  • Review execution logs for the 'Execute Decision Model' step to see inputs received and outputs generated.

Frequently Asked Questions (FAQ)

• How is my data secured during processing and storage?

  We prioritize security. Data is encrypted using industry standards (TLS 1.2+ in transit, AES-256 at rest). Access is strictly controlled via Role-Based Access Control (RBAC). We undergo regular security audits and comply with SOC 2 Type II standards. Features like PHI/PII detection and redaction are available. Refer to the Security & Compliance section in the Admin Guides for detailed information.

• What is the difference between a pre-built model and a custom model in IDP?

  Pre-built models (e.g., Invoices, Receipts, Passports) are trained by Blackstone on large, diverse datasets and offer good performance out-of-the-box for common document types. Custom models are trained specifically on your documents within the Document Studio, allowing you to achieve higher accuracy for unique layouts or specific fields critical to your business.

• Can workflows interact with systems behind a firewall?

  Yes, through our secure On-Premise Agent. This lightweight application is installed within your network (details provided privately via client portal) and establishes a secure, outbound-only connection to the Blackstone cloud platform. This allows workflows running in the cloud to securely interact with your internal databases, APIs, file shares, or applications without requiring you to open inbound ports in your firewall. See the Agent Management guide.

• How does the Human-in-the-Loop (HITL) process work?

  When a workflow encounters a situation requiring human input (defined by you, e.g., low confidence score, specific business rule, approval step), it pauses and creates a task using the 'Assign Task' action. This task appears in the designated user's or group's Task Queue in the platform UI. The user reviews the provided context and data, makes necessary corrections or decisions (e.g., Approve/Reject), and submits the task. The workflow then resumes, using the outcome of the human task to guide its next steps.

• How are platform updates handled?

  For our cloud-hosted platform, updates (including new features, performance improvements, and security patches) are rolled out regularly by Blackstone during scheduled maintenance windows, typically announced in advance. For on-premise deployments, administrators are responsible for applying update packages provided through the client portal, following the procedures outlined in the release notes and update guides.

• What level of support is included?

  Support levels depend on your subscription plan. All clients have access to this comprehensive documentation. Standard support typically includes email/ticketing access during business hours with defined response time SLAs. Enterprise plans often include enhanced SLAs, phone support options, and a dedicated Customer Success Manager (CSM) for proactive guidance and support. Please consult your contract or contact your account representative for specifics.