Skip to content
View subhamviky's full-sized avatar

Block or report subhamviky

Block user

Prevent this user from interacting with your repositories and sending you notifications. Learn more about blocking users.

You must be logged in to block users.

Content in all repositories owned by your account will be closed.
Maximum 250 characters. Please don’t include any personal information such as legal names or email addresses. This note will only be visible to you.
Report abuse

Contact GitHub support about this user’s behavior. Learn more about reporting abuse.

Report abuse
subhamviky/README.md

Hi, I'm Subham Gupta 👋

Principal Engineer and Systems Architect & AI Architecture Framework Author | Enterprise-to-Cloud & Agentic AI Architecture

Translating 13+ years of enterprise transaction integrity, distributed-systems discipline, and cloud-native architecture into governed Agentic AI systems.

Status: Solo-authored architecture R&D, actively evolving. The architectural spikes and the completed projects built from them exercise the framework ideas on non-production workloads; nothing here claims production validation unless a repository explicitly states otherwise.

The Journey at a Glance

 1. ARCHITECTURAL SPIKES          2. FRAMEWORKS                  3. COMPLETED PROJECTS
    (Mar - Apr 2026)                 (Apr - Nov 2026)               (Nov 2026)
 hands-on experiments that  -->   the recurring controls   -->   the same three systems,
 found the patterns and the       became reusable contracts:     rebuilt by consuming the
 gaps: the same controls          E2A, A2C, P0, G2C, AI-DLC,     frameworks; now one working
 rebuilt by hand everywhere       Deterministic CQRS, DSA        Order-to-Cash landscape
Project 1. The spike 3. The completed project What the frameworks changed
Financial Settlement Platform spike/v1-original: three Java services, Kafka, Redis, Spring AI main: CQRS ledger with saga and outbox + Python audit agent · Azure IaC E2A Deterministic CQRS profile, E2A agent + RAG
Payment Reconciliation Engine spike/v1-original: serverless payment intake on AWS, agent layer planned main: DSA-governed matching, agent proposes / rules decide, ledger write-offs · AWS IaC applied in CI DSA, E2A propose-authorize-confirm
Order-to-Cash Agentic AI spike/v1-original: five-agent LangGraph design on Bedrock main: five E2A agents, governed tools, human approval, release gate · GCP IaC E2A workflow, tools, governance, AI-DLC gate

Every completed service was scaffolded by the AI-DLC pipeline (P0 + G2C + A2C) from one request file, and the three projects run together in one end-to-end demo (landscape-demo, 16 checked steps): an order in plain language, a settlement in the ledger, a bank statement reconciled, a write-off posted back.

Core Thesis

Enterprise modernization and Agentic AI are connected engineering problems.

Agentic AI increases the architectural pressure for clean application contracts, deterministic transactional boundaries, explicit state, governed tools, observable execution paths, and reliable recovery. The runtime can change substantially while many of the core engineering invariants remain recognizable.

Same enterprise engineering invariants. Different runtime. New implementation mechanisms.

A second principle follows from this:

Probabilistic intelligence may propose an action. Deterministic enterprise controls must authorize, execute, and confirm material outcomes.


How the Framework Family Emerged

The framework family did not begin as a top-down attempt to invent abstractions for Agentic AI.

It emerged through architectural spikes I built to explore and validate how enterprise-grade reliability, transaction integrity, integration, observability, and failure-management principles translate into cloud-native and Agentic AI runtimes.

Those spikes repeatedly exposed structural correspondence across runtime generations. The implementation technologies changed, but responsibilities such as contracts, idempotency, execution context, policy, observability, reconciliation, failure isolation, and deterministic systems of record remained important.

Evolution of the architecture R&D

Enterprise Transactional & Distributed-Systems Experience
                         |
                         v
              Architectural Spikes
                         |
                         v
       Discovery: stable engineering invariants
          across changing runtime models
                         |
                         v
                        E2A
            Enterprise-to-Agentic runtime
                         |
              +----------+----------+
              |                     |
              v                     v
             A2C                   P0
    governed generation     foundation/scaffolding
              |                     |
              +----------+----------+
                         |
                         v
                        G2C
             contract/class synthesis
                         |
                         v
               Further E2A evolution
                    /           \
                   v             v
        Deterministic CQRS     AI-DLC
             Profile        Assurance Lifecycle
                    \           /
                     v         v
         Completed projects: the spikes rebuilt
           by consuming the framework family

