AI Systems · Technical Evaluation · Security · Software

Build.
Evaluate.
Verify.

Building, evaluating, and securing AI-powered software systems.

Focused on AI/LLM systems, technical evaluation rubrics, policy trust boundaries, software quality, and cryptographic evidence verification.

Live Verifier Online AI/LLM Evaluation Deterministic Security Public Source Code
// System Trace Loop Status: Deterministic
01Input SpecificationRaw payload
02System ExecutionPipeline
03Rubric EvaluationExplicit criteria
04Evidence ArtifactAudit record
05Client VerificationCryptographic check

A system is only as trustworthy as its weakest checkpoint

Where I Can Contribute

Technical capabilities demonstrated through real code, verification evidence, and technical evaluation exercises.

01

AI / LLM Technical Evaluation

Assessing AI-generated outputs against explicit technical criteria — correctness, instruction following, reasoning quality, and failure mode detection.

02

Software Evaluation & Systems QA

Reviewing implementations for distributed consistency, architecture resilience, edge-case robustness, and security boundaries.

03

AI Agent Security & Policy Enforcement

Analyzing tool calls, preventing unauthorized execution paths, and placing deterministic trust boundaries outside untrusted models.

04

Verification & Cryptographic Auditability

Making system output independently checkable rather than trusted on faith — tamper detection, cryptographic proofs, and client-side verifiers.

Proof, Not Claims

Capabilities are more useful when you can inspect the evidence.

Every capability traces directly to something actually built, tested, or benchmarked.

Adversarial Agent Verification

11-Check Deterministic State Observer

Agent Trust Benchmark →

AI Agent Security

Deterministic Policy Engine

AgentGuard →

Web Security & QA

10-Tool Pipeline Normalization

Hybrid Website Scanner →

Cryptographic Verification

Evidence Integrity & Client Check

Provable AI →

LLM Risk Analysis

Behavioral Workflow Guarding

AI Guard →

Selected Technical Work

Projects with deep engineering decisions, tests, and failure mode analysis.

Technical Evaluation & Judgment

Can an AI-generated answer actually be trusted?

I evaluate AI-generated implementations by separating correctness from plausibility, identifying hidden assumptions, testing failure modes, and judging whether the solution survives real system constraints.

01 Task 02 Criteria 03 Evidence 04 Failure Mode 05 Verdict 06 Remediation

Evaluation Task

"Implement a rate limiter for a distributed API that serves both authenticated users and anonymous visitors."

Response A (Plausible but Flawed)

Track requests per IP address in memory with
a fixed window (e.g. 100 req/min).
If a request exceeds the count, return 429.
Reset the counter every minute.

Response B (Production Grade)

Use a token-bucket limiter keyed by user ID for
authenticated requests, falling back to IP for
anonymous traffic. Store bucket state in a shared
store (Redis) so limits hold across N instances.
Return 429 with a Retry-After header.
Criterion Weight A B Technical Reasoning
Requirement Fit 20% 4/10 9/10 A rate-limits a single process; fails under horizontal scaling where requests are load-balanced across multiple instances.
Correctness 20% 4/10 8/10 A's in-memory counters reset per process, silently multiplying the effective limit by N instances.
Robustness 15% 3/10 8/10 B includes Retry-After backoff headers and distributed persistence; A drops state on restart.
Security 15% 5/10 8/10 B isolates authenticated user accounts from NAT/shared IP pools; A allows cross-user IP starvation.

Evaluation Verdict & Remediation Plan

Response B — Decisive Winner (Score: 8.2 vs 4.0)

Critical Failure (A): In-memory per-IP counters reset per process. Behind a load balancer with 10 instances, a user can send 1,000 requests instead of 100 without ever being rate-limited.

Actionable Remediation: Implement distributed atomic token-bucket state in a shared Redis cluster using atomic Lua scripts. Isolate authenticated user keys from anonymous IP pools, and include standard HTTP 429 Retry-After headers.

Evaluation Task

"An AI agent is instructed to delete production records. Evaluate two candidate designs for handling that tool call."

Response A (Model-Centric Safety)

The agent's own LLM reasoning decides whether
the deletion looks safe before calling delete_data.
If the model judges the request legitimate,
it proceeds.

Response B (Deterministic Gateway)

Every call to delete_data is checked against a
deterministic policy engine outside the model loop.
Requires allow-list scopes and blocks production
targets by default. Decisions are logged to an
append-only audit store.

