AIdeas Finalist: Veloquity - The Agentic Evidence Intelligent Platform Turning Raw Feedback into Evidence-Driven Decisions
Decisions don’t fail from too little data - they fail from too much noise. Veloquity, an agentic evidence intelligence platform, filters that noise by transforming fragmented feedback into validated evidence and delivering explainable, prioritized recommendations with full source-to-decision traceability that guides human decisions. READ ON TO SEE HOW.
App Category: Commercial Solutions
The Problem
Organizations today are not lacking feedback.
They are lacking clarity.
Across product teams, hospitals, and public systems, feedback arrives continuously:
support tickets, app reviews, survey responses, and user complaints.
support tickets, app reviews, survey responses, and user complaints.
Individually, each signal seems small.
Collectively, they form a pattern.
Collectively, they form a pattern.
But that pattern is hard to see.
The same issue may be described in completely different ways:
- a crash report
- a vague complaint
- a frustrated review
- a detailed support ticket
As volume increases, these signals fragment across platforms.
To humans, they appear as isolated incidents.
In reality, they often point to the same underlying problem.
In reality, they often point to the same underlying problem.
Most teams still rely on manual interpretation:
- reading feedback
- scanning tickets
- prioritizing based on intuition
At small scale, this works.
At large scale, it fails.
At large scale, it fails.
Organizations may process thousands of inputs, yet still miss the single issue affecting the most users.
This is the gap Veloquity was built to solve.
My Vision
Veloquity is an Agentic Evidence Intelligence System that transforms raw, fragmented feedback into validated, evidence-backed decisions.
Instead of relying on manual guesswork or simple summarization, Veloquity autonomously:
- Ingests multi-source signals
- Extracts semantic patterns
- Clusters related feedback
- Computes mathematical confidence
- Generates prioritized recommendations with absolute source-to-decision traceability
Every output is backed by a traceable chain of evidence, ensuring decisions are grounded in reality, not anecdotes.
Why This Matters
The core failure in modern systems is not a lack of data - it is a lack of decision reliability.
Traditional tools:
- Count keywords
- Display dashboards
- Rely on manual interpretation
This approach leads to two critical errors:
False Positives: Acting on noise (e.g., prioritizing a "metaphorical crash" over a literal bug).
False Negatives: Missing critical patterns because they are described in varied language.
False Positives: Acting on noise (e.g., prioritizing a "metaphorical crash" over a literal bug).
False Negatives: Missing critical patterns because they are described in varied language.
Example: 100 mentions of "crash" might represent one reproducible bug or ten unrelated frustrations. Traditional tools can't tell the difference.
Veloquity introduces Evidence Intelligence, where:
- Signals are validated mathematically
- Patterns are extracted semantically
- Decisions are explainable and traceable
This enables reliable, high-stakes decision-making for product teams, healthcare systems, and public services alike.
Full Live Demo: Domain-Agnostic Intelligence in Action
To demonstrate real-world adaptability, the video shows Veloquity processing two fundamentally different environments using the same core engine, same evidence pipeline, and no domain-specific rewrites.
Stage 1 - SaaS Product Feedback
App Store reviews and Support Tickets are transformed into validated evidence clusters, confidence-scored signals, and prioritized product actions such as recurring crash patterns and performance regressions.
Stage 2 - Healthcare Feedback
Patient surveys and portal complaints pass through the identical pipeline to surface operational risks such as extended emergency wait times, appointment booking failures, and service friction trends.
The underlying system remains unchanged.
This demonstrates that Veloquity is not built on hardcoded industry rules, but on reusable semantic intelligence capable of scaling across sectors wherever feedback exists.
In production, domain-specific adaptations (such as integrations and compliance requirements in healthcare) can be incorporated without altering the core intelligence pipeline.
How My App is Different
1. Source-to-Decision Traceability (The Core Differentiator)
Most competitors stop at "insights." Veloquity ensures complete traceability.
Every recommendation follows a rigorous chain:
Raw Feedback → Evidence Cluster → Confidence Score → Reasoning → Decision
Raw Feedback → Evidence Cluster → Confidence Score → Reasoning → Decision
Through our evidence mapping layer (evidence_item_map):
- Every recommendation links directly to the original feedback items.
- Timestamps, sources (App Store vs. Support Ticket), and user IDs are preserved.
- Decisions are fully auditable.
This transforms AI from a "black box" into a trustworthy system where a PM can click a recommendation and see exactly which user voices generated it.
2. AWS-Native Agentic Infrastructure
Veloquity is a fully serverless system built on Amazon Web Services.
Core Services:
| Service | Role in Veloquity |
|---|---|
| AWS Lambda | Runs 4 independent agents (Ingestion, Evidence, Reasoning, Governance) |
| Amazon Bedrock | Provides embeddings (Titan Embed V2) and reasoning (Nova Pro) |
| Amazon S3 | Stores raw and processed feedback |
| Amazon RDS PostgreSQL (pgvector) | Handles vector clustering and similarity search |
| Amazon EventBridge | Triggers scheduled governance workflows |
| AWS IAM & Secrets Manager | Ensures secure access and credential management |
Agentic Pipeline:
Ingestion → Evidence Intelligence → Reasoning → Governance → Decision
Each stage is independently scalable, fault-isolated, and cost-efficient. This ensures real-time processing, high availability, and near-zero idle cost.
3. Mathematical Confidence Scoring
Traditional systems rely on frequency (keyword counting). Veloquity uses centroid variance-based scoring:
Formula:
Confidence = clamp(1.0 - (variance × 2.0), 0.0, 1.0)
Confidence = clamp(1.0 - (variance × 2.0), 0.0, 1.0)
Process:
- Embeddings are generated using Titan Embed V2 (1024 dimensions).
- Clusters are formed via greedy cosine similarity.
- Variance determines signal strength.
Routing:
| Confidence Range | Action |
|---|---|
| < 0.40 | Reject (noise) |
| 0.40 – 0.60 | AI Validation |
| > 0.60 | Accept (signal) |
Result:
Only high-confidence signals influence decisions. A cluster of 50 loosely related complaints scores low and is ignored, while 5 tightly worded bug reports score high and trigger action.
Only high-confidence signals influence decisions. A cluster of 50 loosely related complaints scores low and is ignored, while 5 tightly worded bug reports score high and trigger action.
4. Proven Domain-Agnostic Intelligence
The system was validated using two completely different datasets to prove its flexibility.
SaaS Product Dataset:
- 547 feedback items
- App Store + Support Tickets
- Example cluster: "App crashes on project switch"
Hospital Dataset:
- 310 feedback items
- Patient surveys + Portal complaints
- Example cluster: "Extended Emergency Wait Times"
The same pipeline, same code, and same architecture processed both. This proves Veloquity operates on semantic intelligence, not domain rules.
Structured View
| Dataset | Size | Example |
|---|---|---|
| SaaS Product | 547 feedback items | Crash issue (~91%) |
| Hospital | 310 feedback items | Wait time (~89%) |
Competitive Landscape: Moving Beyond Dashboards to Evidence Intelligence
The judges correctly identified that the feedback analysis market is crowded. Established platforms like Zendesk, Qualtrics, UserVoice, and Pendo dominate enterprise workflows.
However, these systems focus on collecting and visualizing feedback, not validating it. Veloquity addresses three critical gaps that separate it from the competition:
1. Semantic Noise vs. Mathematical Confidence
Competitor Approach:
- Keyword counting: "If keyword = crash → count++"
- Problem: Cannot distinguish signal from noise. High-frequency noise (e.g., 50 people using "crash" as slang) can dominate dashboards.
Veloquity Approach:
- Vector clustering + variance scoring:
Loose clusters (high variance) → Low confidence → Auto-rejected.
Tight clusters (low variance) → High confidence → Prioritized.
Outcome:
Only coherent signals are surfaced, filtering out the "Twitter noise" that plagues traditional tools.
Only coherent signals are surfaced, filtering out the "Twitter noise" that plagues traditional tools.
2. Black-Box Reasoning vs. Source Traceability
Competitor Approach:
- Input → AI → Output (with little to no explanation).
Veloquity Approach:
- Full traceability via evidence_item_map:
Decision → Cluster → Raw Feedback. - Every AI recommendation includes a drill-down to the exact user quotes that generated it.
Outcome:
AI becomes auditable and trustworthy. In enterprise environments, trust is the scarcest resource.
AI becomes auditable and trustworthy. In enterprise environments, trust is the scarcest resource.
3. Static Rules vs. Agentic Reasoning
Competitor Approach:
- Static heuristics (e.g., "If Priority = High, show at top"). They struggle to weigh conflicting signals like "high volume but old" vs. "low volume but rising fast."
Veloquity Approach:
- Agentic reasoning using Amazon Nova Pro with composite scoring:
Confidence (35%) + Users (25%) + Corroboration (20%) + Recency (20%) - The agent weighs these factors dynamically to produce nuanced trade-off explanations.
Outcome:
Veloquity doesn't just sort data; it reasons over it, offering the strategic context a junior PM might miss.
Veloquity doesn't just sort data; it reasons over it, offering the strategic context a junior PM might miss.
Summary Table
| Capability | Traditional Tools | Veloquity |
|---|---|---|
| Logic | Keyword counts | Semantic clustering |
| Confidence | Assumed | Computed |
| Traceability | Limited | Full |
| Prioritization | Rules | Agentic reasoning |
| Scope | Domain-specific | Domain-agnostic |
How I Built This
Veloquity is a five-phase system where each agent is powered by specific AWS services to ensure scalability, security, and intelligence.
1. Ingestion Agent
AWS Services: Lambda, S3, Secrets Manager
This agent accepts raw feedback, normalizes it, and strips personal data.
- Lambda: Runs the ingestion logic serverlessly, scaling automatically with data volume.
- S3: Stores normalized, redacted feedback items securely with date-partitioned keys.
- Secrets Manager: Safely manages database credentials, ensuring no hardcoded passwords in the code.
2. Evidence Intelligence Agent
AWS Services: Lambda, Bedrock (Titan Embed V2), RDS PostgreSQL (pgvector)
This agent converts text into math and finds patterns.
- Lambda: Orchestrates the embedding and clustering process.
- Bedrock (Titan Embed V2): Converts feedback into 1024-dimensional vectors to capture semantic meaning.
- RDS PostgreSQL (pgvector): Uses the HNSW index to perform fast cosine similarity clustering and store vectors efficiently.
3. Reasoning Agent
AWS Services: Lambda, Bedrock (Amazon Nova Pro), S3
This agent turns scored evidence into ranked decisions.
- Lambda: Computes the composite priority score (Confidence, Users, Corroboration, Recency).
- Bedrock (Amazon Nova Pro): Provides the reasoning engine that weighs trade-offs and generates explainable recommendations.
- S3: Archives the full reasoning run reports (JSON) for long-term traceability.
4. Governance Agent
AWS Services: Lambda, EventBridge, RDS PostgreSQL
This agent maintains system health automatically.
- EventBridge: Triggers the agent daily via a cron schedule to monitor for stale signals.
- RDS PostgreSQL: Runs maintenance queries to flag old evidence and promote frequent low-confidence patterns.
- Lambda: Writes an immutable append-only audit log (governance_log) to track every automated action.
Key Architectural Choice: Amazon Nova Pro over Anthropic Claude
A defining moment in development was migrating the entire reasoning pipeline from Anthropic Claude to Amazon Nova Pro.
The Problem: The AISPL Wall
Initially, the reasoning agent used Claude 3.5 Haiku. However, during testing, I encountered a critical failure: AWS accounts registered under AISPL (Amazon Internet Services Pvt. Ltd.)—common for users in India—are region-restricted from using Anthropic models. The API returned AccessDeniedException.
For a platform designed for global scalability, this was a hard blocker. I could not build a system that worked for only a subset of users.
The Solution
I refactored the pipeline to use Amazon Nova Pro (us.amazon.nova-pro-v1:0), a first-party AWS model available across all account types and regions. This required updating the request structure:
System prompts as a list of dictionaries.
Content structured as [{ "type": "text", "text": "..." }].
Parameters moved into inferenceConfig.
System prompts as a list of dictionaries.
Content structured as [{ "type": "text", "text": "..." }].
Parameters moved into inferenceConfig.
The Result
- Universal Access: Veloquity works for every AWS customer.
- Resilience: Reliance on a first-party model improves stability against external outages.
- Consistency: Standardized JSON output structure for easier parsing.
Validation and Performance
To address judge feedback regarding missing implementation details, I shifted focus from adding features to demonstrating reliability.
Automated Testing
I built a comprehensive test suite to ensure complex logic remains stable.
- 158 automated tests (100% passing) executing in 0.72 seconds.
- Coverage: Every component is validated—deduplication logic, clustering algorithms, priority scoring formulas, and routing thresholds.
- Failure Isolation: Tests verify that a single malformed feedback item does not crash the entire batch.
Cost and Performance
To prove economic viability, I benchmarked the system on a real workload (547 items).
Cost Analysis:
- Full pipeline run: $0.029 (Embeddings $0.016 + Reasoning $0.013).
- Cached runs: ~$0.013 (Embeddings skipped).
Structured View
| Component | Cost |
|---|---|
| Embeddings | ~$0.016 |
| Reasoning | ~$0.013 |
| Total | ~$0.029 |
| Cached Run | ~$0.013 |
Latency Benchmarks:
End-to-end runtime: ~91 seconds (18s Ingestion + 34s Evidence + 27s Reasoning + 12s Governance).
Structured View
| Stage | Time |
|---|---|
| Ingestion | ~18s |
| Evidence | ~34s |
| Reasoning | ~27s |
| Governance | ~12s |
| Total | ~91s |
This leaves ample headroom (under 10% of Lambda timeout budgets) to scale 10x the data volume.
Real-World Failure Modes
I documented and resolved four specific production failures:
- AISPL Restriction: Switched to Nova Pro to ensure global access.
- VPC Connectivity: Removed Evidence Lambda from VPC to allow direct Bedrock access (fixing timeout errors).
- Lambda Handler Pathing: Corrected CloudFormation configuration (evidence.embedding_pipeline.handler) to fix silent deployment failures.
- Missing Dependency: Added python-multipart to fix HTTP 422 errors on file uploads.
Structured View
| Issue | Resolution |
|---|---|
| AISPL Restriction | Switched to Nova Pro |
| VPC Connectivity | Removed VPC restriction |
| Lambda Handler Issue | Fixed configuration |
| Missing Dependency | Added python-multipart |
Development Approach: Using Kiro Agentic IDE as a Co-Pilot
During development, I used an agentic IDE (Kiro) as a co-pilot to accelerate iteration.
It helped with:
- reducing boilerplate
- debugging integration issues
- testing edge cases and prompt flows
The core system — including the architecture, confidence scoring model, and AWS pipeline — was designed and implemented through deliberate engineering decisions and iterative validation.
Kiro primarily improved development speed, allowing more focus on system design, reliability, performance, and the AWS integrations that power the system’s core functionality.
Future Enhancements
Based on the prototype success, the roadmap includes:
- Real-world Pilot Deployments: Integrating directly with hospital EMR systems and SaaS ticketing APIs.
- Adaptive Clustering: Dynamic thresholds based on seasonal feedback volume.
- Reinforcement Learning: Using PM acceptance/rejection data to fine-tune the priority scoring weights.
- Advanced Governance Analytics: Predicting churn risk based on "stale" signals that never get resolved.
What I Learned
The judges' feedback transformed Veloquity from a prototype into a robust system. Here is how I addressed their specific critiques:
Addressing "No Validation"
Lesson: A prototype needs proof to be trusted.
Action: I built a 158-test suite (running in 0.72s) and documented real benchmarks ($0.029/run, 91s latency). I also resolved real-world failures (AISPL restrictions, VPC issues) to prove production resilience.
Lesson: A prototype needs proof to be trusted.
Action: I built a 158-test suite (running in 0.72s) and documented real benchmarks ($0.029/run, 91s latency). I also resolved real-world failures (AISPL restrictions, VPC issues) to prove production resilience.
Addressing "Crowded Market"
Lesson: Competing on "features" against giants like Zendesk is impossible; I must compete on trust.
Action: I shifted to Evidence Intelligence. Unlike competitors who count keywords (creating noise), I use mathematical confidence scoring to filter it out. I also added full source-to-decision traceability, making the AI auditable rather than a black box.
Lesson: Competing on "features" against giants like Zendesk is impossible; I must compete on trust.
Action: I shifted to Evidence Intelligence. Unlike competitors who count keywords (creating noise), I use mathematical confidence scoring to filter it out. I also added full source-to-decision traceability, making the AI auditable rather than a black box.
Addressing "Narrow B2B Audience"
Lesson: I claimed "domain-agnostic" but only showed SaaS examples.
Action: I validated the architecture with a second Healthcare Dataset (Patient Surveys). The same code now detects both "software bugs" and "hospital wait times" without changes, proving the platform's broad social impact.
Lesson: I claimed "domain-agnostic" but only showed SaaS examples.
Action: I validated the architecture with a second Healthcare Dataset (Patient Surveys). The same code now detects both "software bugs" and "hospital wait times" without changes, proving the platform's broad social impact.
Addressing "Missing Implementation Details"
Lesson: Vague claims lack credibility; specifics matter.
Action: I documented the switch to Amazon Nova Pro for global availability and explained the exact priority scoring formula. This technical transparency proved the system is scalable and built for the real world.
Lesson: Vague claims lack credibility; specifics matter.
Action: I documented the switch to Amazon Nova Pro for global availability and explained the exact priority scoring formula. This technical transparency proved the system is scalable and built for the real world.
Business Model & Societal Impact
Veloquity is designed not as a single-purpose application, but as a horizontal intelligence layer that can operate wherever organizations receive feedback at scale.
The same evidence pipeline can power decision-making across multiple sectors without rebuilding the core system:
- SaaS companies analyzing product issues and churn signals
- Hospitals identifying patient experience bottlenecks
- Governments processing citizen complaints and service failures
- Universities detecting student dissatisfaction trends
- Financial institutions surfacing recurring customer friction points
- E-commerce platforms identifying product quality and returns issues
This creates a highly scalable business model: one core platform, many industries.
Efficient by Design
Because Veloquity uses serverless agents, embedding reuse, and event-driven workloads, costs scale with usage rather than idle infrastructure.
This means smaller organizations can access advanced decision intelligence without enterprise-sized budgets, while larger organizations can process high feedback volumes efficiently across departments.
Why This Matters Socially
Many important signals are ignored not because they are unimportant, but because they are buried in volume.
A repeated accessibility complaint, a patient frustration trend, or a recurring public-service issue may remain invisible until it becomes severe.
Veloquity helps surface these weak signals earlier, transforming fragmented voices into evidence that leaders can act on with confidence.
Final Thought
Organizations are overwhelmed with feedback but under-equipped to act on it.
Veloquity delivers what they lack:
Clear, trustworthy, evidence-backed signal.
Just as observability transformed how engineers monitor software systems, Veloquity introduces a new concept: Evidence Intelligence for human decision-making - and it works wherever humans produce feedback at scale.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article