Chronology and runtime composition are deliberately different views. E2A emerged first historically, while P0 and G2C can execute earlier in a solution lifecycle because they prepare foundations and contracts before runtime execution.

The architectural spikes therefore have three roles:

  • Discovery spikes helped reveal and test the cross-runtime invariants that led to E2A.
  • Reference runtimes exercise, challenge, and refine formalized framework patterns after those patterns exist.
  • Completed projects close the loop: each spike was rebuilt on the released frameworks, and its spike is kept on a branch so the growth stays visible.

Architectural Mental Model — Structural Correspondence Across Runtimes

My core mental model comes from comparing recurring architectural responsibilities across enterprise applications, cloud-native distributed systems, and Agentic AI.

The important claim is not literal technology equivalence. An OData service is not a FastAPI router, and a Behavior Definition is not literally a BaseAgent. The useful observation is that they can occupy comparable architectural responsibilities: contract definition, exposure, execution, policy, observability, and lifecycle control.

Enterprise Runtime        Cloud-Native Runtime       Agentic Runtime
------------------        --------------------       ---------------
Domain contract       ->  API/service contract   ->  Agent/tool contract
Business operation    ->  Service/command        ->  Governed tool/action
Request context       ->  Trace/request state    ->  Workflow/agent state
Validation            ->  Policy/validator       ->  Evaluation + policy gate
Recovery              ->  Retry/saga/outbox      ->  Retry/fallback/compensation
Observability         ->  Logs/metrics/traces    ->  + tokens/evals/tool traces
System authority      ->  Database / SoR         ->  Deterministic SoR remains authoritative

This cross-runtime correspondence became the conceptual basis for E2A structural isomorphism.


Architecture R&D — Framework Family

The frameworks are different lifecycle and control layers of one evolving architecture, not six independent abstractions.

Current architectural composition

BUSINESS / ARCHITECTURE INTENT
             |
             v
            P0
     Context + Scaffolding
             |
             v
            G2C
       Contract Synthesis
             |
       +-----+-----+
       |           |
       v           v
      A2C         E2A
 Generation   Runtime Execution
       |           |
       +-----+-----+
             |
             v
           AI-DLC
    Evaluation / Assurance

Deterministic CQRS applies where transactional
semantics require stronger correctness guarantees.
Framework / profile Primary responsibility Intended outcome
E2A Governed runtime for agents, RAG, tools, enterprise integration, and execution context Auditable Agentic AI execution
A2C NFR-aware generation of code, tests, configuration, IaC, and delivery artifacts Consistent engineering artifacts
P0 Project, runtime, configuration, and platform scaffolding Repeatable foundation
G2C Governed contract synthesis; Generate-to-Class is the initial concrete realization Implementation-ready contracts and class structures
AI-DLC Evaluation and assurance across generated artifacts and runtime behavior Evidence of quality, safety, and fitness
Deterministic CQRS Profile Commands, queries, idempotency, outbox, concurrency, and compensation Safe state mutation and scalable reads

E2A — Enterprise-to-Agentic

🔗 github.com/subhamviky/e2a-framework

E2A is the runtime and governance core of the family. It explores:

  • Stable public lifecycle entry points
  • Protected extension hooks for bounded specialization
  • Explicit request-scoped execution context
  • Governed RAG and knowledge boundaries
  • Governed REST/MCP tool execution
  • Evaluation before trust
  • Reliability, observability, and cost controls
  • Deterministic confirmation before material side effects are declared successful

Multi-cloud portability: E2A is designed around stable contracts and provider adapters. Agent implementations written exclusively against supported common contracts can remain largely provider-independent, while provider adapters, configuration, model capabilities, and cloud-specific infrastructure remain intentionally isolated.

A2C — Architecture-to-Code

🔗 github.com/subhamviky/a2c-framework

A2C explores Correct-by-Design generation: moving architectural and NFR constraints from loose prompt instructions into governed generation policies.

Representative generated artifacts include application code, tests, configuration, Infrastructure as Code, CI/CD definitions, and policy-aware templates.

P0 — Project Bootstrap / Phase Zero

P0 separates project and platform foundation from later business-code generation.

Current concepts include build/dependency metadata, directory structure, environment configuration, README/license scaffolding, container artifacts, developer automation, runtime/platform selection, and baseline quality/security integration points.

G2C — Governed Contract Synthesis / Generate-to-Class

G2C translates architectural intent into implementation-ready contracts. Generate-to-Class is the initial concrete realization, where E2A-governed generator agents produce framework and domain class structures.

The broader direction includes class/interface, workflow, data, API/event, NFR, and test contracts.

