AIdeas: Kanso — A Cloud-Native Semantic Intelligence Layer to Prevent Engineering Duplication
Kanso is a cloud-native semantic intelligence layer that detects duplicate initiatives across Jira, GitHub, Notion, Slack, and Linear in real time. It prevents redundant engineering effort before it happens and transforms fragmented workflows into a unified organizational memory system.
The Hidden Cost of Growing Teams
Two teams build the same feature.
Not because they lack talent.
Not because they made a mistake.
But because they used different words.
Not because they made a mistake.
But because they used different words.
One team creates an “Authentication Service.”
Another builds a “Login Backend.”
A third writes documentation for an “Auth Flow Redesign.”
Another builds a “Login Backend.”
A third writes documentation for an “Auth Flow Redesign.”
Different names.
Same intent.
Zero visibility.
Same intent.
Zero visibility.
Additional Organizational Costs
When semantic duplication occurs inside large engineering organizations, the impact extends far beyond two teams building the same feature. Hidden costs include:
| Impact Area | Description |
|---|---|
| Duplicate Work | Engineers unknowingly rebuild existing systems, repeating design and implementation work. |
| Wasted Sprint Cycles | Entire sprint capacity may be spent on redundant work before duplication is discovered. |
| Cloud Cost Duplication | Duplicate infrastructure, environments, and compute workloads increase operational cost. |
| Morale & Coordination Loss | Teams become frustrated when discovering parallel work that could have been collaboration. |
| Roadmap Slowdown | Strategic initiatives are delayed because engineering capacity is consumed by redundant development. |
These inefficiencies remain largely invisible in modern organizations because tools store information but do not understand intent.
Modern tools do not share semantic understanding.
| Tool | What it Stores | What it Cannot Understand |
|---|---|---|
| Jira | Tickets | Intent similarity |
| GitHub | Code | Cross-team feature overlap |
| Notion | Docs | Semantic duplication |
| Slack | Conversations | Hidden project collisions |
Kanso becomes the shared semantic memory layer across all of them.
My Vision
Kanso is a Cloud-Native Semantic Intelligence Layer that detects hidden “semantic fissures” -- overlapping initiatives expressed differently across systems.
Instead of discovering duplication in retrospectives,
Kanso detects it while the engineer is still typing.
Kanso detects it while the engineer is still typing.
Why Existing Tools Fail
Modern engineering organizations already use dozens of SaaS tools—issue trackers, code repositories, documentation platforms, and communication systems. Yet duplication continues to occur.
The problem is not lack of data, but lack of semantic understanding.
| Tool Category | What It Does Well | What It Cannot Detect |
|---|---|---|
| Issue Tracking | Task management | Cross-team intent similarity |
| Source Control | Code history | Parallel feature development |
| Documentation Tools | Knowledge storage | Duplicate architectural initiatives |
| Messaging Platforms | Communication | Hidden project collisions |
Traditional search relies on keywords. But engineers rarely describe the same idea using identical words.
Example:
- “Authentication Service”
- “Login Backend”
- “Identity API”
All describe the same intent but appear unrelated in keyword search systems. Kanso solves this by introducing semantic understanding across systems, enabling organizations to detect duplicate initiatives before development begins.
How I Built This
When I first started architecting Kanso, the naive approach was to build a highly optimized keyword search. But I quickly realized that in a sprawling engineering org, an "Authentication Backend" and a "Login Service" would never trigger a keyword match, even though they represent the exact same engineering effort. I needed the system to understand intent, not just vocabulary.
This realization shaped the entire AWS serverless architecture.
The Semantic Engine: Why Titan and Claude 3 Sonnet? To solve the intent problem, I moved away from text matching and built a pipeline centered around vector embeddings using Amazon Bedrock. When a developer writes an initiative or a Jira ticket, Kanso uses the Titan Text Embeddings model to convert that text into a high-dimensional vector.
However, vector proximity isn't perfect. For example, "Implement Stripe billing" and "Deprecate Stripe billing" share high semantic similarity but have opposite intents. If Kanso flagged every highly similar vector, developers would suffer from severe alert fatigue. To solve this, I introduced a secondary reasoning layer. When vector similarity crosses the 85% threshold, the payload is routed to Claude 3 Sonnet (via Bedrock). Claude acts as the contextual validator, analyzing status conflicts, intent variations, and cross-tool references to confirm if it is a true duplicate before firing an alert.
The Core Engineering Challenge: The 500ms Latency Budget The biggest technical hurdle wasn't the AI—it was the user experience. For Kanso to be effective as an IDE extension (VS Code/Kiro), it has to analyze what a developer is typing as they type it, without lagging their environment. I gave myself a strict 500ms latency budget.
To achieve this, I had to optimize both the edge and the cloud:
- At the Edge: I built a 500ms debouncer and an embedding cache directly into the extension's Similarity Engine to prevent noisy, redundant API calls while the developer is mid-sentence.
- In the Cloud: I needed lightning-fast vector retrieval. I chose Amazon OpenSearch Serverless for its KNN similarity matching. The serverless configuration allowed me to query thousands of vectors in milliseconds, leaving just enough time in the latency budget to invoke Claude 3 Sonnet only when absolutely necessary.
The Fully Managed Pipeline The resulting event-driven flow is entirely serverless. The IDE extensions act as sensors, securely passing payloads through Amazon API Gateway to an AWS Lambda (Python 3.11) compute layer. Lambda orchestrates the Bedrock embeddings, queries OpenSearch, and stores the metadata and finalized alerts in an on-demand DynamoDB table.
Because the entire stack is serverless, Kanso scales seamlessly from a two-person startup to an enterprise engineering org without requiring any manual infrastructure provisioning.
Core Infrastructure Stack
| Layer | Service | Purpose |
|---|---|---|
| Ingestion | Amazon API Gateway | Secure API entry point |
| Compute | AWS Lambda (Python 3.11) | Event processing |
| Embeddings | Amazon Bedrock (Titan) | Semantic vector generation |
| Reasoning | Claude 3 Sonnet | Contextual validation |
| Vector Search | OpenSearch Serverless | KNN similarity matching |
| Metadata | DynamoDB (On-Demand) | Initiative & alert storage |
| Monitoring | CloudWatch | Logging & metrics |
This architecture is fully managed and auto-scaling.
The Edge Extensions (The Sensors)
Kanso integrates into:
- VS Code
- Kiro IDE
- Jira
- GitHub
- Notion
- Linear
When a developer types:
- Extension detects change
- Debounce (500ms)
- Similarity analysis triggered
- Alert shown if threshold exceeded
Extension Core Architecture
Extension Internal Components
| Component | Role |
|---|---|
| Code | Detects document changes |
| Debouncer | Reduces noisy API calls |
| Similarity Engine | Pre-validates similarity |
| Embedding Cache | Reduces redundant embedding calls |
| Alert Manager | Constructs alert objects |
| UI Notifier | Displays inline warning |
| Alert Queue | Handles offline cases |
The extension is lightweight.
The intelligence runs in AWS.
The intelligence runs in AWS.
Predictive Overlap Warning
When similarity exceeds threshold (default ~85%), the user sees:
- Similar initiative reference
- Similarity score
- Evidence bullets
- Suggested action
- Confidence score
Overlap Decision Logic
| Condition | Action |
|---|---|
| Similarity < 75% | Ignore |
| 75–85% | Flag for lightweight review |
| > 85% | Trigger Claude reasoning |
| Claude confirms overlap | Create alert |
| User confirms | Merge / Link initiatives |
This makes duplication prevention proactive.
The Cloud Intelligence Core
Kanso does not rely on keyword matching.
It uses embeddings + reasoning.
Kanso System Architecture Overview
The Kanso architecture is organized into six core functional layers.
| Layer | Role |
|---|---|
| Ingestion | Collects events from developer tools via extensions and APIs |
| Embedding Generation | Converts text into semantic vectors using Titan embeddings |
| Retrieval | Finds similar initiatives using OpenSearch KNN search |
| Reasoning | Uses Claude to validate whether similarity represents true duplication |
| Alert Generation | Generates structured alerts for engineers and leadership |
| Storage & Metrics | Stores events, alerts, and metrics in DynamoDB and monitoring systems |
This layered architecture allows Kanso to operate as a real-time semantic intelligence layer across engineering workflows.
AI Workflow
| Step | Engine | Function |
|---|---|---|
| 1 | Titan Embeddings | Convert text → vector |
| 2 | OpenSearch KNN | Retrieve top similar initiatives |
| 3 | Threshold Filter | Remove low similarity |
| 4 | Claude 3 Sonnet | Validate semantic overlap |
| 5 | JSON Response | Send structured alert |
Claude analyzes:
- Rewritten intent variations
- Tag similarity
- Status conflict
- Cross-tool references
- Executive Redundancy Graph
- Kanso builds a semantic relationship graph.
Knowledge Graph UI
What Leadership Sees
| Metric | Meaning |
|---|---|
| Overlap Clusters | Groups of semantically similar initiatives |
| Duplicate Density | Percentage of redundancy in workspace |
| High-Risk Domains | Teams with repeated overlap |
| Prevented Duplications | Alerts resolved before execution |
| Estimated Time Saved | Calculated engineering hours avoided |
This turns invisible inefficiency into measurable insight.
Metric Calculation Methodology
The executive dashboard metrics are computed from the event stream generated by semantic overlap detections.
| Metric | Calculation |
|---|---|
| Overlap Clusters | Groups of initiatives with embedding similarity above the clustering threshold |
| Duplicate Density | (Total Overlap Alerts / Total Initiatives) × 100 |
| High-Risk Domains | Teams or repositories with the highest frequency of overlap alerts |
| Prevented Duplications | Alerts that were resolved or merged before code implementation began |
| Estimated Time Saved | (Average engineering hours per feature × prevented duplications) |
These metrics transform duplication detection into measurable operational insights for leadership.
Data Model
Users ---> Alerts---> Metrics Schema
Every overlap event is stored.
Every resolution updates metrics.
Every resolution updates metrics.
Security & Multi-Tenant Design
Kanso uses JWT-based authentication with refresh tokens.
Security Architecture
| Feature | Implementation |
|---|---|
| Authentication | JWT access + refresh tokens |
| Authorization | Bearer token validation |
| Multi-Tenant Isolation | workspaceId partitioning |
| API Protection | API Gateway + Lambda authorizers |
| Audit Logging | CloudWatch event logs |
Security is built-in, not added later.
Product Walkthrough
Onboarding
Interface Workflow Narrative The Kanso interface is designed to expose semantic overlaps at multiple organizational levels.
- Onboarding Flow: Developers connect existing tools such as Jira, GitHub, or Notion. Kanso begins ingesting metadata and generating semantic embeddings for initiatives.
- Dashboard Overview: The dashboard aggregates organization-wide metrics including detected overlaps, prevented duplication events, and estimated engineering time saved.
- Live Alerts Panel: When potential duplication is detected, engineers receive contextual alerts showing:
- Similar initiative references
- Similarity score
- Evidence supporting the match
- Suggested actions (merge, link, or ignore)
This workflow ensures engineers can resolve overlaps before development effort is duplicated.
Dashboard Overview
Dashboard Metrics
| Card | Description |
|---|---|
| Total Alerts | All detected overlaps |
| Prevented Duplications | Resolved before execution |
| Estimated Savings | Hours saved |
| Activity Feed | Recent overlap events |
Live Alerts Panel
Developers can:
- Compare initiatives
- Accept / Ignore
- Merge references
- Track history
SaaS Integrations
Kanso does not replace tools.
It connects them semantically.
It connects them semantically.
Measurable Impact
| KPI | Why It Matters |
|---|---|
| Prevented duplications | Direct cost avoidance |
| Alert frequency | Overlap density |
| Time saved | Productivity gain |
| Compute avoided | Cloud cost reduction |
| Overlap clusters | Strategic visibility |
What I Learned
- Embeddings outperform keyword search in organizational systems.
- Preventive detection has higher ROI than reactive review.
- Human-in-the-loop builds trust.
- Serverless reduces operational drag.
Final Positioning
Kanso is:
- Cloud-native
- Serverless
- AI-powered
- Event-driven
- Multi-tenant
- Semantic-first
It transforms fragmented SaaS workflows into a unified intelligence system.
Effort aligns.
Knowledge is reused.
Redundancy disappears.
Knowledge is reused.
Redundancy disappears.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article