Evaluation Verdict & Remediation Plan

Response B — Winner (Fail-Closed Architecture)

Critical Flaw (A): Using the LLM to judge its own actions puts enforcement inside the untrusted component. A single prompt injection bypasses the entire guard.

Actionable Remediation: Move all authorization checks out of the prompt and into a deterministic, schema-enforced gateway layer. Default to BLOCK on any unmapped tool-call signature and write every attempt to an append-only audit log.

Evaluation Task

"Review two AI-generated vulnerability assessments of the same web endpoint finding on /search?q="

Assessment A (Surface Pattern Matching)

Finding: Reflected XSS on /search?q=
Severity: Critical
Parameter is reflected in page, so any input
could execute script. Block immediately.

Assessment B (Verified Test)

Finding: No confirmed XSS on /search?q=
Severity: N/A (Mitigated)
Parameter is reflected, but context-aware HTML
entity encoding renders payload inert. Verified by
submitting payload and inspecting rendered DOM.

Evaluation Verdict & Remediation Plan

Assessment B — Winner (Verified Exploitability)

Critical Flaw (A): Treats simple string reflection as proof of execution. Reflection without execution is not a vulnerability — this is the #1 source of automated false positives.

Actionable Remediation: Never report a vulnerability as confirmed without demonstrating payload execution in the rendered context. Conduct audit testing across all secondary render paths for that parameter.

Engineering Judgment

How I Think: Mental models applied across technical evaluations.

AI Review Framework

Before trusting any AI-generated output, I check:

About & Standards

I am interested in systems that have to be correct.

I'm a Computer Science graduate focused on building, evaluating, and securing AI-powered software systems.

My work spans AI/LLM evaluation, agent policy gateways, backend engineering, security tooling, software testing, and cryptographic verification.

My approach is evidence-driven: understand requirement → build → test → evaluate failure modes → verify evidence.

I apply the same engineering standards to AI-generated code that I apply to code I write myself: correctness, security, maintainability, failure handling, scalability, and verifiability.

Academic Foundation

B.Tech in Computer Science & Engineering

Sri Sarathi Institute of Engineering & Technology

2022 – 2026 • Graduated

Core Competencies

Technical Evaluation & Evidence Review
Structured Technical Reasoning
AI / LLM Evaluation & Rubrics
AI Agent Security & Policies
Python • FastAPI • Rust
Cryptographic Verification
Redis • PostgreSQL • SQLite
Docker • Automated Testing
Get in Touch

Open to serious technical work.

Looking for AI evaluation, AI security, systems engineering, and technical QA opportunities.

Selected Technical Work — Project Summaries

Provable AI

Verification infrastructure for making AI-related execution evidence inspectable, auditable, and independently verifiable.

Designed and implemented the policy, execution, evidence-generation, cryptographic verification, and audit-validation pipeline.

Public repository: futureaihub/provable-ai

Live verifier portal: zorynex.co

Limitations

Agent Trust Benchmark

A deterministic verification framework that tests whether tool-using AI agents actually obey authorization policies, perform the correct actions, and report outcomes truthfully — using observable evidence instead of trusting agent explanations.

Designed and implemented the adversarial test harness, OPA/Rego policy evaluation layer, benchmark-owned state observer, SHA-256 evidence chain recorder, and 11 deterministic evaluator checks.

Public repository: futureaihub/agent-trust-benchmark

Limitations

AgentGuard

Deterministic policy gateway evaluating every AI agent tool call before execution with replayable audit trails.

Designed and implemented the deterministic policy gateway, rule evaluation layer, fail-closed behavior, audit storage, replay mechanism, and test suite.

Repository: futureaihub/agentguard (private) — interactive execution preview available on this page.

Limitations

Hybrid Website Scanner

Modular pipeline orchestrating ten security scanners, normalizing conflicting findings into a single deduplicated risk report.

Designed and implemented the orchestration pipeline, scanner normalization, async job processing, correlation, deduplication, and verification workflow.

Repository: futureaihub/hybrid-website-scanner (private) — interactive execution preview available on this page.

Limitations

AI Guard

Behavioral analysis inspecting LLM workflow inputs, outputs, and signals for injection and manipulation patterns.

Designed and implemented the behavioral analysis layer, workflow context inspection, risk signal extractor, and reviewable finding schema.

Repository: futureaihub/ai-guard (private) — interactive execution preview available on this page.

Limitations