01
Platform Overview
What GenAI is, and what it deliberately is not
Foundation

GenAI is Venerable's enterprise Generative AI platform, designed to extract data, automate workflows, and generate insights using agent-based AI solutions. It is built to support production-grade AI usage in regulated environments by embedding governance, auditability, and human oversight directly into its core architecture.

GenAI treats AI as enterprise infrastructure — governed, auditable, and human-centered by default — not a collection of isolated tools bolted onto a business.

GenAI hosts multiple purpose-built AI agents, each aligned to a specific business problem, while inheriting common platform services such as security guardrails, observability, evaluation, policy-based access control, and Human-in-the-Loop (HITL) workflows.

What it IS
A shared infrastructure layer for enterprise AI: governed, auditable, multi-agent, policy-controlled. Every agent built on the platform inherits its controls automatically.
What it is NOT
A collection of one-off AI tools. Not a chatbot wrapper. Not an isolated PoC. Every AI capability is a production-grade agent with full governance, not a standalone experiment.
02
Design Principles
Three commitments applied to every agent on the platform
Core

Security, compliance, auditability, and traceability are foundational capabilities rather than after-thoughts. Every agent on the platform inherits these properties without additional implementation effort from the team building the agent.

All AI capabilities are delivered as agents that can reason, orchestrate tools, and interact with users or systems through standardized workflows. There is no ad-hoc LLM invocation — every AI capability is an agent with defined inputs, outputs, and governance controls.

AI augments decision-making rather than replacing it, with HITL review and override capabilities embedded across agents. High-risk or low-confidence outputs are automatically routed to human review before any downstream action is taken.

Design intent: governance is built into the platform, not bolted onto individual agents. Every new agent automatically inherits guardrails, audit logging, HITL routing, and access control — teams focus on business logic, the platform guarantees the governance.
03
High-Level System
Four layers — the same stack shown above, expanded
Architecture

Every entry point into the platform, from human users to other systems.

  • Web UI for user interaction
  • REST APIs for system-to-system integration
  • Python SDK for internal tools and notebooks
  • Microsoft Teams App integration
  • MCP & A2A integration
  • Event, batch, and request-response execution modes

Home to GenAI's purpose-built agents — IntelliDoc, FundIntel, and DeepLens.

  • Accepts domain-specific inputs
  • Executes AI-driven reasoning and extraction
  • Produces structured outputs
  • Optionally routes results through HITL review

The common spine every agent inherits, so governance is never re-implemented per agent.

  • Agent orchestration and execution
  • Prompt and configuration management
  • Guardrail enforcement
  • Knowledge base and vector storage
  • Evaluation, observability, and audit logging

A secure, scalable, fully serverless AWS architecture supporting enterprise-grade AI workloads with strong isolation, governance, and operational resilience.

Environment & Account Isolation

Each GenAI environment is deployed into a separate AWS account, providing strong isolation across data, compute resources, IAM boundaries, and operational blast radius — keeping dev, test, and production workloads fully separated.

DEV
INTEG
ACCP
PROD
DR
VAL
Serverless, Cloud-Native Architecture

No long-running servers, event-driven and on-demand execution, automatic scaling, and built-in resiliency — powered by native AWS managed services.

AWS LambdaCompute & agent execution
Step FunctionsWorkflow orchestration, batch
EventBridgeEvent-driven triggers
Amazon S3Document storage & ingestion
DynamoDB / AuroraMetadata & execution state
API GatewaySecure API access
AWS SNSNotifications
AWS BatchBatch workloads
LLM Execution — AWS Bedrock + Guardrails

GenAI uses AWS Bedrock as its primary managed LLM service, with Bedrock Guardrails applied as part of the execution pipeline so outputs adhere to enterprise and regulatory expectations.

Bedrock LLMFoundation models
Content FilteringBedrock Guardrails
Safety & CompliancePolicy enforcement
Governed OutputConsistent across agents
CI/CD & Infrastructure Provisioning

Jenkins-based CI/CD pipelines build and deploy application code and provision cloud resources, using YAML-based templates for consistent, version-controlled, repeatable deployments across all environments.

Build code
Provision resources
Promote across envs
Audit & version control
04
Platform Design Diagram
Authoritative reference for component boundaries and execution flow

The GenAI Platform Design Diagram (attached separately) is the authoritative reference for component boundaries, execution flow, service interactions, and control points for governance and HITL. No additional interpretation beyond the diagram is required.

05
Agent Architecture
What an agent is, what it's built from, and the framework that runs it
Core

A long-lived AI construct that orchestrates multiple steps, delegates work to tools, applies business logic and validation, and produces auditable outputs. Agents are independent in function but standardized in behavior through shared platform capabilities.

Deterministic, callable functions agents use to retrieve data, parse and chunk content, validate and reconcile, and persist or enrich results — executed under agent control and logged for traceability.

GenAI uses the Strands framework as its primary agentic AI framework. Strands Agents act as orchestrators for multi-step workflows, coordinate tool execution, maintain execution context across steps, and support both synchronous and event-driven execution — implementing reason–act–observe loops for complex enterprise workflows such as document processing, portfolio extraction, and evaluation pipelines.

5.4 Agent Lifecycle — 7 steps, every invocation
01Invocation — UI, API, or event-based
02Orchestration via Strands Agent
03Tool execution and reasoning
04Guardrail application
05Confidence scoring and validation
06Optional HITL review
07Final output persistence and audit capture
06
Authentication & Authorization
Two questions, answered by two separate systems
Security
6.1 — Who are you (Authn)
Handled using Microsoft Entra ID across the platform. Web UI access authenticated via Entra SSO. Users authenticate through the enterprise identity provider. Enforced consistently across all environments.
6.2 — What can you do (Authz)
Policy-based access control powered by AWS Verified Permissions and Cedar policies. Fine-grained authorization decisions. Role- and resource-aware access control. Policies evaluated centrally, applied at runtime.
Key principle: authentication and authorization are enforced at the platform level, not per-agent. Every agent automatically inherits these controls without additional implementation.
07
Governance, Guardrails & HITL
Embedded into every layer — not bolted on after output is produced
Governance

Governance is embedded into every layer of the platform. The four pillars work together to ensure every AI output is controlled, observable, and auditable.

GuardrailsConstrain AI behavior at inference time
HITL RoutingHigh-risk or low-confidence outputs reviewed by humans
ObservabilityEnd-to-end traceability across every execution
Audit LogInputs, outputs, decisions, and overrides captured

A growing agent library delivers immediate business value, alongside an agent builder model that lets teams create new agents which automatically inherit platform controls — enabling scalable AI adoption without fragmentation or duplicated governance logic.

Why it matters: every new agent gets guardrails, audit logging, HITL routing, and access control for free. Teams build business logic; the platform guarantees the governance.
App.
Source Reference
Original working notes this framework was transcribed from