Nilesh Jaiswal

HydraScale: Trust-Coupled Elastic Scaling for Federated CI/CD Pipelines Using Bounded Autonomous Agents

Continuous integration and delivery (CI/CD) pipelines increasingly execute across heterogeneous runner pools spanning standard, regulated, and isolated execution domains. Conventional autoscalers provision capacity using compute signals such as queue depth, CPU, or pending job count, but they ignore whether the target runner domain remains trusted. We define this mismatch as the scaling-security decoupling problem (SSDP): a pipeline controller may admit jobs or scale replicas into a domain whose runtime trust score has degraded below an acceptable threshold, causing unsafe admissions, compliance stalls, or provisioning deadlock. This paper presents HydraScale, a trust-coupled elastic scaling framework for federated CI/CD pipelines. HydraScale combines a four-component runtime trust vector with a three-tier bounded-autonomous control plane that couples queue, capacity, and trust signals before each scale-out, scale-in, or migration decision. We implement HydraScale as a service mesh of seven Python micro-services with Open Policy Agent enforcement, evaluate it against three baselines (static, queue-only predictive, reactive trust) across five scenarios, four scaling systems, and ten random seeds (200 paired runs), and report unsafe admissions, queuing stability, decision latency, and audit completeness. HydraScale admits no unsafe jobs across the five evaluated scenarios versus baseline means of 4.04 (reactive trust) to 204.56 (trust-blind), with Mann-Whitney U p ≤ 2.2 × 10−4 across the test family, p99 decision latency of 17 µs, and complete audit traces in all measured decisions.

Eliminates unsafe job admissions across all evaluated scenarios by coupling trust signals with elastic scaling decisions.

zero-trustCI/CDautoscalingKubernetesSPIFFEOPAagentic AIbounded autonomy

SATHOS: Self-Adaptive Trust-Hierarchical Orchestration for Zero-Trust DevSecOps Pipelines

Modern DevSecOps pipelines execute workloads across heterogeneous environments, including cloud runners, on-premises agents, and ephemeral containers, yet orchestration frameworks assume pre-trusted execution agents and rely on static policy gates. This assumption fails under agent compromise, configuration drift, and trust asymmetry between cloud and on-premises zones. We present SATHOS (Self-Adaptive Trust-Hierarchical Orchestration System), a zero-trust orchestration framework that models CI/CD pipelines as trust-governed directed acyclic graphs (DAGs) where each node's execution is conditioned on dynamically evolving four-dimensional trust vectors covering identity, platform, behavioral, and contextual evidence. SATHOS introduces a distributed trust negotiation protocol over mutual TLS with replay protection and cryptographic transcript verification, combined with a self-adaptive trust evolution mechanism that adjusts trust scores based on execution outcomes without requiring policy redeployment. Evaluated on a Kubernetes-based testbed with three pipeline topologies (3-5 nodes), three experimental conditions, and three random seeds (27 runs), SATHOS blocks 100% of compromised agent execution requests with zero false positives (p < 0.001, Fisher's exact test). The five-message trust negotiation protocol adds a median per-node latency of 4.73 ms (p50), and the Wilcoxon signed-rank test confirms bounded overhead (p = 0.065, one-sided). The system achieves zero false allows and zero false denies across all trial configurations.

Framework grounded in production experience automating enterprise Kubernetes/OpenShift delivery at scale.

zero trustDevSecOpsCI/CD securitysupply chain

Policy-Driven Shift-Left Security for Hybrid OpenShift CI/CD Pipelines

This paper presented a policy-driven shift-left security framework for hybrid OpenShift CI/CD pipelines that integrates container vulnerability scanning (Trivy), Kubernetes policy enforcement (OPA/Rego with eight denial rules), and governance tag validation into a unified pre-deployment gate. Through a controlled experiment of 50 pipeline builds per configuration, the framework detected and blocked all 15 insecure builds (8 vulnerable images, 5 policy violations, 2 governance violations) while allowing all 35 compliant builds to deploy, achieving a 100% detection rate with zero false positives. The shift-left pipeline introduces a mean overhead of 28.3 seconds per build, with container scanning accounting for 82.2% of the added time. The results demonstrate that early-stage, automated security enforcement can prevent insecure artifacts from reaching production environments without disrupting legitimate workloads. The layered three-gate architecture provides defense in depth across image vulnerabilities, deployment misconfigurations, and governance metadata, addressing a gap in existing CI/CD security research that has focused on individual controls in isolation.

shift-leftpolicy as codeOpenShiftOPA/Regocontainer security

Future-Proofing Identity Security for Agentic AI Systems: Design, Implementation, and Evaluation of an Identity Fabric

Agentic AI systems composed of dynamically instantiated, tool-enabled agents operating across trust boundaries introduce identity failures that exceed the assumptions of existing identity and access management frameworks. This paper identifies five identity gaps in agentic AI systems and introduces six composable security primitives that address ephemeral identity, delegation integrity, capability-level control, cross-domain trust, behavioral assurance, and content provenance: Ephemeral Attested Agent Identity (EAAI), Intent-Bound Delegation Tokens (IBDT), Identity-Constrained Capability Sandboxes, Decentralized Agent Identity Registries (DAIR), Continuous Behavioral Attestation, and Content Provenance Binding. We implement the architecture on Kubernetes using SPIFFE/SPIRE workload identity and mutual TLS for all inter-service communication. Across 33 mTLS test cases (n=100 per operation), the system achieved 100% delegation fidelity (20/20 narrowing tests), sub-25 ms mean latency for credential issuance and delegation, and 6/6 abuse-resistance rejections. In an end-to-end pipeline with Claude Sonnet, total identity overhead was 203 ms, representing 2.6% of inference latency.

agentic AIidentityIAMSPIFFE/SPIREworkload attestation

Risk-Adaptive Authorization for Agentic AI Systems

Agentic AI systems deploy autonomous agents that execute transactions with delegated authority, yet existing authorization mechanisms rely on static role-based policies that are inadequate for contexts varying in risk. Authentication protocols for ephemeral agents include SPIFFE, OAuth Token Exchange, and DPoP, addressing the question of "who is the agent?" This paper extends that foundation to address "what should the agent be allowed to do?" We present an authorization flow combining workload identity (SPIFFE/SPIRE), token exchange (RFC 8693), policy evaluation (Open Policy Agent), AI-based risk scoring, sender-constrained tokens (DPoP), and CIBA-inspired human approval for high-risk transactions. The architecture implements a three-tier authorization model: Tier 1 transactions receive automatic approval, Tier 2 transactions require supervisor-agent approval, and Tier 3 transactions trigger human-in-the-loop verification. We validate the approach through a retail exchange scenario. Measurements across 120 authorization requests show cold-path latency of 32.7 ms (SD = 18.5 ms) and warm-path latency of 4.7 ms (SD = 2.3 ms), a 7x speedup with token caching. Delegation narrowing enforcement blocks all invalid privilege escalation attempts across 20 test cases. The results indicate that risk-adaptive authorization adds acceptable overhead for agentic systems while enabling contextual policy decisions and human oversight for high-risk operations.

authorizationrisk-adaptiveagentic AISPIFFE/SPIREzero trust