AI-DLC — Evaluation & Assurance Lifecycle

AI-DLC is a cross-cutting lifecycle spanning contract synthesis, generation, runtime execution, and production feedback. It covers static policy checks, deterministic tests, AI evaluations, integration verification, runtime reliability/cost evaluation, and business-outcome feedback.

Deterministic CQRS Profile

The CQRS profile extends E2A where Agentic workflows interact with material transactional state. It keeps command correctness, scalable reads, idempotency, concurrency, transactional outbox behavior, events, and compensation inside deterministic control boundaries.


🎯 Vision — From Field Patterns to Reusable Platform Capabilities

The long-term direction is to turn recurring enterprise AI engineering friction into reusable platform capabilities.

Recurring need Framework response Potential productization form
Governed Agentic AI runtime E2A Agent execution / governance control plane
NFR-aware artifact generation A2C Developer productivity / paved-path tooling
Repeatable project foundation P0 Project bootstrap tooling
Architecture-to-contract synthesis G2C Architect productivity tooling
Continuous evaluation and assurance AI-DLC AI quality and release-gating platform
Deterministic enterprise mutation paths CQRS profile Transactional integration patterns

The objective is not abstraction for its own sake. A reusable platform is justified when multiple domains repeatedly need the same contracts, guardrails, observability, and operational controls.

The framework family is vendor-neutral by design. Reference mappings span AWS Bedrock, Google Cloud / Vertex AI, Microsoft Azure AI, and standalone/open-model runtimes, with provider-specific capabilities isolated behind adapters rather than assumed to be equivalent.


📦 From Spikes to Completed Projects

Each project shows both stages: main is the completed project built on the framework family; the branch spike/v1-original (tag spike-v1) keeps the spike that informed it.

Order-to-Cash Agentic AI Platform

🔗 order-to-cash-agentic-ai · the spike

  • Spike (Apr 2026): Python · FastAPI · LangGraph · Amazon Bedrock · OpenSearch · Terraform. Explored multi-agent coordination, hybrid retrieval, policy controls and idempotency.
  • Completed (Nov 2026): Python · FastAPI · E2A · DSA · Cloud Run (Terraform). Five E2A agents in one workflow, governed tools with typed outcomes against the two other projects, hybrid RAG, MCP, human approval with four eyes, and an AI-DLC release gate (seven stages, RAGAS gate, red team).

Cloud-Native Financial Settlement Platform

🔗 financial-settlement-platform · the spike

  • Spike (Apr 2026): Java 21 · Spring Boot · Spring AI · Kafka · Redis · PostgreSQL. Explored saga orchestration, compensation, Redis-backed idempotency, distributed messaging and financial-integrity controls.
  • Completed (Nov 2026): Java 21 on E2A's Deterministic CQRS profile (double-entry ledger, saga with compensation, transactional outbox, versioned event contract, write-offs and refunds) and a Python E2A audit agent with policy retrieval · Azure (Terraform).

Cloud-Native Payment Reconciliation Engine

🔗 aws-reconciliation-engine · the spike

  • Spike (Mar 2026): Python · FastAPI · AWS Lambda · SQS/DLQ · DynamoDB · Amazon Bedrock. Explored asynchronous processing, conditional-write idempotency, DLQ handling and agent routing.
  • Completed (Nov 2026): Python on Lambda with matching on governed DSA operations, one DynamoDB transaction per match, an E2A agent that proposes while rules decide, and write-offs posted to the settlement ledger · AWS Terraform applied to a local AWS emulator in CI.

Capability-Oriented DSA (Enterprise Lens)

🔗 capability-oriented-dsa

Python · zero runtime dependencies · mypy strict · GitHub Actions

Patterns explored: one governed entry point, declared operations instead of branching, ordered configuration resolution, request identifiers (correlation_id, tenant_id, idempotency_key) and honest structured results, applied to classical data structures and algorithms as a bridge for enterprise developers.

Evidence discipline: The completed projects are verified in CI (tests, contracts, Terraform, a cross-project demo) with a simulated model and are not deployed. They demonstrate architectural feasibility and implementation patterns; they are not presented as production validation unless a specific repository provides explicit production evidence.


Enterprise Production Engineering — Where the Invariants Came From

My framework thinking is grounded in enterprise transactional and distributed-systems work, particularly financial settlement and transportation-management domains.

The important connection is not that cloud and Agentic AI systems should copy SAP implementations. It is that production experience with transactional consistency, zero-loss processing, idempotency, integration boundaries, auditability, failure recovery, and major NFRs provides a strong set of invariants to test against new runtime models.

