Control Plane: Brings order to multi-model, multi-agent AI

At the heart of the Control Plane is the Context Engine, a workflow orchestrator for highly dynamic interactions and complex, multi-step, long-running processes. The Context Engine is the serverless runtime for the Semantic AI Harness. It is event-driven, asynchronous, concurrent with massively parallel processing. It is exposed by a Gateway with a Behavioral Interface.

The Context Engine pushes beyond GREP tools, GraphRAG retrieval, iterative Loops, static DAGs, markdown files and one-off DSLs. These primitive engineering techniques result in opaque and brittle solutions that lack useful developer abstractions. The Control Plane benefits from EnterpriseWeb’s common domain, object, interaction and transaction model with shared tools and common governance to eliminate redundant and inconsistent boilerplate code.

The Context Engine

• Dynamically assembles relevant context (typed objects, data and workflows)
• Semantically rewrites and routes prompts to language models
• Composes and configures tasks into complex, multi-step and long-running workflows
• Orchestrates distributed solution endpoints, virtualized data sources, federated components, and physical devices
• Enforces constraints (e.g., ontological axioms, business rules, workflow logic, governance policies and transaction guarantees)
• Automatically generates vector embedding for natural language processing
• Federates SQL, GQL and SPARQL queries (zero-copy integration)

The Semantic AI Harness enables the declarative design and management of event-driven, goal-oriented, context-aware processes. Flow logic, business rules, integration, and data modeling are all performed in one tool for ease, speed and power of design.

The no-code design environment enables the declarative modeling of a process as a set of loosely coupled tasks connected by events and rules (i.e., intelligent graph-based workflows). EnterpriseWeb makes it easy for organizations to rapidly model dynamic non-linear processes that unfold based on conditions, with each instance following its own unique path based on its interaction context. It supports:

• Policy-controlled closed-loop automation
• Smart transformation pipelines
• Intent-based orchestration
• Distributed Transactions
• Programmable Infrastructure/Networking
• Intelligent model routing
• Dynamic interface and protocol pipeline generation (i.e., serverless Gateway)

In the Semantic AI Harness, everything is connected through shared domain knowledge, types and objects provided by the Knowledge Plane. It supports catalog-driven, declarative composition.

Developers can model complex logic referencing concepts and types in the ontology, nodes in the topology, entities in the knowledge graph and platform services in the system library. EnterpriseWeb supports simple and complex logic.

Simple logic – Declaratively model as re-usable decision tree templates, which includes the ability to invoke attached logic or external decision engines (i.e., simple decision workflow within a task)

Complex logic – Declaratively model as re-usable state chart templates, which includes the ability to invoke attached logic or external decision engines (i.e., complex decision workflow within a task)

EnterpriseWeb’s no-code platform provides a model-driven process for onboarding distributed solution elements, federated components, virtualized data sources and physical devices. Customers can import files, docs, models and reference public endpoints. EnterpriseWeb introspects the information, performs algorithmic mapping, entity extraction, dynamic typing and generates a typed, immutable object registered in a catalog with change management and governance. When composing workflows and services, domain objects can be simply linked from the system catalog and inventory.

EnterpriseWeb’s design environment also allows queries, analytics and inferences to be embedded, enabling a broad evaluation of global context to optimize decisions and actions. Customers can declaratively model a task with a series of operations that call internal system capabilities, as well as external language models, algorithms, analytics and rules engines, which the runtime will orchestrate based on policies and conditions. EnterpriseWeb’s no-code platform allows developers to rapidly model “Complex Events” by simply composing tasks with objects, operations and rules, instead of writing custom algorithms. The Control Plane handles the implementation details at runtime. Developers don’t have to worry about the technical complexity of ad-hoc Hybrid Analytics Transaction Processing (i.e., HTAP).

Don’t exclusively depend on a language model when algorithms, analytics and rules often provide a smarter, faster, better result. EnterpriseWeb allows customers to specify the “best tool for the job”. Developers can declaratively model complex events that invoke Language models, AI runtimes, analytics engines and databases based on policies. In this way, EnterpriseWeb enables targeted and precise use of language models, while supporting hybrid-reasoning for rich situational awareness.

no custom code, manual integration, script writing or interface development