This is what the architectural spikes were intended to challenge: which principles survive when the runtime changes?

The answer became the foundation of E2A.


🏛️ Architectural Philosophy — Correct by Design

Idempotency and reconciliation can be business features, not merely technical safeguards.

For financial and settlement-oriented workflows, the correct control layer depends on the domain.

A useful calibration asks:

  1. Input mutability — can amounts or quantities legitimately change mid-flight?
  2. Output ambiguity — can identical values represent different business meaning?
  3. Audit exposure — what is the consequence of an incorrect posting?

Higher ambiguity and exposure justify stronger business-layer controls such as explicit idempotency, sagas, reconciliation, and ledger invariants. Lower-risk flows may be adequately protected by simpler infrastructure controls.

The broader principle is:

Make invalid business states difficult or impossible by architecture before relying on exception handling.


NFR-First Engineering

A representative production-oriented sequence used across the framework thinking is:

  1. Scaffold — establish structure and engineering standards
  2. Infrastructure — establish a reproducible execution substrate
  3. Observability — make behavior measurable
  4. CI/CD — automate engineering gates
  5. NFR controls — reliability, security, policy, cost, and recovery
  6. Business logic — build domain capability on the governed foundation

This is a reference sequence, not a requirement that every use case implement every layer. Why not simpler? remains an explicit architectural test.


Claim & Evidence Discipline

I distinguish these categories across the repositories:

Classification Meaning
Framework invariant Architectural rule the framework intends to enforce
Implemented capability Present in concrete code
Architectural spike Experiment used to discover or challenge an architectural hypothesis
Reference runtime Implementation used to exercise formalized framework patterns
Recommended production pattern Guidance requiring contextual validation
Directional design Extension or hypothesis still under architectural exploration

This distinction is especially important for portability, reliability targets, multi-cloud mappings, and production-readiness claims.


Why Not Simpler?

A framework is useful only when the problem justifies it.

  • If conventional deterministic application logic solves the problem, use it.
  • If a bounded RAG assistant is sufficient, do not introduce transactional orchestration.
  • If a managed cloud capability directly satisfies a requirement, prefer it over unnecessary custom abstraction.
  • Introduce E2A-level controls when probabilistic reasoning interacts with enterprise data, tools, regulated boundaries, material business actions, or systems of record.

📐 Framework Documentation


Areas of Focus

  • Enterprise and Agentic AI architecture
  • Distributed systems and transactional correctness
  • RAG and enterprise knowledge systems
  • Agent orchestration and tool integration
  • Multi-cloud architecture
  • Developer platforms and paved paths
  • Evaluation, observability, and AI production readiness
  • Cloud-native modernization

Design Principle

Same enterprise principles. Different runtime. Explicit boundaries. Measurable outcomes.


Attribution and trademarks

All trademarks, service marks, and logos referenced in architecture examples remain the property of their respective owners. References to AWS, Google Cloud, Microsoft Azure, SAP, Meta, LangGraph, and other technologies are for educational and architectural comparison and do not imply endorsement.

Pinned Loading

  1. a2c-framework a2c-framework Public

    AI-governed developer platform extending E2A. Generates enterprise-grade code (A2C), project scaffolding (P0), and E2A/A2C framework classes (G2C) -- all via E2A-governed agents with NFRs enforced …

    Python

  2. e2a-framework e2a-framework Public

    Enterprise-to-Agentic (E2A) Architecture Framework — a vendor-neutral governance layer mapping enterprise architecture discipline (SAP RAP, Java EE) to agentic AI systems. Designed to be multi-clou…

    Python

  3. financial-settlement-platform financial-settlement-platform Public

    Double-entry settlement ledger on E2A's deterministic CQRS profile (Java 21): saga with compensation, transactional outbox, versioned event contract, write-offs and refunds; plus a Python E2A audit…

    Java

  4. order-to-cash-agentic-ai order-to-cash-agentic-ai Public

    Order-to-Cash agentic assistant on E2A: five governed agents, typed tool outcomes, four-eyes approval, hybrid RAG, MCP and an AI-DLC release gate; runs with the settlement and reconciliation projec…

    Python

  5. aws-reconciliation-engine aws-reconciliation-engine Public

    Payment reconciliation on AWS Lambda, built on E2A and DSA: governed matching, an agent that proposes while rules decide, idempotent SQS consumer with DLQ reconciliation, write-offs posted to the s…

    Python