EnterpriseWeb provides Blueprints for common workflow patterns to ease and speed modeling of event-driven goal-oriented business, infrastructure and network processes (e.g., Order-to-Cash, SaaS integration, deployment workflows, NetOps automation).

System Blueprints are generic process patterns independent of any domain

Customer Templates bind blueprints to a domain and configuration for a use case

Workflow Instances bind templates to interaction-specific context

At runtime, EnterpriseWeb late-binds domain, use case and instance context and executes all operations. The declarative design and the event-driven runtime allow for the dynamic customization of every system response within workflow logic and governance policies and with rich logs and distributed traces of all actions. The generic workflow patterns support re-use and mass customization. Instead of being static and brittle, they are dynamic and responsive.

The cloud-native, asynchronous, concurrent run-time natively supports parallel execution of tasks and operations for maximum performance.

Process models and instances are simply other typed objects that reside in the KG catalog and inventory respectively. They are declaratively modeled in the same graph language (i.e., Code-as-Data) as the KG, ontology and topology so nothing is lost in translation between domain semantics, objects and workflows. Ontological axioms, business rules, workflow logic and governance policies are all enforced by the same runtime.

EnterpriseWeb features a library of Platform Services providing rich middleware capabilities. Platform Services include communication, integration, transformation, automation, configuration, orchestration, generation, and learning. They are implemented as serverless, event-driven functions that are dispatched, configured and coordinated by the runtime per declarative policies. No execution stack or system integration required. While EnterpriseWeb supports integration and federation, no 3rd-party gateways, brokers, integration tools, workflow engines, orchestrators, or protocol servers are required.

EnterpriseWeb provides common serverless middleware services across cloud, data center and edge environments, which eliminates deep lock-in to each hyperscaler’s native APIs and stacks. It allows for the rationalization of solution architecture and tool consolidation.

In addition to the no-code design environment, EnterpriseWeb provides rich management controls:

• Process Management
  • API-first (REST) commands: Get instance, List instances, Get Schema, Launch Instance
  • Graphic User Interface (JSON) management console with Task List, Catalog and Inventory
• Serverless Gateway
  • Library of industry standard protocols
  • Objects representing distributed elements, virtualized data sources, federated components, and physical devices model interface formats, schema and operations
  • Dynamically generated interface and protocol pipelines
  • No manual interface development
  • No need for separate protocol servers
• Serverless API-first Middleware Functions (Platform Services)
  • Attached by type system to implement required operations, or declaratively specified as part of a workflow
  • Communicate, Integrate, Transform, Automate, Configure, Orchestrate, Learn
• Security/Identity
  • All clients (human, system and agents) are registered with identity and permissions
  • Supports trusted Certifications and Authorization schemes
  • Supports LDAP, Kerberos, Single Sign-On, etc
  • Role-based and Attribute-based Access Control
  • Asynchronous, virtualized sessions - no long-running threads (i.e., small attack surface)
  • Security reevaluated with every interaction
  • No root access
• Transaction Management
  • Isolated, logically partitioned, ephemeral processes
  • Reliable messaging (e.g., idempotency, immutability)
  • Configurable policies for retries, exceptions, circuit-breakers, roll-back, compensations, and counter-measures
  • Wraps every transaction in a transitive closure
• State Management
  • Short term transaction memory for intermediary results and blackboard for parallel processing (i.e., safe, scalable inter-process communications)
  • Async, immutable, log-style, append-only durable memory (non-blocking, non-locking)
  • Logs with distributed trace
  • Temporal history – supports predictive analytics and learning
  • Automatic indexing and tagging - supports predictive analytics and learning
• Model-driven onboarding of new solution elements,
  • Configurable policy-controlled validations
  • Automated conformance checking
  • Configurable TestOps process
    • Deploy to DMZ
    • Execute mapped tests based on object type
    • Report issues and allow iterative debug
    • Register in catalog
• System Catalog
  • Includes 100+ modeled adaptors for common system, infrastructure and network applications (open source and commercial)
  • Version-control
  • Model-driven change management
• System Inventory
  • Includes 100+ modeled adaptors for common cloud and SaaS endpoints
  • Observability
  • Continuous Assurance
  • Service lifecycle management
  • Configuration history