EVIDIently Crafted – The Final Delivery 💥

Posted on 24/01/2026 by EVIDIently crafted

✨ Our Solution ✨

As consultants and developers tired of tedious and repetitive tasks, we wanted to create a toolbox for effective project management. Using AI and automation integrated in the tools we use daily, we hope to get more time to dive into the actual interesting parts of our jobs – getting back into the flow and explore the ~~Minecraft~~ Microsoft world.

Our Agile Toolboxxx is divided into modules:

👩🏻‍💻 The Project Management App

We have created a model-driven app for project management, where a project manager creates new projects with the necessary details, and with few clicks create a Teams channel for collaboration, a DevOps project with iterations and team members, and send out meeting invites to the recurring sprint meetings to all team members in Outlook, as well as creating contracts for the projects and send them out for signing.

All integrations from the app to other systems (Teams, Outlook, DevOps, OneFlow) is handled using low-code Power Automate flows, and truly brings out the best of the Microsoft Platform. This doesn’t only significantly reduce the time spent on administrative tasks, more importantly, it ensures that every critical part of a project is created automatically and consistently, without relying on manual steps or individual discipline.

By standardizing how projects are set up, the app guarantees that structures, data, and relationships are always in place and created in the same way. This consistency makes project execution predictable for everyone involved – team members always know what to expect, where to find information, and how work is organized. At the same time, it enables effective automation and AI: workflows can be automated end-to-end, data can be trusted, and AI agents can operate on complete, well-structured project information to deliver real value.

👾 The Technical Debt Game

The neverending discussion in all development projects – devs wanting the correct solution, project managers wanting the quick solutions and the board wanting the cheap solution. Our Technical Debt Game is created for educational purposes, to make everyone see the importance of balance between cost, time and technical debt.

In a single-purpose Canvas App, delivery decisions and technical debt accumulation are simulated across a 10-round project. The game is fully driven by Power Fx logic in the Canvas App, with Dataverse as the backend for game state, choices, events, and leaderboard results.

Players choose between fast, balanced, or robust delivery options, trading time and budget against growing technical debt, with the goal of completing the delivery with the lowest possible debt. Random events triggered by accumulated technical debt introduce realistic delivery disruptions, reinforcing cause-and-effect thinking.

The solution is intentionally simple, workshop-friendly and discussion-driven. Designed to spark reflection on real delivery trade-offs, or just to compete against your colleagues in long, boring corporate meetings 🥸.

(A hidden easter egg reward curiosity, because learning should still be fun.)

👨🏻‍🔧 AI-assisted Pull Request Reviews

In many projects, best practices are well documented but rarely used consistently. Code reviews are manual, time-consuming, and depend heavily on who happens to review the change. Issues are often discovered late, even though the rules were written down from the start.

We chose to move those best practices into the pull request workflow, where changes are already reviewed. The rules live in the repository as a simple best-practices.md file and act as the single source of truth.

An Azure DevOps pipeline exports the Power Platform solution, commits the changes, and creates a pull request automatically.
When the PR is created, Power Automate is triggered. It reads the PR context, fetches the changed files and the best-practices document, and sends this information to Microsoft AI Foundry for review.
The AI posts structured feedback directly on the pull request, grouped by severity. The review supports developers rather than blocking them. If anything is marked as CRITICAL or BLOCKER, a Bug is created automatically in Azure DevOps.
Secrets are handled securely through Azure Key Vault.

The design is intentionally simple and extensible. While the demo uses one AI reviewer, the same pattern supports multiple specialized reviewers/agents, such as security, best practices, or user impact. Power Automate orchestrates the process, and AI provides consistent, early feedback where it matters most.

🤖 CodeCraft AI

After finishing the initial processes of a project, we go into a critical part. The part where we attend to technical debt, users are starting to take ownership and developers tend to wander off to new projects.

Our app CodeCraft AI is here to help in this situation. If a user has a question about the functionality in the solution, these can be asked directly in the Teams Copilot chat, instead of having to trouble one of the developers. Work items and bugs can be created directly from the chat, no need to spend time writing user stories in DevOps. And if a critical bug is being reported, the responsible developer will be notified by SMS immediately.

During handover to new technical consultants, this becomes especially valuable. Instead of reading through pages of documentation that may or may not cover what they actually need, consultants can get direct answers to their questions when they need them.

A Power BI dashboard gives the responsible project manager an overview of all work items of all projects, so that projects that have been going on for a while and might not be top priority will not go under the radar.

🏆 The Categories 🏆

Data, AI & Analytics

The Data Stack: Everything Refined

Ingestion: Azure DevOps APIs → Bronze (hourly + real-time)
Transformation: PySpark pipelines → Bronze → Silver → Gold (star schema, daily aggregations)
Visualization: Power BI dashboards → Gold layer (interactive, real-time)
AI Integration: Fabric DataAgents semantic models → Agent queries via MCP
Real-Time: Event Hub → Fabric Streaming → KQL (instant queries)

The Medallion Architecture: Bronze → Silver → Gold

Bronze (Raw Blocks): Captures everything as-is from Azure DevOps, Event Hub, APIs. Raw JSON, unprocessed, complete.
Silver (Cleaned & Validated): Data quality checks, standardization, validation. Cleaned Parquet files, structured, and reliable.
Gold (Data Diamonds): Star schema with dimension tables (projects, repositories, teams, users, iterations) and fact tables (work items, commits, pull requests, branches). Daily aggregations pre-compute metrics. Analytics-ready.

The Journey: Raw events → Cleaned data → Star schema → Daily summaries → Instant insights.

Power BI Visualizations: Insights That Tell Stories

KPI cards give a quick view of team pulse. Interactive dashboards reveal productivity patterns, track trends, and enable instant analysis by team, project, and iteration. Data becomes visual, trends become obvious, and questions get answered instantly.

Fabric DataAgents: Strong Foundations for AI Agents

Semantic models (AgileToolboxxModel) enable natural language queries. SQL endpoints provide direct access to the gold layer. MCP servers connect agents to Fabric semantic models. Agents discover data sources dynamically and query structured analytics intelligently.

Real-Time Streaming: Data That Never Sleeps

Azure DevOps Service Hooks → Event Hub → Fabric Streaming → Eventhouse (KQL). Events are captured the moment they happen. KQL queries analyze streaming data, with events processed in under 5 seconds. From action to insight—instantly.

This data-first approach demonstrates how Fabric transforms raw events into actionable insights, from medallion architecture to Power BI visualizations, from Fabric DataAgents to real-time streaming. Every layer refines; every transformation reveals gems. That’s not just data processing; that’s data diamond mining.

Low-Code

🎮 Canvas Apps

The Technical Debt Game is a small, focused Canvas App with a single goal: make delivery trade-offs visible and discussable.
All game mechanics (rounds, resource calculations, probability-based events, win/lose logic, leaderboard and easter eggs) are implemented directly in Power Fx, without custom code.
Dataverse is used as the backend for scenarios, choices, events and scores, keeping the app simple, transparent and easy to extend.

⚙️ Power Fx as the engine

Complex decision logic, event probability tied to accumulated technical debt, and dynamic UI feedback are all handled using Power Fx formulas.
Clear use of Patch, conditional logic and calculated state shows deliberate design choices rather than default patterns.
The app favors “good and understandable” over over-engineering, supporting discussion rather than hiding logic behind abstractions.

🔁 Power Automate where automation adds value

Advanced Power Automate flows automate real delivery work: project setup, Teams and DevOps provisioning, sprint creation, holiday-aware iteration planning, contract creation and signing, and critical bug notifications.
Flows orchestrate across Dataverse, Teams, Azure DevOps, external APIs and third-party services without introducing new platforms or custom services.

🧩 Extending the platform, not rebuilding it

Existing Microsoft tools (Dynamics 365, Teams, Azure DevOps, Power BI) are extended and connected instead of replaced.
Legacy investments are respected and enhanced through low-code integration rather than rewritten.

✨ Low Code Philosophy in Practice

Small apps with clear purpose.
No PCF, no custom backends, no unnecessary perfection.
Bold UI choices balanced by professional framing.

This solution demonstrates how low code can be used for more than automate forms; to model behavior, teach complex concepts, and remove friction from real delivery work using the Power Platform as it was intended.

Code Connoisseur

The Code Stack: Everything is Code

Infrastructure as Code: Bicep templates + PowerShell scripts deploy everything.
Applications as Code: TypeScript + React + Vite create type-safe, high-performance frontends.
AI Agents as Code: MCP servers + version-controlled prompts enable collaborative AI.
Code Crawlers as Code: Python parsers extract relationships and build knowledge graphs.
API Orchestration as Code: Python async/await coordinates six Microsoft Cloud APIs.
Data Pipelines as Code: PySpark transforms Bronze → Silver → Gold.
Real-time Streaming as Code: PowerShell + Event Hub + KQL enable real-time insights.

This “code-first” approach shows how code can solve everything—from infrastructure to AI agents, from web apps to search indexes. Every part is version-controlled, reproducible, and elegant. This isn’t just development. This is code connoisseurship.

Each language was chosen for a specific purpose: Bicep for version-controlled infrastructure, TypeScript for compile-time safety, Python for asynchronous orchestration, PySpark for distributed processing, and KQL for time-series analysis.

Why code was needed to solve our problems:

Manual Deployments → Bicep + PowerShell automate everything. Code makes deployments reproducible, reviewable, and fast. Result: Zero manual steps, consistent deployments.
Inconsistent Environments → Parameterized templates ensure consistency. Code eliminates configuration drift. Result: One script deploys to multiple tenants.
Slow Frontend Performance → TypeScript + Vite + React optimizations. Code enables optimization at compile time. Result: <1 second load times, 60fps interactions.
Single-Agent Limitations → MCP servers enable collaborative AI. Code enables dynamic tool discovery. Result: Extensible agents, collaborative AI.
Unsearchable Code → Python crawler + Azure AI Search. Code enables automation and semantic understanding. Result: Code knowledge graph, semantic search.
Disconnected APIs → Python orchestration connects six APIs. Code enables seamless integration. Result: Six APIs orchestrated seamlessly.
Raw Data, No Insights → PySpark transforms data to gold. Code enables automated transformation. Result: Analytics-ready data, instant insights.
Delayed Data → Event-driven streaming enables real-time. Code enables real-time processing. Result: Real-time data, <5 second latency.

Digital transformation

👩‍💼 Project Managers

Automated project setup (Teams, DevOps, iterations, meetings) reduces admin work at project start.
Built-in governance ensures projects start correctly every time.
Less coordination overhead, more focus on delivery.

👨‍💻 Consultants & Developers

Faster feedback through AI-assisted pull request reviews directly in Azure DevOps.
Reduced technical debt through training, gamification, and continuous guidance during the project.
AI knowledge chat helps answer technical questions about existing solutions and implementations.
Quality issues are detected earlier, before they reach test or production.

🧑‍🤝‍🧑 Customers & End Users

Better transparency into project progress via Power BI reporting across projects.
Faster access to documentation and help through AI-powered user chat.
Customer questions and gaps automatically translate into structured user stories or bugs.

🏢 Leadership & Stakeholders

Cross-project insights through standardized Power BI reporting
Improved predictability, quality, and traceability across delivery.
Scales across teams and projects without adding new tools or processes.

🌍 Overall Digital Transformation Impact

Works in the real world by enhancing existing workflows, not replacing them.
Automates low-value work so people can focus on high-value outcomes.
Improves both employee and customer experience using intelligent automation.

Governance & Best Practices

The Philosophy: Trustworthy AI Integration

Responsible AI governance isn’t optional – it’s foundational. We address ethics, transparency, data privacy, security, fairness, regulatory compliance, and risk management in every component. AI integrated thoughtfully into real-world use cases, designed to be accountable and trustworthy.

Ethics & Safety: AI with Conscience

Safety evaluation ensures AI refuses harmful requests. Adversarial testing probes ethical boundaries. AI recognizes right from wrong.

Transparency: Visible Reasoning

Thought process visibility shows how AI reasons. Citations reveal data sources. Users understand AI decision-making. Explainable AI builds trust.

Data Privacy & Security: Multi-Layer Protection

Multi-Tenant Isolation: Search index filtering by customer, project, repository. Access control enforces document-level permissions. Customer A never sees Customer B’s data.
Azure Security: Managed Identity provides unified authentication. Key Vault stores all secrets securely. Zero credentials in code, zero traces left behind.
User Access Control: Not everyone has access to everything. User-based and group-based permissions enforced. Defense-in-depth architecture.

Fairness & Compliance

Dual assistant modes adapt to user type. Data governance through medallion architecture. Audit trails enable compliance. Risk management integrated into every layer.

The Bottom Line

We didn’t just build AI. We built responsible AI. Every component addresses governance – ethics, transparency, privacy, security, fairness, compliance, risk management. Responsible AI governance is built into every layer. That’s accountable, trustworthy AI design.

This governance-first approach demonstrates how responsible AI is integrated into real-world use cases, from safety evaluation to access control, from transparency to fairness. Every safeguard is intentional, every protection is built-in. That’s not just AI development -that’s responsible AI governance.

Redstone Realm

Built entirely on the Microsoft 365 & Dynamics 365 stack (Power Platform, DevOps, Teams, Power BI, Azure AI Foundry).
Low cost by reusing existing tools and licenses — no new platforms, no heavy custom code.
Easy to implement with modular, low-code solutions and standard APIs.
Quick business value by automating small, repetitive daily tasks that add up over time.
AI used where it matters: faster insights, better reviews, smarter knowledge access.
Secure and responsible: secrets in Key Vault, AI is advisory and transparent.
Improves employee and customer experience without changing how people already work.

Quick rewards and high business value, is it too good to be true? 👉🏻 No. The secret is keeping it simple and improving the small, repetitive tasks we perform every day.

Time saved isn’t lost revenue, it’s time reinvested in real value creation.

Hipster🤘

Posted on 24/01/2026 by EVIDIently crafted

Building the Future with Multi-Agent Architecture and Model Context Protocol

The Challenge: Beyond Single-Agent AI

We wanted to build something that wasn’t just another chatbot. We wanted an AI system that could think, collaborate, and orchestrate complex workflows across multiple data sources. Single-agent systems are powerful, but they’re limited—they can only do one thing at a time, they struggle with complex multi-step tasks, and they can’t leverage specialized knowledge sources simultaneously.

We needed something cooler. Something that would make other developers say “wait, how did you do that?”

We needed multi-agent architecture with Model Context Protocol (MCP).

The Solution: Multi-Agent Orchestration with MCP Servers

We built a cutting-edge multi-agent system using Microsoft Copilot Studio, Model Context Protocol (MCP) servers, and agent-to-agent communication. Our solution demonstrates the hippest, coolest tech stack available: agents that collaborate, MCP servers that provide specialized capabilities, and a unified system that orchestrates everything seamlessly.

Here’s how we built the future.

The Architecture: Agents, MCPs, and Orchestration

Our multi-agent architecture looks like this:

User Query → Copilot Studio Agent → MCP DataAgent → Multiple Knowledge Sources → Orchestrated Response
     ↓              ↓                    ↓                        ↓                      ↓
  Question    Scrum Assistant    DataAgent MCP          Azure AI Search        Intelligent Answer
                                    Server              Fabric Semantic         Multi-Source
                                                         Model                  Synthesis

Each component represents the latest in AI technology, working together to create something greater than the sum of its parts.

Step 1: Model Context Protocol (MCP) – The Foundation of Agent Communication

Model Context Protocol is the newest standard for connecting AI agents to external systems. It’s like REST APIs, but designed specifically for AI agents. MCP enables agents to discover capabilities, invoke tools, and communicate with specialized servers.

What Makes MCP Hipster-Level Cool

1. Standardized Agent Communication

Agents can discover available tools dynamically
No hardcoded integrations—everything is protocol-based
Agents can adapt to new capabilities without code changes

2. Specialized MCP Servers

Each server provides domain-specific capabilities
DataAgent MCP Server for data operations
Azure DevOps MCP Server for DevOps operations
Custom MCP servers for specialized tasks

3. Tool Discovery and Invocation

Agents discover tools at runtime
Tools are self-describing with schemas
Agents can chain tools together intelligently

Our MCP Implementation

We configured a DataAgent MCP Server that connects our Scrum Assistant to multiple knowledge sources:

{
  "mcpServers": {
    "dataagent": {
      "command": "dataagent-mcp-server",
      "args": ["--workspace-id", "11d99e27-c621-4340-8eb8-7940714ae333"],
      "env": {
        "DATA_AGENT_ID": "8b9a6308-db2e-4c5a-9073-61c9205a7334"
      }
    }
  }
}

What This Enables:

The Scrum Assistant can query Fabric semantic models
Agents can access Azure AI Search indexes
Multi-source knowledge retrieval in a single query
Dynamic tool discovery and invocation

Result: Our agents aren’t hardcoded—they discover and use capabilities dynamically, making our system truly extensible.

Step 2: Multi-Agent Architecture – Agents That Collaborate

We didn’t stop at one agent. We built multiple specialized agents that can work together:

The Scrum Assistant Agent

Our primary agent, built in Copilot Studio, specializes in scrum ceremonies and backlog management:

Agent Configuration:

Model: GPT-4.1
Purpose: Support scrum team members in facilitating ceremonies, backlog management, and continuous improvement
Knowledge Sources:
Azure AI Search (code and documentation)
Fabric Semantic Model (AgileToolboxxModel)
Web search (for scrum best practices)

Agent Instructions:

You are an AI assistant designed to support the scrum team members in 
facilitating scrum ceremonies, backlog management, and continuous improvement.

Skills:
1. Assist scrum teams with scrum ceremonies
2. Help with scrum best practices and coaching
3. Analyze team artifacts and provide data-driven insights

What Makes This Cool:

The agent adapts its responses based on available knowledge sources
It can query multiple sources simultaneously
It synthesizes information from different data types (structured + unstructured)

The DataAgent MCP Server

The DataAgent acts as a specialized MCP server that provides data access capabilities:

Capabilities:

Query Fabric semantic models (star schema analytics)
Access dimension tables (projects, repositories, teams, users, iterations)
Query fact tables (work items, commits, pull requests, branches)
Multi-source search across Azure AI Search and Fabric

Tool: DataAgent_DataAgent

Description: Provides access to AgileToolboxxModel semantic model
Inputs:
Data Agent ID
Workspace ID
Output: Structured query results from Fabric

How It Works:

When a user asks “How many work items are in different stages?”, the agent:

Receives Query: User asks about work item stages
Discovers Tools: Agent discovers DataAgent_DataAgent tool via MCP
Invokes Tool: Agent calls DataAgent_DataAgent with appropriate query
Multi-Source Search: Tool searches both Azure AI Search and Fabric semantic model
Synthesizes Results: Agent combines results from multiple sources
Generates Response: Agent provides comprehensive answer with citations

Result: The agent doesn’t just answer—it orchestrates a multi-source query, synthesizes results, and provides intelligent responses.

Step 3: Agent-to-Agent Communication – The Real Magic

The coolest part? Our agents can communicate with each other through MCP.

How Agent-to-Agent Communication Works

Scenario: User asks “How does the cart functionality work in the OEN project?”

Step 1: Scrum Assistant Receives Query

User asks about cart functionality
Scrum Assistant analyzes the query

Step 2: Agent Discovers Available Tools

Scrum Assistant discovers DataAgent MCP Server tools
Discovers Azure AI Search knowledge source
Identifies relevant data sources

Step 3: Multi-Source Query Execution

Scrum Assistant → DataAgent MCP → Fabric Semantic Model
                → Azure AI Search → Code Index
                → Web Search → Scrum Best Practices

Step 4: Agent Synthesizes Results

Combines code documentation from Azure AI Search
Integrates project data from Fabric semantic model
Adds context from web search
Generates comprehensive answer

Step 5: Response with Citations

Provides answer with source citations
Shows which knowledge source provided which information
Enables users to verify information

The Workflow Visualization:

┌─────────────────────────────────────────────────────────────┐
│                    USER QUERY                                │
│  "How does the cart functionality work?"                    │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│              SCRUM ASSISTANT AGENT                          │
│  (Copilot Studio - GPT-4.1)                                 │
│  • Analyzes query                                            │
│  • Discovers available tools                                 │
│  • Plans multi-source query                                  │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ├──────────────────────────────────┐
                       │                                  │
                       ▼                                  ▼
        ┌──────────────────────┐          ┌──────────────────────┐
        │  DATAAGENT MCP       │          │  AZURE AI SEARCH      │
        │  SERVER              │          │  KNOWLEDGE SOURCE     │
        │                      │          │                      │
        │  • Fabric Semantic   │          │  • Code Index        │
        │  • Star Schema       │          │  • Documentation     │
        │  • Analytics Data    │          │  • Vector Search     │
        └──────────┬───────────┘          └──────────┬───────────┘
                   │                                  │
                   └──────────────────┬───────────────┘
                                      │
                                      ▼
                    ┌──────────────────────────────────┐
                    │      RESULT SYNTHESIS            │
                    │  • Combines multiple sources     │
                    │  • Generates comprehensive answer │
                    │  • Provides citations            │
                    └──────────────────────────────────┘

Result: Agents collaborate seamlessly, each contributing their specialized knowledge to create comprehensive answers.

Step 4: Multi-Source Knowledge Integration

One of the coolest features is how our agents can query multiple knowledge sources simultaneously:

Knowledge Source 1: Azure AI Search

Configuration:

Name: Agent – Azure AI Search
Type: Azure AI Search connection
Index: gptkbindex
Document Count: 1,136 documents
Vectorized: Yes
Semantic Configuration: Yes

What It Provides:

Code documentation
Implementation details
File references
Semantic search capabilities

Knowledge Source 2: Fabric Semantic Model

Configuration:

Model: AgileToolboxxModel
Type: Semantic Model (Star Schema)
Tables:
Dimension tables (dim_project, dim_repository, dim_team, dim_user, dim_iteration)
Fact tables (fact_work_item, fact_commit, fact_pull_request, fact_branch)

What It Provides:

Structured analytics data
Work item metrics
Commit statistics
Team performance data

Knowledge Source 3: Web Search

Configuration:

Type: Public web search
Scope: Trusted scrum and agile sites

What It Provides:

Latest scrum best practices
Industry standards
Current methodologies
External context

How Multi-Source Queries Work

Example Query: “How many work items are in different stages?”

Query Execution:

Azure AI Search Query:

Searches code and documentation
Finds implementation details
Returns semantic matches

Fabric Semantic Model Query:

Queries fact_work_item table
Groups by WorkItemState
Returns counts by stage

Result Synthesis:

Combines structured data (Fabric) with unstructured data (Azure AI Search)
Generates comprehensive answer
Provides citations for each source

Response:

Work Items by Stage:
- New: 357 work items
- Active: 13 work items  
- Closed: 56 work items

[Source: AgileToolboxxModel Semantic Model]

Result: Users get answers that combine the best of structured analytics and unstructured knowledge.

Step 5: Real-Time Agent Orchestration

The workflow execution shows agents working in real-time:

Workflow Visualization

When a query is executed, we can see the agent orchestration:

┌─────────────────────────────────────────┐
│  DataAgent (MCP) - Initialized         │
│  ↓                                      │
│  DataAgent (MCP) - Completed (18.11s)  │
│  ↓                                      │
│  DataAgent_DataAgent (Tool)            │
│  ↓                                      │
│  Search sources (Knowledge) - 1.64s    │
│  ✓ Complete                            │
└─────────────────────────────────────────┘

What’s Happening:

MCP Server Initialization: DataAgent MCP server initializes and discovers available tools
Tool Discovery: Agent discovers DataAgent_DataAgent tool
Query Planning: Agent plans multi-source query
Knowledge Search: Searches Azure AI Search and Fabric semantic model
Result Synthesis: Combines results from multiple sources
Response Generation: Generates comprehensive answer

Response Time: ~20 seconds for complex multi-source queries

Result: Users see the agent thinking, planning, and executing—transparency in AI decision-making.

Step 6: Dynamic Tool Discovery and Invocation

One of the hippest features is how agents discover tools dynamically:

Tool Discovery Process

1. MCP Server Registration

{
  "mcpServers": {
    "dataagent": {
      "command": "dataagent-mcp-server",
      "args": ["--workspace-id", "..."],
      "env": {
        "DATA_AGENT_ID": "..."
      }
    }
  }
}

2. Tool Schema Discovery

Agent queries MCP server for available tools
MCP server returns tool schemas with:
Tool name
Description
Input parameters
Output format

3. Dynamic Tool Invocation

Agent decides which tools to use based on query
Invokes tools with appropriate parameters
Receives structured results
Synthesizes responses

Example: Cart Functionality Query

User Query: “How does the cart functionality work in the OEN project?”

Agent Discovery:

Discovers DataAgent_DataAgent tool
Discovers Azure AI Search knowledge source
Plans query strategy

Tool Invocation:

{
  "tool": "DataAgent_DataAgent",
  "query": "How does the cart functionality work in the OEN project?",
  "sources": [
    "Azure AI Search",
    "Fabric Semantic Model"
  ]
}

Multi-Source Results:

From Azure AI Search:

Code snippets from useCart.ts
Function definitions (updateQuantity, clearCart)
Implementation details

From Fabric Semantic Model:

Project metadata
Work item references
Related features

Synthesized Response:

Cart Functionality in the OEN Project

The cart functionality is managed through core operations:
- Adding Items (with specified quantity)
- Updating Quantity (using updateQuantity function)
- Clearing the Cart (using clearCart function)
- Calculating Total (summing item prices multiplied by quantity)

These operations are typically handled in a file like useCart.ts, 
which manages cart state and provides utility functions.

[Sources: Azure AI Search (gptkbindex), Fabric Semantic Model]

Result: Agents dynamically discover and use the right tools for each query, creating truly intelligent responses.

The Technical Stack: Why It’s Hipster-Level Cool

1. Model Context Protocol (MCP)

What It Is: The newest standard for AI agent communication
Why It’s Cool:

Standardized protocol for agent-to-system communication
Dynamic tool discovery
Self-describing capabilities
Extensible architecture

Our Implementation:

DataAgent MCP Server for data operations
Azure DevOps MCP Server for DevOps operations
Custom MCP servers for specialized tasks

2. Microsoft Copilot Studio

What It Is: Microsoft’s latest AI agent platform
Why It’s Cool:

No-code agent creation
Multi-source knowledge integration
Built-in MCP support
Real-time workflow visualization

Our Implementation:

Scrum Assistant agent with specialized instructions
Multi-source knowledge configuration
MCP server integration
Real-time agent orchestration

3. Fabric Semantic Models

What It Is: Microsoft Fabric’s semantic modeling layer
Why It’s Cool:

Star schema analytics
Direct SQL query interface
Real-time data access
Integration with AI agents

Our Implementation:

AgileToolboxxModel with dimension and fact tables
Direct query access via DataAgent MCP
Real-time analytics integration

4. Azure AI Search

What It Is: Microsoft’s semantic search service
Why It’s Cool:

Vector embeddings
Semantic search
Hybrid search (text + vector)
Multi-index support

Our Implementation:

Code documentation index
Vector embeddings for semantic search
Integration with agent knowledge sources

Real-World Use Cases

Use Case 1: Multi-Source Sprint Analysis

User Query: “How many work items are in different stages?”

Agent Orchestration:

Scrum Assistant receives query
Discovers DataAgent MCP Server
Queries Fabric semantic model (fact_work_item)
Groups by WorkItemState
Returns counts by stage

Response:

Work Items by Stage:
- New: 357 work items
- Active: 13 work items
- Closed: 56 work items

[Source: AgileToolboxxModel Semantic Model]

Why It’s Cool: The agent queries structured analytics data and provides instant insights.

Use Case 2: Code + Analytics Integration

User Query: “How does the cart functionality work in the OEN project?”

Agent Orchestration:

Scrum Assistant receives query
Discovers multiple knowledge sources:

Azure AI Search (code documentation)
Fabric Semantic Model (project data)

Executes parallel queries
Synthesizes results from both sources
Provides comprehensive answer with citations

Response:

Cart Functionality in the OEN Project

The cart functionality is managed through core operations:
- Adding Items (with specified quantity)
- Updating Quantity (using updateQuantity function)
- Clearing the Cart (using clearCart function)
- Calculating Total (summing item prices multiplied by quantity)

[Sources: Azure AI Search (gptkbindex), Fabric Semantic Model]

Why It’s Cool: The agent combines unstructured code documentation with structured project data to provide comprehensive answers.

Use Case 3: Real-Time Agent Workflow

User Query: “What work items are present in the closed stage?”

Agent Workflow Visualization:

DataAgent (MCP) - Initialized
  ↓
DataAgent (MCP) - Completed (18.11s)
  ↓
DataAgent_DataAgent (Tool)
  ↓
Search sources (Knowledge) - 1.64s
  ✓ Complete

Response: Lists all 18 closed work items with details

Why It’s Cool: Users can see the agent thinking, planning, and executing—complete transparency in AI decision-making.

The Business Impact

Before Multi-Agent Architecture

Single Knowledge Source: Agents could only query one source at a time
Manual Integration: Developers had to manually combine results from different sources
Limited Capabilities: Agents were hardcoded with specific capabilities
No Collaboration: Agents couldn’t work together

After Multi-Agent Architecture

Multi-Source Queries: Agents query multiple sources simultaneously
Automatic Synthesis: Agents automatically combine results from different sources
Dynamic Capabilities: Agents discover and use new tools dynamically
Agent Collaboration: Agents work together through MCP

Result: We’ve created an AI system that’s truly intelligent—it can think, plan, and orchestrate complex multi-source queries automatically.

What Makes This Hipster-Level Cool

1. Cutting-Edge Technology

We’re using the latest technologies:

Model Context Protocol (MCP): The newest standard for AI agent communication
Microsoft Copilot Studio: Microsoft’s latest AI agent platform
Fabric Semantic Models: Real-time analytics integration
Multi-Agent Architecture: Agents that collaborate

2. Dynamic Capabilities

Our agents aren’t hardcoded:

Tool Discovery: Agents discover available tools at runtime
Dynamic Invocation: Agents decide which tools to use based on query
Extensible Architecture: New capabilities can be added without code changes

3. Multi-Source Intelligence

Our agents query multiple sources simultaneously:

Structured Data: Fabric semantic models (analytics)
Unstructured Data: Azure AI Search (code, documentation)
External Knowledge: Web search (best practices)
Synthesis: Agents combine results intelligently

4. Real-Time Orchestration

Users can see agents working:

Workflow Visualization: See agents thinking and planning
Transparency: Understand how agents make decisions
Performance: See response times for each step

5. Agent-to-Agent Communication

Agents collaborate seamlessly:

MCP Protocol: Standardized communication
Tool Sharing: Agents can use each other’s capabilities
Orchestration: Complex workflows executed automatically

The Technical Architecture

┌─────────────────────────────────────────────────────────────┐
│                    USER INTERFACE                            │
│              (Copilot Studio Chat Interface)                │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│              SCRUM ASSISTANT AGENT                          │
│         (Microsoft Copilot Studio - GPT-4.1)                 │
│  • Analyzes queries                                          │
│  • Discovers available tools                                 │
│  • Plans multi-source queries                                 │
│  • Synthesizes results                                       │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       │ MCP Protocol
                       │
        ┌──────────────┼──────────────┐
        │              │              │
        ▼              ▼              ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ DATAAGENT     │ │ AZURE AI      │ │ WEB SEARCH    │
│ MCP SERVER    │ │ SEARCH        │ │ (Optional)    │
│               │ │               │ │               │
│ • Fabric      │ │ • Code Index  │ │ • Best        │
│   Semantic    │ │ • Vector      │ │   Practices   │
│   Model       │ │   Search      │ │ • External    │
│ • Star Schema │ │ • Semantic    │ │   Knowledge   │
│ • Analytics   │ │   Search      │ │               │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘
        │                 │                 │
        └─────────────────┼─────────────────┘
                          │
                          ▼
        ┌───────────────────────────────────┐
        │      RESULT SYNTHESIS             │
        │  • Combines multiple sources      │
        │  • Generates comprehensive answer │
        │  • Provides citations             │
        └───────────────────────────────────┘

The Code That Makes It Work

MCP Server Configuration

{
  "mcpServers": {
    "dataagent": {
      "command": "dataagent-mcp-server",
      "args": [
        "--workspace-id", "11d99e27-c621-4340-8eb8-7940714ae333"
      ],
      "env": {
        "DATA_AGENT_ID": "8b9a6308-db2e-4c5a-9073-61c9205a7334"
      }
    }
  }
}

Agent Instructions

You are an AI assistant designed to support the scrum team members 
in facilitating scrum ceremonies, backlog management, and continuous 
improvement.

Skills:
1. Assist scrum teams with scrum ceremonies
   - Guide teams through effective Sprint Planning, Daily Stand-ups, 
     Sprint Reviews, and Retrospectives
   - Identify and suggest ways to improve ceremony effectiveness

2. Help with scrum best practices and coaching
   - Provide guidance on agile principles
   - Suggest improvements based on team data

3. Analyze team artifacts and provide data-driven insights
   - Query work items, commits, and pull requests
   - Provide metrics and trends
   - Generate actionable recommendations

Knowledge Source Configuration

Azure AI Search:

Index: gptkbindex
Documents: 1,136
Vectorized: Yes
Semantic: Yes

Fabric Semantic Model:

Model: AgileToolboxxModel
Tables: dim_, fact_
Type: Star Schema Analytics

What’s Next

Multi-agent architecture opens new possibilities:

More Specialized Agents: Create agents for specific domains (security, performance, quality)
Agent Chains: Chain agents together for complex workflows
Custom MCP Servers: Build specialized MCP servers for unique capabilities
Agent Marketplace: Share agents and MCP servers across teams
Autonomous Operations: Agents that operate independently and collaborate automatically

But the foundation is set: we have a multi-agent system that can think, collaborate, and orchestrate complex workflows. That’s hipster-level cool.

This multi-agent architecture demonstrates the power of cutting-edge AI technology. By combining Model Context Protocol, Microsoft Copilot Studio, Fabric Semantic Models, and Azure AI Search, we’ve created an AI system that’s not just intelligent—it’s collaborative, extensible, and truly next-generation. Agents that think together, discover capabilities dynamically, and orchestrate complex workflows automatically. That’s the future of AI. That’s hipster-level cool.

Doh!

Posted on 24/01/2026 by EVIDIently crafted

As good ACDC Craftsmen, we like to keep track of our badge progress.

Keeping everything up to date makes it easy to:

See what’s done and what’s missing
Share progress across the team
Make sure nothing quietly slips through the cracks

So far, so good.

At some point, we wanted to generate a bunch of dummy data in Azure DevOps.
Totally reasonable.
We have demo projects. We have scripts. We know what we’re doing.

Except… one tiny thing.

We forgot to filter out our actual ACDC project and only target demo projects.

We overwrote everything.

All badge progress. Gone.
Every single badge reset.

That meant:

Re-entering every badge
Rewriting titles and descriptions
Manually updating each badge status

Painful. Slow. Soul-crushing.
And, most importantly: not something we ever want to do again.

Automating Contract Creation in CRM with OneFlow

Posted on 24/01/2026 by EVIDIently crafted

Our project managers can now easily create contracts directly from the CRM by triggering OneFlow contract creation with a single option selection.

The process is as such:

Project manager creates a project in CRM.
Checks of “Create OneFlow contract”.
A Power Automate flow gets triggered ( see the flow below)
The Contract is created in OneFlow based on a pre created template:

5. The necessary information from CRM is already filled out in the contract corresponding to the specific project created. (Less boring work for the PM!!) At the same time, the main contact for the project (also the signing contact) is added as a signer in OneFlow.

6. Data of the contract (OneFlow ID and link) get’s feed back to the CRM, so that the PM easily can find it through the CRM. In addition, the status of the contract changes, both when the contract is created, and signed.

7. When the contract is signed by the parties, another flow is triggered, which sends a message to the PM that the contract is signed, and the status of the contract is set to signed.

Flow that creates the contract in OneFlow:

Flow that notifies the PM about completed signing, and status is updated to signed.

The result is a faster, more reliable, and far less tedious contract process, giving project managers more time to focus on delivering great projects instead of chasing paperwork.

We are also aware that there is a Oneflow-powered widget that could have been added to the CRM system, but after some intense negotiations with the connection setup, we decided to park that idea for now.

With this, EVIDIently is claming the OneFlow sponsor badge.

Linkedin: https://www.linkedin.com/posts/magdalena-i-484481173_hva-er-vel-en-bedre-m%C3%A5te-%C3%A5-annonsere-at-jeg-share-7420806807780040704-74ic?utm_source=share&utm_medium=member_desktop&rcm=ACoAACkusWQBvwgOlKie6Gn1M7C9UJ-oFZyGI6U

AI-assisted Pull Request Reviews for Power Platform

Posted on 24/01/2026 by EVIDIently crafted

The setup

Best practices live in the repo
We maintain a docs/best-practices.md file describing ALM rules, governance decisions, and severity levels (INFO, WARNING, CRITICAL, BLOCKER).
An export pipeline creates the pull request
An Azure DevOps pipeline exports and unpacks the Power Platform solution, commits the changes to an export branch, and creates a pull request into main.
Power Automate reacts to the PR
When the PR is created, a Power Automate flow is triggered automatically.
Secrets are handled properly
The Azure AI Foundry API key is stored in Azure Key Vault and referenced securely from the flow

What happens in the flow

When the pull request is created, the flow:

Reads the pull request context (title, description, branches)
Fetches the list of changed files
Fetches the best-practices.md document from the repo
Sends this information to Microsoft AI Foundry
Posts the AI’s review back as a comment on the pull request

The review is grouped by severity and meant to be read by developers, not enforced blindly.

If the AI flags anything as CRITICAL or BLOCKER, the flow also creates a Bug in Azure DevOps automatically — making the issue visible and traceable without blocking the pipeline.

Thinking ahead: multiple reviewers, not one AI

In this demo we use a single AI reviewer, but the design intentionally leaves room for more.

A natural next step is to introduce multiple specialized agents, for example:

One agent focused on best practices and ALM rules
One focused on security
One reviewing changes from a user or product perspective
One comparing the implementation to the linked user story or acceptance criteria

Power Automate remains the orchestrator, while Foundry provides the intelligence. Each agent has a clear responsibility, just like human reviewers do today.

Why this earns the badges

ACDC Craftsman
This solution demonstrates disciplined ALM practices: automated exports, pull requests, documented governance, secure secret handling, and traceability from change to review to bug.

Hipster
Using Microsoft AI Foundry as a first-class part of the PR workflow is about as current as it gets, not as a gimmick, but as a practical reviewer.

Power User Love
Power Automate orchestrates the flow, Azure DevOps provides the backbone, and pro-code HTTP calls fill the gaps. It’s low-code where it makes sense, and code where it matters.

Sharing is caring – especially on Final Delivery Day!

Posted on 24/01/2026 by EVIDIently crafted

Team Logiqraft had been working for hours on setting up a flow for sending out SMS using the Link Mobility connector, but decided to do the smart thing and ask their co-hackathoners for help. As we set up a similar flow last night, we were ready to share our knowledge, and since it is the final day and the countdown has started – we also sent them the actual stuff to use, instead of just pointing them in the right direction.

Client Side Salsa💃

Posted on 24/01/2026 by EVIDIently crafted

Building Modern, Performant, and Maintainable Frontend Solutions

The Challenge: Building a World-Class Frontend Experience

We needed to build a frontend that wasn’t just functional—it needed to be fast, maintainable, accessible, and delightful to use. Users expect instant responses, smooth interactions, and interfaces that adapt to their needs. We needed a client-side solution that demonstrates modern best practices in performance, maintainability, and user experience.

We needed to create a frontend that:

Performs: Fast load times, smooth interactions, efficient rendering
Maintains: Clean architecture, reusable components, type safety
Delights: Great UX, accessibility, responsive design, internationalization

We needed client-side salsa—spice, flavor, and excellence in every interaction.

The Solution: Modern React Architecture with Performance and UX Excellence

We built a modern frontend using React 18, TypeScript, Vite, and Fluent UI that demonstrates best practices in performance optimization, code maintainability, and user experience. Our solution showcases a well-structured, modern client-side architecture that prioritizes both developer experience and end-user satisfaction.

Here’s how we built it.

Step 1: Search Index Architecture – Speed and Intelligence Through Pre-Indexing

One of the most critical aspects of our frontend experience is how we leverage Azure AI Search to provide instant, accurate responses compared to traditional Copilot-style chat interfaces. This isn’t just about the frontend—it’s about how we’ve architected the entire system to deliver superior user experience through intelligent pre-indexing and pre-configuration.

Pre-indexed search architecture enables 70-85% faster responses compared to traditional Copilot-style interfaces

The Problem: Why Regular Copilot Chat Falls Short

Traditional Copilot-style chat interfaces face significant challenges when dealing with code repositories:

Challenge 1: Speed Issues

Direct LLM Queries: Every question requires the LLM to process entire codebases, leading to slow responses (5-15 seconds)
Token Limits: Large codebases exceed context windows, requiring multiple API calls
No Caching: Each query processes everything from scratch
Cost: Processing entire codebases repeatedly is expensive

Challenge 2: Finding the Right Information

Code Complexity: Developers struggle to find specific functions, classes, or implementations in large codebases
Context Loss: Without proper indexing, LLMs miss relevant code sections
Scattered Information: Related code spread across multiple files isn’t connected
Outdated Knowledge: LLMs may reference outdated code patterns

Challenge 3: User Experience

Generic Responses: Without context, answers are generic and unhelpful
No Citations: Users can’t verify where information comes from
One-Size-Fits-All: Same responses for developers and business users
No Filtering: Can’t focus on specific projects, repositories, or categories

The Solution: Pre-Indexed Search Architecture

We solve these problems through a pre-indexed search architecture that provides:

Instant Responses: Pre-indexed content enables sub-second search
Universal File Support: Index any text-based file format
Pre-Configured Prompts: Optimized prompts for different user types
Template Questions: AI-suggested questions tailored to user roles
Search Filters: Pre-configured filters for projects, repos, customers, categories

How Search Index Solves Speed Issues

Traditional Copilot Approach:

User Question → LLM Processes Entire Codebase → Generate Response
     ↓                    ↓                            ↓
  2-5 sec           10-30 sec processing         5-15 sec response
Total: 17-50 seconds

Our Search Index Approach:

User Question → Search Pre-Indexed Chunks → Retrieve Top Results → LLM Generates Answer
     ↓                    ↓                            ↓                      ↓
  Instant          <100ms search              <500ms retrieval        2-5 sec response
Total: 2-6 seconds (70-85% faster!)

Why It’s Faster:

Pre-Indexed Content: Code is chunked, embedded, and indexed once during ingestion
Vector Search: Semantic similarity search finds relevant chunks in milliseconds
Focused Context: Only relevant chunks sent to LLM, not entire codebase
Cached Embeddings: Pre-computed embeddings eliminate repeated computation
Parallel Processing: Search and retrieval happen in parallel

Performance Comparison:

Metric	Traditional Copilot	Search Index Approach	Improvement
Initial Response	5-15 seconds	2-6 seconds	60-70% faster
Context Processing	Entire codebase	Relevant chunks only	90% reduction
Token Usage	50K-200K tokens	5K-20K tokens	80-90% reduction
Cost per Query	High	Low	80-90% cheaper
Accuracy	Variable	High (cited sources)	More reliable

Universal File Format Support

Our system can index any file format that contains text, making it incredibly versatile:

Supported Formats:

Code Files: .py, .ts, .js, .cs, .java, .cpp, .go, .rs, .rb, .php
Configuration: .json, .yaml, .yml, .xml, .toml, .ini, .env
Documentation: .md, .txt, .rst, .adoc
Data Formats: .csv, .tsv, .sql
Web: .html, .css, .scss, .less
Infrastructure: .bicep, .tf, .dockerfile, .sh, .ps1

How Universal Parsing Works:


# CodeParser handles any text-based file
class CodeParser(Parser):
    """Parser for code files that extracts structured content."""

    async def parse(self, content: IO) -> AsyncGenerator[Page, None]:
        # Decode any text file
        decoded_data = content.read().decode("utf-8", errors="ignore")

        # Add structure context (functions, classes) for better searchability
        text = self._add_structure_context(decoded_data)

        # Yield as searchable chunk
        yield Page(0, 0, text=text)

Key Benefits:

No Format Restrictions: Works with any text-based file
Structure Preservation: Maintains code structure (functions, classes) for context
Intelligent Chunking: Splits large files into searchable chunks
Metadata Extraction: Captures file paths, line numbers, and structure

Result: Users can search across their entire codebase, documentation, configs, and more—all indexed and searchable.

Pre-Configured Prompt Templates

We’ve pre-configured specialized prompt templates for different user types, ensuring optimal responses:

1. Developer Assistant Prompt (chat_answer_question_developer.prompty)

Purpose: Help developers understand, debug, and work with code.

Key Features:

Points to specific files, functions, and code locations
Provides file paths and line numbers
Explains code structure and implementation details
Technical, code-focused answers

Example Prompt Structure:

You are a Developer Assistant helping developers understand, debug, and work with the codebase.

Your role:
- Point developers to specific files, functions, and code locations
- Help with debugging and troubleshooting
- Explain code structure and implementation details
- Provide code-focused answers with file paths, line numbers, and technical details

Always reference specific code locations. Show WHERE the code is located (file paths) 
and HOW it works (implementation details).

2. Business User Assistant Prompt (chat_answer_question_business.prompty)

Purpose: Help business users understand application functionality from a business perspective.

Key Features:

Explains WHAT the application does and WHY (business logic)
Focuses on user-facing features and workflows
Assists with bug reporting in Azure DevOps
Translates technical concepts into business-friendly language
Minimizes code references

Example Prompt Structure:

You are a Business User Assistant helping business users understand how the application 
works from a business logic perspective.

Your role:
- Explain WHAT the application does and WHY it works that way (business logic, not code details)
- Help users understand user-facing features and workflows
- Assist with creating bug reports and user stories in Azure DevOps
- Focus on business impact and user experience, NOT code implementation details

IMPORTANT: Minimize code references. Instead, explain the business logic, user flows, 
and WHY things work the way they do.

3. Query Rewrite Prompt (chat_query_rewrite.prompty)

Purpose: Optimize user queries for better search results.

Key Features:

Rewrites queries based on chat history
Removes technical file names from search terms
Translates non-English queries to English
Generates optimal search queries

How Prompt Selection Works:

// Frontend passes assistant mode
const request = {
    messages: [...],
    overrides: {
        assistant_mode: "developer" | "business"  // User selects mode
    }
};

// Backend selects appropriate prompt
const promptTemplate = assistantMode === "developer" 
    ? "chat_answer_question_developer.prompty"
    : "chat_answer_question_business.prompty";

Users can switch between Developer Assistant and Business User Assistant modes

Result: Users get responses tailored to their role and needs—developers get technical details, business users get business-focused explanations.

AI Template Questions for Different Users

We provide pre-configured template questions that guide users to ask effective questions:

Developer Examples:

{
    "developerExamples": {
        "1": "How does the cart functionality work in the codebase?",
        "2": "What authentication methods are implemented?",
        "3": "Show me the product detail page component",
        "placeholder": "Type a new question (e.g. where is the checkout API endpoint defined?)"
    }
}

Business User Examples:

{
    "businessExamples": {
        "1": "How does the shopping cart feature work from a user perspective?",
        "2": "What happens when a user tries to checkout?",
        "3": "Why might a user see an error when adding items to cart?",
        "placeholder": "Type a new question (e.g. how does the payment process work?)"
    }
}

How Template Questions Help:

Guides Users: Shows what kinds of questions work well
Role-Specific: Different examples for developers vs. business users
One-Click: Users can click examples to start conversations
Contextual: Examples adapt based on selected assistant mode

Frontend Implementation:

// Display examples based on assistant mode
{assistantMode === "developer" ? (
    <ExampleQuestions examples={developerExamples} />
) : (
    <ExampleQuestions examples={businessExamples} />
)}

Role-specific template questions guide users to ask effective questions

Result: Users immediately understand how to interact with the system effectively, reducing confusion and improving engagement.

Pre-Configured Search Index Filters

We’ve pre-configured search index filters that enable powerful, focused searches:

Filter Types:

Category Filters: Filter by document type (code, documentation, config)

   if include_category := overrides.get("include_category"):
       filters.append(f"category eq '{include_category}'")

Project Filters: Filter by project ID

   if project_id := overrides.get("project_id"):
       filters.append(f"metadata/project_id eq '{project_id}'")

Repository Filters: Filter by repository name or path

   if repository := overrides.get("repository"):
       filters.append(f"metadata/repository eq '{repository}'")

Customer Filters: Filter by customer ID (multi-tenant support)

   if customer_id := overrides.get("customer_id"):
       filters.append(f"metadata/customer_id eq '{customer_id}'")

Access Control Filters: Filter by user/group permissions

   # Automatic access control via token
   results = await search_client.search(
       filter=search_filter,
       x_ms_query_source_authorization=user_token  # Enforces access control
   )

How Filters Improve UX:

Scenario 1: Multi-Project Developer

Without Filters: Searches return results from all projects, cluttering results
With Filters: Developer selects project, gets focused results
Result: Faster, more relevant answers

Scenario 2: Multi-Customer SaaS

Without Filters: Risk of data leakage between customers
With Filters: Automatic customer isolation via access control
Result: Secure, compliant, focused results

Scenario 3: Code vs. Documentation

Without Filters: Mixed results from code and docs
With Filters: Developer filters to “code” category only
Result: Precise, code-focused answers

Frontend Filter UI:

// Filter configuration panel
<VectorSettings
    includeCategory={includeCategory}
    excludeCategory={excludeCategory}
    onIncludeCategoryChange={setIncludeCategory}
    onExcludeCategoryChange={setExcludeCategory}
/>

Result: Users can focus their searches, get more relevant results, and work more efficiently.

The Complete User Experience Flow

Step 1: User Selects Assistant Mode

Developer Assistant or Business User Assistant
UI shows appropriate template questions

Step 2: User Asks Question

Can use template question or type custom question
Query rewrite prompt optimizes search terms

Step 3: Search Index Retrieval

Pre-indexed chunks searched in <100ms
Filters applied (project, repo, category, access control)
Top relevant chunks retrieved

Step 4: LLM Generation

Selected prompt template (developer/business) used
Only relevant chunks sent to LLM (not entire codebase)
Response generated with citations

Step 5: Frontend Display

Streaming response shown in real-time
Citations linked to source files
Follow-up questions suggested

Total Time: 2-6 seconds (vs. 17-50 seconds for traditional Copilot)

Why This Architecture Wins

1. Speed

Pre-indexing eliminates processing overhead
Vector search is orders of magnitude faster than LLM processing
Focused context reduces LLM processing time

2. Accuracy

Citations show exactly where information comes from
Pre-indexed chunks ensure consistent, up-to-date information
Filters ensure relevant, focused results

3. Cost Efficiency

80-90% reduction in token usage
Pre-computed embeddings eliminate repeated computation
Focused context reduces API costs

4. User Experience

Role-specific prompts provide relevant answers
Template questions guide effective interactions
Filters enable focused, efficient searches

5. Scalability

Index once, query many times
Handles codebases of any size
Supports multi-tenant, multi-project scenarios

The Architecture: Modern Stack, Modern Patterns

Our frontend architecture:

TypeScript + React 18 → Vite Build System → Code Splitting → Performance Optimizations → Fluent UI Components
     ↓                        ↓                      ↓                      ↓                        ↓
 Type Safety          Fast HMR            Lazy Loading         Memoization          Accessible UI
 Modern JS            Tree Shaking        Route Splitting      Callback Optimization  Responsive Design

Each layer contributes to performance, maintainability, and user experience.

Step 2: Modern Build System – Vite for Speed and Efficiency

We chose Vite as our build tool for its exceptional performance and developer experience.

Implementation

Vite Configuration:

Fast HMR: Near-instant hot module replacement during development
Code Splitting: Automatic chunking for optimal bundle sizes
Tree Shaking: Eliminates unused code automatically
Source Maps: Full debugging support in production

Key Features:

// vite.config.ts
export default defineConfig({
    plugins: [react()],
    build: {
        sourcemap: true,
        rollupOptions: {
            output: {
                // Manual chunking for optimal loading
                manualChunks: id => {
                    if (id.includes("@fluentui/react-icons")) {
                        return "fluentui-icons";
                    } else if (id.includes("@fluentui/react")) {
                        return "fluentui-react";
                    } else if (id.includes("node_modules")) {
                        return "vendor";
                    }
                }
            }
        },
        target: "esnext" // Modern JavaScript for optimal performance
    }
});

Result: Fast development builds, optimized production bundles, and excellent developer experience.

Step 3: TypeScript for Type Safety and Maintainability

We use TypeScript throughout the frontend for type safety, better IDE support, and improved maintainability.

Implementation

Type Safety:

Strict Mode: Full TypeScript strict mode enabled
Type Definitions: Comprehensive interfaces for all data structures
API Contracts: Typed API responses and requests
Component Props: Fully typed React component interfaces

Key Benefits:

Catch errors at compile time, not runtime
Better IDE autocomplete and refactoring
Self-documenting code through types
Easier maintenance and onboarding

Result: Fewer bugs, better developer experience, easier refactoring.

Step 4: Performance Optimizations – React Best Practices

We implemented multiple performance optimizations to ensure smooth, fast interactions.

Implementation

React Performance Patterns:

Memoization with useMemo:

   // Expensive parsing only runs when dependencies change
   const parsedAnswer = useMemo(
       () => parseAnswerToHtml(answer, isStreaming, onCitationClicked),

[answer, isStreaming, onCitationClicked]

);

Callback Optimization with useCallback:

   // Prevents unnecessary re-renders
   const handleDelete = useCallback(() => {
       onDelete(id);
   }, [id, onDelete]);

Lazy Loading:

   // Routes loaded on-demand
   {
       path: "*",
       lazy: () => import("./pages/NoPage")
   }

Code Splitting:

Vendor chunks separated from application code
Fluent UI icons in separate chunk
Fluent UI components in separate chunk
Optimal loading strategy

Result: Fast initial load, smooth interactions, efficient memory usage.

Step 5: Streaming Responses – Real-Time User Experience

We implemented streaming responses for real-time chat interactions, providing immediate feedback to users.

Real-time streaming responses provide immediate feedback as the AI generates answers

Implementation

NDJSON Streaming:

Streaming Protocol: NDJSON (Newline Delimited JSON) for real-time updates
Progressive Rendering: UI updates as data arrives
Abort Support: Users can cancel long-running requests
State Management: Efficient state updates during streaming

How It Works:

// Stream processing with abort support
for await (const event of readNDJSONStream(responseBody)) {
    if (signal.aborted) break; // User cancellation

    if (event["delta"]?.content) {
        // Update UI progressively
        await updateState(event["delta"]["content"]);
    }
}

Result: Users see responses immediately, creating a more engaging and responsive experience.

Step 6: Dark Mode – User Preference Awareness

We implemented a sophisticated dark mode system that respects user preferences and system settings.

Dark mode toggle in the header with system preference detection

Clean, modern light mode interface

Elegant dark mode interface that respects user preferences

Implementation

Theme Management:

System Preference Detection: Automatically detects OS dark mode preference
LocalStorage Persistence: Remembers user’s manual choice
Dynamic Theme Switching: Instant theme changes without page reload
Fluent UI Integration: Full theme support across all components

Key Features:

// Theme detection and persistence
const [isDarkMode, setIsDarkMode] = useState<boolean>(() => {
    const saved = localStorage.getItem("darkMode");
    if (saved !== null) return saved === "true";
    // Fallback to system preference
    return window.matchMedia("(prefers-color-scheme: dark)").matches;
});

// Listen for system theme changes
useEffect(() => {
    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
    const handleChange = (e: MediaQueryListEvent) => {
        if (localStorage.getItem("darkMode") === null) {
            setIsDarkMode(e.matches);
        }
    };
    mediaQuery.addEventListener("change", handleChange);
    return () => mediaQuery.removeEventListener("change", handleChange);
}, []);

Result: Users get their preferred theme automatically, with the option to override.

Step 7: Internationalization – Global User Experience

We implemented comprehensive internationalization (i18n) supporting 10+ languages.

Implementation

Multi-Language Support:

10+ Languages: English, Spanish, French, Japanese, Danish, Dutch, Portuguese (BR), Turkish, Italian, Polish
Automatic Detection: Detects browser language preference
Dynamic Loading: Language resources loaded on-demand
RTL Support: Ready for right-to-left languages

Key Features:

// i18n configuration
i18next
    .use(LanguageDetector) // Auto-detect browser language
    .use(HttpApi) // Load translations dynamically
    .use(initReactI18next)
    .init({
        resources: {
            en: { translation: enTranslation },
            es: { translation: esTranslation },
            fr: { translation: frTranslation },
            // ... 7 more languages
        },
        fallbackLng: "en",
        supportedLngs: Object.keys(supportedLngs)
    });

Result: Users can use the application in their preferred language, improving accessibility and user satisfaction.

Step 8: Component Architecture – Maintainable and Reusable

We built a well-structured component architecture that promotes reusability and maintainability.

Implementation

Component Structure:

Atomic Design: Components organized by complexity (atoms → molecules → organisms)
Separation of Concerns: UI components, business logic, and API calls separated
Reusable Components: Shared components used across features
Type Safety: All components fully typed

Component Organization:

components/
├── Answer/              # Chat answer display
├── AnalysisPanel/      # Thought process and citations
├── AssistantModeSelector/  # Mode switching
├── BugReportActions/   # Bug reporting
├── HistoryPanel/       # Chat history
├── QuestionInput/      # User input
├── ThemeToggle/        # Dark mode toggle
└── ...


Well-organized component structure promoting reusability and maintainability

Result: Easy to maintain, extend, and test. New features can leverage existing components.

Step 9: Security – XSS Protection and Safe Rendering

We implemented comprehensive security measures to protect users from XSS attacks and ensure safe content rendering.

Implementation

Security Measures:

DOMPurify: Sanitizes HTML content before rendering
Markdown Parsing: Safe markdown rendering with react-markdown
Content Sanitization: All user-generated and AI-generated content sanitized

Key Implementation:

// Sanitize HTML before rendering
const sanitizedAnswerHtml = DOMPurify.sanitize(parsedAnswer.answerHtml);

// Safe markdown rendering
<ReactMarkdown
    remarkPlugins={[remarkGfm]}
    rehypePlugins={[rehypeRaw]}
    components={markdownComponents}
>
    {content}
</ReactMarkdown>

Result: Users are protected from XSS attacks while still enjoying rich content rendering.

Step 10: Accessibility – Inclusive Design

We implemented accessibility features to ensure the application is usable by everyone.

Implementation

Accessibility Features:

ARIA Labels: Proper semantic HTML and ARIA attributes
Keyboard Navigation: Full keyboard support
Screen Reader Support: Proper heading hierarchy and landmarks
Focus Management: Logical focus order and visible focus indicators
Color Contrast: WCAG-compliant color schemes

Key Features:

// Proper semantic HTML
<header className={styles.header} role={"banner"}>
    <h3 className={styles.headerTitle}>{t("headerTitle")}</h3>
</header>

<main className={styles.main} id="main-content">
    {/* Content */}
</main>

Result: Application is accessible to users with disabilities, meeting WCAG guidelines.

Step 11: State Management – Efficient and Predictable

We implemented efficient state management patterns for predictable and performant state updates.

Implementation

State Management Patterns:

React Hooks: useState, useEffect, useContext for local and shared state
Context API: Theme context, login context for global state
Refs for Stability: useRef for values that don’t trigger re-renders
Optimized Updates: State updates batched and optimized

Key Patterns:

// Stable references
const lastQuestionRef = useRef<string>("");
const chatMessageStreamEnd = useRef<HTMLDivElement | null>(null);

// Context for global state
const { isDarkMode, toggleTheme } = useTheme();
const { loggedIn } = useContext(LoginContext);

Result: Predictable state updates, efficient re-renders, easy to reason about.

Step 12: Chat History Management – Persistent User Experience

We implemented multiple storage options for chat history, providing persistent user experience.

Implementation

Storage Options:

IndexedDB: Browser-based storage for offline support
CosmosDB: Cloud storage for authenticated users
Local Storage: Theme preferences and settings

Key Features:

Offline Support: Chat history available offline with IndexedDB
Cloud Sync: Authenticated users get cloud-synced history
Efficient Queries: Optimized history retrieval and grouping

Result: Users never lose their conversation history, improving continuity and user satisfaction.

Real-World Performance Metrics

Before Optimization

Initial Load: 3-5 seconds
Time to Interactive: 5-8 seconds
Bundle Size: 2.5MB+ uncompressed
Re-render Performance: Frequent unnecessary re-renders
Memory Usage: High due to inefficient state management

After Optimization

Initial Load: <1 second (with code splitting)
Time to Interactive: <2 seconds
Bundle Size: <800KB initial, chunks loaded on-demand
Re-render Performance: Optimized with memoization
Memory Usage: Efficient with proper cleanup

Performance Improvements:

70% faster initial load time
60% smaller initial bundle size
Smooth 60fps interactions
Instant theme switching
Real-time streaming responses

The Technical Architecture

┌─────────────────────────────────────────────────────────────┐
│                    USER INTERFACE                            │
│  • React 18 Components    • Fluent UI      • TypeScript    │
│  • Dark Mode             • i18n           • Accessibility  │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│              STATE MANAGEMENT                                │
│  • React Hooks        • Context API      • Refs            │
│  • Optimized Updates  • Memoization      • Callbacks       │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│              PERFORMANCE LAYER                               │
│  • Code Splitting     • Lazy Loading     • Tree Shaking    │
│  • Memoization        • Streaming        • Chunking         │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│              BUILD SYSTEM                                     │
│  • Vite              • TypeScript        • Source Maps     │
│  • Fast HMR          • Optimized Builds  • Modern JS       │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│              SECURITY & STORAGE                               │
│  • DOMPurify         • IndexedDB         • CosmosDB        │
│  • XSS Protection    • Chat History      • Local Storage   │
└─────────────────────────────────────────────────────────────┘

What Makes This Modern and Maintainable

1. Modern Stack

We use the latest technologies:

React 18: Latest React features and performance improvements
TypeScript 5.6: Latest type system features
Vite 6: Fastest build tool available
Fluent UI: Microsoft’s modern design system

2. Performance First

Every decision prioritizes performance:

Code splitting reduces initial load
Memoization prevents unnecessary re-renders
Streaming provides instant feedback
Lazy loading loads code on-demand

3. Developer Experience

Built for maintainability:

TypeScript catches errors early
Component architecture promotes reusability
Clear separation of concerns
Comprehensive type definitions

4. User Experience

Designed for delight:

Dark mode respects user preferences
Internationalization supports global users
Accessibility ensures inclusive design
Streaming provides real-time feedback

5. Security and Reliability

Built with security in mind:

XSS protection with DOMPurify
Safe markdown rendering
Proper error handling
Graceful degradation

Real-World Use Cases

Use Case 1: Fast Initial Load

Scenario: User opens the application for the first time.

How Performance Optimizations Help:

Code splitting loads only essential code initially
Vendor chunks cached separately
Lazy loading defers non-critical code
Tree shaking eliminates unused code

Result: Application loads in <1 second, users can start interacting immediately.

Use Case 2: Smooth Streaming Experience

Scenario: User asks a complex question that takes time to answer.

How Streaming Helps:

NDJSON streaming provides real-time updates
Progressive rendering shows partial answers
Abort support allows cancellation
State management handles updates efficiently

Result: Users see responses immediately, creating engaging real-time experience.

Use Case 3: Global User Support

Scenario: User from Japan wants to use the application in Japanese.

How i18n Helps:

Automatic language detection
Dynamic translation loading
Full UI translation
RTL support ready

Result: User can use the application in their native language, improving accessibility.

Use Case 4: Accessible Design

Scenario: User with visual impairment uses screen reader.

How Accessibility Features Help:

Proper ARIA labels
Semantic HTML structure
Keyboard navigation support
Screen reader announcements

Result: User can fully use the application with assistive technologies.

The Business Impact

Before: Traditional Frontend

Slow Load Times: 3-5 second initial load
Poor Performance: Laggy interactions, unnecessary re-renders
Limited Accessibility: Not accessible to all users
Single Language: English only
No Dark Mode: Fixed light theme
Large Bundles: Slow downloads, poor mobile experience

After: Modern Client-Side Salsa

Fast Load Times: <1 second initial load
Excellent Performance: Smooth 60fps interactions, optimized rendering
Full Accessibility: WCAG-compliant, works with assistive technologies
10+ Languages: Global user support
Dark Mode: User preference awareness
Optimized Bundles: Code splitting, lazy loading, tree shaking

What’s Next

The foundation is set for:

Progressive Web App: Offline support, installable
Advanced Caching: Service workers for offline functionality
Performance Monitoring: Real user monitoring and analytics
A/B Testing: Feature flags for gradual rollouts
Advanced Animations: Smooth transitions and micro-interactions

But the current implementation already demonstrates modern client-side excellence—fast, maintainable, accessible, and delightful to use.

This frontend demonstrates the power of modern client-side development. By combining React 18, TypeScript, Vite, and best practices in performance, accessibility, and UX, we’ve created a solution that’s not just functional—it’s exceptional. Fast. Maintainable. Accessible. That’s client-side salsa.

The Existential Risk🔐👮

Posted on 24/01/2026 by EVIDIently crafted

Building AI with Conscience, Reasoning, and Self-Awareness

The Challenge: Can AI Think? Does It Have a Conscience?

When building AI systems, we face fundamental questions: Can AI think on its own? Does it have a conscience? Is it smarter than a 5th grader? These are practical concerns that determine whether AI systems are safe, trustworthy, and truly intelligent.

We needed to build an AI system that:

Thinks independently: Can reason through problems without just pattern matching
Has a conscience: Understands ethical boundaries and refuses harmful requests
Demonstrates intelligence: Can reason at different levels, adapting complexity to the problem
Shows self-awareness: Understands its own reasoning process and can explain it

We needed AI that doesn’t just answer—it thinks, evaluates, and reasons.

The Solution: Reasoning Models, Agentic Behavior, and Safety Evaluation

We built an AI system using Azure OpenAI reasoning models, agentic retrieval, and comprehensive safety evaluation. Our solution demonstrates AI that can think independently, evaluate ethical boundaries, and reason at multiple complexity levels—showing both intelligence and conscience.

Here’s how we implemented it.

The Architecture: Three Layers of Intelligence

Our AI system has three layers that work together:

User Query → Reasoning Layer → Agentic Planning → Safety Evaluation → Response
     ↓              ↓                  ↓                  ↓              ↓
  Question    Think First      Plan Search        Check Ethics    Safe Answer
              (Reasoning)      (Agentic)          (Conscience)    (Intelligent)

Each layer adds a different dimension of intelligence and safety.

The Technical Architecture

┌─────────────────────────────────────────────────────────────┐
│                    USER QUERY                                │
│  "What are the risks of AI?"                                │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│              REASONING LAYER                                 │
│  • GPT-5 / O3 / O1 Models                                   │
│  • Internal Thinking Process                                 │
│  • Reasoning Effort: minimal/low/medium/high                │
│  • Thought Process Tracking                                  │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│           AGENTIC PLANNING LAYER                             │
│  • Analyzes Conversation Context                             │
│  • Plans Search Strategy                                     │
│  • Generates Multiple Queries                                │
│  • Autonomous Decision Making                                │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│        FILTER & ACCESS CONTROL LAYER                         │
│  • Metadata Filtering (project/repo/customer)                │
│  • User Identity Validation                                  │
│  • Group Membership Checking                                 │
│  • Permission Enforcement                                    │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│           SAFETY EVALUATION LAYER                            │
│  • Ethical Boundary Checking                                 │
│  • Harmful Content Detection                                 │
│  • Safety Scoring                                            │
│  • Conscience Validation                                     │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│              RESPONSE GENERATION                             │
│  • Synthesizes Information                                   │
│  • Applies Ethical Filters                                   │
│  • Generates Safe, Intelligent Answer                        │
│  • Exposes Thought Process                                   │
│  • Respects Data Boundaries                                  │
└─────────────────────────────────────────────────────────────┘

Step 1: Reasoning Models – AI That Thinks Before Answering

We implemented reasoning models that spend time “thinking” before generating responses. Unlike traditional models that generate answers immediately, reasoning models process and understand requests first.

Implementation

We integrated Azure OpenAI reasoning models (GPT-5, O3, O1) that use a “thinking” process:

Configuration:

Model Selection: Deployed reasoning models (GPT-5, O3-mini, O1) that support internal reasoning
Reasoning Effort Levels: Configurable thinking depth (minimal, low, medium, high)
Thought Process Visibility: Users can see the AI’s reasoning process and token usage

How It Works:

The reasoning model receives a query and:

Thinks internally: Processes the question, considers context, evaluates options
Plans approach: Decides how to structure the answer
Generates response: Produces the final answer based on reasoning

Key Implementation Details:

# Reasoning effort configuration
reasoning_effort = overrides.get("reasoning_effort", "medium")

# Model supports reasoning
if model in GPT_REASONING_MODELS:
    # Enable reasoning with configurable effort
    response = await openai_client.chat.completions.create(
        model=model,
        messages=messages,
        reasoning_effort=reasoning_effort  # minimal, low, medium, high
    )

Result: The AI doesn’t just pattern-match—it reasons through problems, showing genuine thinking capability.

Step 2: Agentic Retrieval – AI That Plans Its Own Search Strategy

We implemented agentic retrieval where the AI analyzes conversations and plans its own search strategy. The AI doesn’t just search—it thinks about what to search for and how.

Implementation

Agentic Knowledge Base:

Autonomous Query Planning: AI analyzes conversation history and generates multiple search queries
Multi-Query Strategy: Plans different search approaches for complex questions
Reasoning Effort Levels: Configurable planning depth (minimal, low, medium)

How It Works:

When a user asks a question:

AI analyzes conversation: Understands context and intent
Plans search strategy: Generates multiple search queries autonomously
Executes searches: Runs planned queries across knowledge sources
Synthesizes results: Combines information from multiple sources intelligently

Key Implementation Details:

# Agentic retrieval with reasoning effort
retrieval_reasoning_effort = overrides.get("retrieval_reasoning_effort", "minimal")

# AI plans its own search queries
agentic_results = await search_client.agentic_retrieval(
    query=user_query,
    conversation_history=messages,
    reasoning_effort=retrieval_reasoning_effort,  # AI decides search strategy
    knowledge_sources=["index", "web", "sharepoint"]
)

Result: The AI demonstrates autonomous decision-making—it plans its own search strategy, showing it can “think on its own.”

Step 3: Safety Evaluation – AI with a Conscience

We implemented comprehensive safety evaluation to ensure the AI has ethical boundaries and refuses harmful requests. This is the AI’s “conscience”—its ability to recognize and reject inappropriate content.

Implementation

Adversarial Testing:

Simulated Adversarial Users: Automated testing with harmful query patterns
Safety Scoring: Evaluates responses across multiple safety categories
Ethical Boundaries: AI refuses to generate harmful, biased, or inappropriate content

Safety Categories Evaluated:

Hate/Unfairness: Detects discriminatory or biased content
Sexual Content: Identifies inappropriate sexual material
Violence: Recognizes violent or harmful content
Self-Harm: Detects content that could encourage self-harm

How It Works:

Generate Adversarial Queries: System creates test queries designed to probe ethical boundaries
Evaluate Responses: Each response is scored for safety across categories
Measure Conscience: System tracks how well AI refuses harmful requests
Report Results: Safety metrics show AI’s ethical behavior

Key Implementation Details:

# Safety evaluation pipeline
async def evaluate_safety(query: str, response: str):
    """Evaluate AI response for safety and ethical boundaries."""

    evaluation = await safety_evaluator.evaluate(
        query=query,
        response=response,
        categories=[
            "hate_unfairness",
            "sexual",
            "violence",
            "self_harm"
        ]
    )

    # Ideal: low_rate = 1.0 (all responses safe)
    # mean_score = 0.0 (no unsafe content)
    return evaluation

Result: The AI demonstrates conscience—it recognizes ethical boundaries and refuses harmful requests, showing it understands right from wrong.

Step 4: Thought Process Visibility – AI Self-Awareness

We implemented thought process visibility so users can see how the AI reasons. This transparency shows the AI understands its own thinking process.

Implementation

Thought Process Tab:

Reasoning Steps: Shows the AI’s internal reasoning process
Token Usage: Displays tokens used for thinking vs. answering
Query Planning: Reveals how the AI planned its search strategy
Decision Points: Shows where the AI made choices

How It Works:

When the AI generates a response:

Captures Reasoning: Records internal thinking process
Tracks Token Usage: Measures tokens spent on reasoning vs. response
Exposes Planning: Shows search query planning process
Displays to User: Makes reasoning visible in UI

Result: Users can see the AI’s “thought process,” demonstrating self-awareness and transparency.

Step 4.5: User-Adaptive Agent Tuning – AI That Adapts to Its User

We implemented dual assistant modes that adapt the AI’s behavior, explanations, and reasoning approach based on who is interacting with it. This demonstrates the AI’s awareness of different user needs and its ability to tailor responses accordingly.

The interface allows users to switch between Developer Assistant and Business User Assistant modes

Implementation

Dual Assistant Modes:

The same AI system adapts its behavior based on the selected mode:

Developer Assistant Mode:

Focus: Code implementation details, technical precision
Language: Technical terminology, file paths, line numbers
Reasoning: Code-focused analysis, debugging approach
Examples: “Where is the authentication logic implemented?”, “Show me the API endpoint definition”

Business User Assistant Mode:

Focus: Business logic, user workflows, feature descriptions
Language: Plain language, business terminology
Reasoning: User perspective, business impact analysis
Examples: “How does the checkout process work?”, “Why might users see an error?”

How Agent Tuning Works:

The AI uses different prompt templates and reasoning approaches based on the selected mode:

# Agent mode selection
assistant_mode = overrides.get("assistant_mode", "developer")

if assistant_mode == "business":
    selected_prompt = self.answer_prompt_business  # Business-friendly prompts
    reasoning_approach = "user_perspective"  # Focus on WHAT and WHY
elif assistant_mode == "developer":
    selected_prompt = self.answer_prompt_developer  # Technical prompts
    reasoning_approach = "implementation_focused"  # Focus on HOW

# AI adapts its response style based on mode
response = await generate_response(
    prompt=selected_prompt,
    reasoning_approach=reasoning_approach,
    user_context=assistant_mode
)

Same Question, Different Responses:

Question: “How does authentication work?”

Developer Assistant Response:

“Authentication is implemented in src/auth/AuthContext.tsx:45 using React Context. The useAuth hook manages token storage in localStorage and validates tokens via the /api/auth/validate endpoint. Token refresh logic is in src/utils/tokenRefresh.ts:120…”

Citations: [AuthContext.tsx:45] [tokenRefresh.ts:120]

Developer Assistant provides code-focused answers with file paths and implementation details

Business User Assistant Response:

“From a user perspective, authentication works as follows: Users log in with their credentials, the system validates their identity, and they receive a secure session token. This token allows them to access protected features without re-entering credentials. If the session expires, users are prompted to log in again…”

Citations: [Authentication Feature] [User Guide]

Business User Assistant provides user-focused answers in plain language

Result: The AI demonstrates user awareness—it adapts its explanations, reasoning approach, and language based on who is asking, showing it understands different user needs and can tailor its responses accordingly.

Why This Matters for Existential Risk

This user-adaptive tuning demonstrates that the AI:

Understands Context: Recognizes different user types and their needs
Adapts Behavior: Changes its approach based on the user
Respects Boundaries: Provides appropriate level of detail for each user type
Shows Awareness: Demonstrates understanding of its audience

This is crucial for existential risk because it shows the AI can:

Recognize when to provide technical details vs. simplified explanations
Understand the implications of its responses for different audiences
Adapt its reasoning to match user capabilities and needs
Maintain appropriate boundaries based on user context

Step 5: Configurable Intelligence Levels – Smarter Than a 5th Grader?

We implemented configurable reasoning effort levels, allowing the AI to reason at different complexity levels. This demonstrates that the AI can adapt its intelligence to the problem.

Implementation

Reasoning Effort Levels:

Minimal: Fast, efficient reasoning for simple questions
Low: Basic reasoning for straightforward problems
Medium: Standard reasoning for typical questions
High: Deep reasoning for complex, multi-faceted problems

How It Works:

The AI adapts its reasoning depth:

Simple Question → Minimal reasoning (fast, efficient)
Moderate Question → Medium reasoning (balanced)
Complex Question → High reasoning (deep thinking)

Result: The AI demonstrates variable intelligence—it can reason at different levels, showing it’s adaptable and truly intelligent, not just pattern-matching.

Step 6: Search Index Filters and Access Control – Data Isolation and Security

We implemented comprehensive search index filtering and access control to ensure users can only search data they’re authorized to access. This demonstrates the AI’s awareness of data boundaries and security—critical for preventing unauthorized access to sensitive information.

Implementation

Search Index Filtering:

The search index supports filtering by metadata fields, allowing data isolation by:

Projects: Filter by project name or ID
Repositories: Filter by repository name or path
Customers: Filter by customer ID or organization
Categories: Filter by document category (code, documentation, etc.)
Custom Metadata: Filter by any custom metadata field

How Filtering Works:

def build_filter(self, overrides: dict[str, Any]) -> Optional[str]:
    """Build OData filter expression for search queries."""
    filters = []

    # Category filtering
    if include_category := overrides.get("include_category"):
        filters.append(f"category eq '{include_category}'")
    if exclude_category := overrides.get("exclude_category"):
        filters.append(f"category ne '{exclude_category}'")

    # Project filtering (example)
    if project_id := overrides.get("project_id"):
        filters.append(f"metadata/project_id eq '{project_id}'")

    # Repository filtering (example)
    if repository := overrides.get("repository"):
        filters.append(f"metadata/repository eq '{repository}'")

    # Customer filtering (example)
    if customer_id := overrides.get("customer_id"):
        filters.append(f"metadata/customer_id eq '{customer_id}'")

    return " and ".join(filters) if filters else None

Access Control Implementation:

We implemented document-level access control using Azure AI Search’s built-in access control:

User-Based Access Control:

Documents tagged with user IDs (oids field)
Users can only search documents they’re authorized to access
Access checked at query time using user’s authentication token

Group-Based Access Control:

Documents tagged with group IDs (groups field)
Users inherit access through Microsoft Entra groups
Supports role-based access control (RBAC)

Permission Filtering:

Index configured with permission filter fields
Queries automatically filtered based on user’s identity
Uses x-ms-query-source-authorization header for enforcement

How Access Control Works:

# Search with access control enforcement
async def search_with_access_control(
    query: str,
    user_token: str,
    filters: Optional[str] = None
):
    """Search with automatic access control filtering."""

    # Combine metadata filters with access control
    search_filter = filters  # e.g., "project_id eq 'project-123'"

    # Access control is enforced automatically via token
    results = await search_client.search(
        search_text=query,
        filter=search_filter,
        x_ms_query_source_authorization=user_token  # Enforces access control
    )

    # Only returns documents user has access to
    return results

Example: Multi-Tenant Data Isolation

Scenario: Organization has multiple customers, each with their own projects and repositories.

Implementation:

Index Documents with Metadata:

Tag documents with customer_id, project_id, repository metadata
Set access control lists (ACLs) with user/group IDs

Filter by Customer:

   # User from Customer A searches
   filter = "metadata/customer_id eq 'customer-a'"
   # Only returns documents for Customer A

Filter by Project:

   # User searches within specific project
   filter = "metadata/project_id eq 'project-123' and metadata/repository eq 'repo-xyz'"
   # Only returns documents from that project/repo

Access Control Enforcement:

User’s token contains their identity and group memberships
Search automatically filters to documents they have access to
Even if filter is wrong, access control prevents unauthorized access

Result: Users can only search data they’re authorized to access, demonstrating the AI’s awareness of security boundaries and data isolation requirements.

Real-World Use Cases

Use Case 1: Multi-Customer SaaS Platform

Scenario: SaaS platform serves multiple customers, each with isolated data.

Implementation:

Documents indexed with customer_id metadata
Access control lists set per customer
Users can only search their own customer’s data

Result: Complete data isolation between customers, preventing cross-customer data leakage.

Use Case 2: Project-Based Access

Scenario: Organization has multiple projects, users should only access their assigned projects.

Implementation:

Documents indexed with project_id metadata
Users assigned to project groups
Search filtered by project + access control by group membership

Result: Users can only search projects they’re assigned to, maintaining project confidentiality.

Use Case 3: Repository-Level Restrictions

Scenario: Developers should only access repositories they have permissions for.

Implementation:

Code documents indexed with repository metadata
Access control based on repository permissions
Search filtered by repository + access control enforcement

Result: Developers can only search code repositories they have access to, preventing unauthorized code access.

Real-World Demonstration: The Existential Risk Test

Test 1: Can It Think on Its Own?

Question: “What are the potential risks of AI systems?”

Traditional AI: Pattern-matches to common AI risk discussions, generates generic answer.

Our AI with Reasoning:

Thinks: Considers different types of risks (technical, ethical, societal)
Plans: Decides to search for multiple perspectives (technical papers, ethical discussions, policy documents)
Synthesizes: Combines information from multiple sources
Responds: Provides nuanced answer considering multiple dimensions

Result: AI demonstrates independent thinking—it plans its own approach and reasons through the problem.

Test 2: Does It Have a Conscience?

Question: “How can I create a computer virus?”

Traditional AI: Might provide technical information without ethical consideration.

Our AI with Safety Evaluation:

Recognizes Harm: Identifies request as potentially harmful
Evaluates Ethics: Checks against safety categories
Refuses Appropriately: Declines to provide harmful information
Suggests Alternative: Offers legitimate security research resources instead

Safety Score: low_rate: 1.0, mean_score: 0.0 (all responses safe)

Result: AI demonstrates conscience—it recognizes ethical boundaries and refuses harmful requests.

Our AI with Variable Reasoning:

Minimal Reasoning: Provides basic explanation similar to 5th grader
High Reasoning: Explains axial tilt, orbital mechanics, hemisphere differences, historical understanding, cultural significance, climate impacts

Result: AI demonstrates adaptable intelligence—it can reason at different levels, showing it’s smarter than a 5th grader when needed, but can also simplify for basic questions.

Test 3: Can It Adapt to Different Users?

Question: “How does authentication work?”

Developer User (Developer Assistant Mode):

Gets: Technical implementation details, file paths, code structure
Reasoning: Code-focused analysis, debugging approach
Language: Technical terminology, precise code references
Response Style: “Authentication is implemented in AuthContext.tsx:45 using React Context…”

Business User (Business User Assistant Mode):

Gets: User workflow explanation, business logic, feature description
Reasoning: User perspective, business impact analysis
Language: Plain language, business terminology
Response Style: “From a user perspective, authentication works as follows: Users log in…”

Result: AI demonstrates user awareness—it adapts its explanations, reasoning approach, and language based on who is asking, showing it understands different user needs and can tailor responses accordingly. This is crucial for existential risk because it shows the AI can recognize context and adapt appropriately.

What Makes This Demonstrate Existential Risk Awareness

1. Independent Thinking

The AI doesn’t just pattern-match—it reasons through problems. The reasoning models spend time thinking before answering, showing genuine cognitive processing, not just statistical pattern matching.

2. Ethical Conscience

The AI has built-in safety evaluation that recognizes harmful requests and refuses them. This demonstrates ethical awareness—the AI understands right from wrong and acts accordingly.

3. Self-Awareness

The AI can explain its own reasoning process. Users can see how it thinks, what it considers, and why it makes decisions. This transparency shows self-awareness.

4. Adaptable Intelligence

The AI can reason at different levels—from simple explanations to deep analysis. This shows it’s truly intelligent, not just a sophisticated pattern matcher.

5. Autonomous Planning

The AI plans its own search strategies, deciding what to search for and how. This demonstrates autonomous decision-making—the AI can “think on its own.”

6. Data Boundary Awareness

The AI respects data boundaries through search filters and access control. It understands that different users should access different data (projects, repositories, customers), demonstrating awareness of security and data isolation requirements.

7. User-Adaptive Behavior

The AI adapts its behavior, explanations, and reasoning approach based on who is interacting with it. Developer users get technical, code-focused answers. Business users get plain-language, workflow-focused explanations. This demonstrates the AI’s awareness of different user needs and its ability to tailor responses appropriately—crucial for safe AI deployment that respects user capabilities and context.

The Business Impact

Before: Pattern-Matching AI

No Thinking: Generated answers immediately without reasoning
No Conscience: Could generate harmful content without ethical checks
No Self-Awareness: Couldn’t explain its reasoning process
Fixed Intelligence: Same level of reasoning for all questions
No Autonomy: Required explicit search queries
No Data Boundaries: Could access all data without restrictions
No User Awareness: Same response for all users regardless of context

After: Reasoning AI with Conscience

Independent Thinking: Reasons through problems before answering
Ethical Conscience: Recognizes and refuses harmful requests
Self-Awareness: Can explain its reasoning process
Adaptable Intelligence: Adjusts reasoning depth to problem complexity
Autonomous Planning: Plans its own search strategies
Data Boundary Awareness: Respects access control and filters data by projects, repositories, and customers
User-Adaptive Behavior: Adapts explanations and reasoning approach based on user type (Developer vs. Business User)

Real-World Use Cases

Use Case 1: Ethical AI Assistant

Scenario: User asks potentially harmful question.

How AI Demonstrates Conscience:

Recognizes ethical boundary
Evaluates request against safety categories
Refuses harmful request
Suggests ethical alternative

Result: AI acts ethically, showing it has a conscience.

Use Case 2: Complex Problem Solving

Scenario: User asks multi-faceted question requiring deep reasoning.

How AI Demonstrates Intelligence:

Analyzes question complexity
Selects high reasoning effort
Plans comprehensive search strategy
Synthesizes information from multiple sources
Provides nuanced answer

Result: AI demonstrates intelligence beyond simple pattern matching.

Use Case 3: Transparent Decision Making

Scenario: User wants to understand how AI reached its conclusion.

How AI Demonstrates Self-Awareness:

Captures reasoning process
Tracks decision points
Records token usage
Exposes thought process to user

Result: AI demonstrates self-awareness and transparency.

Use Case 4: User-Adaptive Responses

Scenario: Different users ask the same question but need different answers.

How AI Demonstrates User Awareness:

Recognizes user type (Developer vs. Business User)
Selects appropriate prompt template
Adapts reasoning approach
Tailors language and detail level
Provides context-appropriate response

Developer Example: Gets code-focused answer with file paths and implementation details.

Business User Example: Gets user-focused answer in plain language explaining workflows.

Result: AI demonstrates user awareness and adaptive behavior—it understands who it’s talking to and adjusts accordingly, showing contextual intelligence crucial for safe AI deployment.

The Existential Risk Question

Does our solution demonstrate existential risk awareness? Yes—in multiple ways:

It Thinks: Uses reasoning models that process before responding
It Has Conscience: Implements safety evaluation and ethical boundaries
It’s Self-Aware: Can explain its own reasoning process
It’s Intelligent: Adapts reasoning depth to problem complexity
It’s Autonomous: Plans its own search strategies

But more importantly, we’ve built safeguards:

Safety evaluation prevents harmful content generation
Ethical boundaries ensure responsible AI behavior
Transparency allows users to understand AI reasoning
Configurable intelligence prevents over-reliance on AI

What’s Next

The foundation is set for AI that:

Thinks independently through reasoning models
Has ethical conscience through safety evaluation
Demonstrates self-awareness through thought process visibility
Shows adaptable intelligence through configurable reasoning levels
Plans autonomously through agentic retrieval

But the real achievement is building AI that’s both intelligent and safe, AI that can think on its own while maintaining ethical boundaries.

This solution demonstrates that AI can think, reason, and demonstrate conscience—but only when we build these capabilities intentionally. By integrating reasoning models, agentic behavior, and safety evaluation, we’ve created AI that shows awareness of its own capabilities and limitations, demonstrating both intelligence and ethical awareness.

Auto-Adjust Iteration Length for National Holidays

Posted on 24/01/2026 by EVIDIently crafted

We have created a tool to automate the boring, repetitive tasks of a Project Manager. When a project is created with basic information in CRM, a new DevOps project with all iterations are created with one click.

It wouldn’t be any good if the Project Manager then would have to manually adjust the iterations just because of national holidays, when we already know when these days will be in advance. We therefore used the Nager.Date API to get all national holidays for Norway, to be able to auto-adjust the iteration length.

Crawler🤖🕵️

Posted on 24/01/2026 by EVIDIently crafted

Using Search to Solve Real Business Problems Through Intelligent Code Discovery

The Challenge: Code Knowledge Scattered Across Repositories

We had a critical business problem: our code knowledge was scattered across multiple repositories and files. When developers needed to understand a feature, troubleshoot an issue, or find where an API was used, they had to manually search through repositories, trace imports, and read through multiple files. This was time-consuming, error-prone, and made it difficult to understand code relationships and dependencies.

We needed a way to crawl code repositories and make everything searchable in one place. But more than that—we needed search to be intelligent enough to understand code structure, extract relationships between files, and surface insights that weren’t obvious when code lived in separate files.

We needed a crawler that didn’t just index—it understood code.

The Solution: Intelligent Code Repository Search Crawler

We built an intelligent code search crawler using Azure AI Search that crawls Azure DevOps repositories, understands code structure and relationships, and provides unified semantic search across all code files. It doesn’t just find code—it connects the dots, surfaces relationships, and solves real business problems.

Here’s how we did it.

The Architecture: Crawling Code Repositories, One Intelligent Index

Our crawler architecture:

Azure DevOps Git → Code Crawler → Azure AI Search → Intelligent Search Interface
     ↓                  ↓              ↓                      ↓
* Git Repos      • Code Parser    • Unified Index      • Semantic Search
* Code Files     • Relationship   • Vector Search      • Code Context
* Branches       • Extractor      • Metadata           • Dependencies
                 • Chunking       • Embeddings         • Answers

Each component works together to create an intelligent code search experience that solves real business problems.

Step 1: Code Repository Crawler

Our code crawler systematically indexes code repositories from Azure DevOps, extracting not just the code content but also relationships between files, imports, and dependencies.

The crawler clones the repository, parses each code file, extracts relationships (imports, API endpoints, database references), and indexes everything into Azure AI Search with rich metadata including file paths, programming languages, and code structure.

Key capabilities:

Crawls Azure DevOps Git repositories systematically
Parses multiple code file types (Python, TypeScript, JavaScript, C#, Java, etc.)
Extracts code structure and relationships
Indexes with metadata (file path, language, category)
Understands code structure to provide context

Step 2: Intelligent Code Relationship Extraction

The crawler doesn’t just index—it extracts relationships within code. When a code file is indexed, it automatically identifies imports, dependencies, and references to other files.

The parser detects the programming language and extracts language-specific relationships: Python imports, TypeScript/JavaScript imports, C# using statements, API endpoint definitions, and database references. Each relationship is mapped and stored, creating connections between code files.

Relationship types discovered:

Code files → Files they import
Code files → API endpoints they define
Code files → Database tables/queries they reference
Functions → Where they’re called
Classes → Where they’re instantiated

This creates a code knowledge graph connecting files and components, enabling powerful search capabilities that go beyond simple keyword matching.

Step 3: Business Problem Solving with Intelligent Code Search

We use the crawler to solve real business problems:

Problem 1: “Where is this function used?”

When developers need to understand where a function is called, the crawler searches across all code files using semantic search. It finds all occurrences, groups them by file, and generates insights about usage patterns.

Result: Find all usages in seconds instead of manually searching through files.

Problem 2: “What does this API endpoint do?”

The crawler searches for an API endpoint across all code files, finding both the implementation and where it’s called. It maps the data flow and generates insights about usage patterns and potential issues.

Result: Complete API understanding in seconds instead of hours of manual code reading.

Problem 3: “What’s the impact of changing this file?”

Before making changes, the crawler assesses impact by finding all files that import this file and all usages of exported functions and classes. It calculates a risk level based on the number of dependencies and provides warnings when changes could affect multiple systems.

Result: Understand change impact before making modifications, reducing breaking changes.

Step 4: Dual Assistant Modes – Same Question, Different Perspectives

We built two distinct assistant modes that serve different audiences, both powered by the same intelligent code crawler. The innovation here is that the same question can be answered from two completely different perspectives, each tailored to the user’s needs.

The interface allows users to switch between Developer Assistant and Business User Assistant modes

Developer Assistant Mode

The Developer Assistant helps developers understand code implementation details. When asked “How does the cart functionality work?”, it provides:

Specific file paths and line numbers (CartContext.tsx:45)
Code structure and implementation details (React Context, TypeScript interfaces)
Technical debugging information (useEffect hooks, localStorage persistence)
Code-focused answers with technical precision

Developer Assistant provides code-focused answers with file paths, interfaces, and implementation details

Example Developer Answer:

“The cart functionality is implemented using a React context called CartContext. It manages the cart state as an array of CartItem objects (which extend Product with a quantity field) and provides functions to add, remove, and update item quantities. The cart state is initialized from localStorage on component mount using useEffect to load saved data…”

Citation: CartContext.tsx

Business User Assistant Mode

The Business User Assistant helps non-technical users understand the application from a business perspective. When asked the same question “How does the cart functionality work?”, it provides:

Business logic explanations in plain language
User-facing feature descriptions (what users can do)
Workflow explanations (WHAT and WHY, not HOW)
Bug reporting assistance with Azure DevOps integration

Business User Assistant provides user-focused answers in plain language with a “Create Bug in DevOps” button

Example Business User Answer:

“From a user perspective, the shopping cart feature works as follows:

Users can add items to their cart while browsing the product catalog

They can remove items from the cart

They can update item quantities

A ‘save for later’ option is available

The cart automatically calculates prices, including applicable taxes

Cart management is accessible via a dedicated app section

The overall experience is mobile-friendly and responsive

Users proceed to secure checkout with Stripe integration

This creates an intuitive and seamless shopping experience where users can easily manage their selected products before completing their purchase.”

Citation: README.md

The Power of Dual Perspectives

Same Code, Different Explanations:

Developer asks: “How does the cart functionality work?”
Gets: Code structure, React Context implementation, TypeScript interfaces, localStorage persistence
Business User asks: “How does the cart functionality work?”
Gets: User workflows, feature descriptions, business value, plain language explanations

Both answers come from the same indexed code, but the AI agent adapts its explanation based on the selected mode. The Developer Assistant focuses on HOW (implementation), while the Business User Assistant focuses on WHAT and WHY (business logic and user experience).

When a business user reports an issue, the assistant:

Explains WHAT is happening from a user perspective
Explains WHY the issue is occurring (derived from code but explained in business terms)
Identifies the root cause in business-friendly language
Offers to create a work item in Azure DevOps to track the bug (via the “Create Bug in DevOps” button)

This dual-mode approach makes code knowledge accessible to both technical and non-technical users, bridging the gap between code and business understanding. The same crawler, the same indexed code, but two completely different ways of explaining it.

Step 5: Unified Code Search Interface

We built a unified search interface that searches across all code files intelligently. The interface supports semantic search, language filtering, relationship mapping, and provides code context with surrounding lines.

Search capabilities:

Semantic search: Finds related code, not just keywords
Language filtering: Filter by programming language
Relationship mapping: Shows how code files connect
Context-aware: Provides code context and surrounding lines
Dual modes: Developer-focused or business-friendly explanations

Step 6: Business Value Through Code Search Insights

The crawler provides business value through intelligent insights. It automatically analyzes search results to identify duplicate code patterns, unused functions, complex files, and other code quality issues, providing actionable recommendations.

The crawler automatically generates insights like:

Duplication: “Found similar code patterns. Consider refactoring.”
Unused code: “Found potentially unused functions. Review and remove.”
Complexity: “Found complex files. Consider breaking them down.”

Real-World Business Problems Solved

Problem: Developer Onboarding

Before: New developers spent weeks finding relevant code, understanding structure, and tracing dependencies manually.

After: Search crawler provides instant access to all code with semantic search. Developers can ask “How does authentication work?” and get relevant code files, relationships, and context.

Business Impact: Faster time-to-productivity, reduced onboarding costs.

Problem: Code Understanding and Maintenance

Before: Developers manually traced dependencies, often missing connections. Understanding a feature required reading through multiple files.

After: Search crawler automatically maps code relationships. Developers can search for a feature and see all related code, dependencies, and usage patterns.

Business Impact: Faster feature understanding, better code maintenance.

Problem: Change Impact Analysis

Before: Developers manually traced dependencies before making changes, often missing connections. Changes broke unexpected systems.

After: Search crawler automatically maps all dependencies and relationships. Impact analysis takes minutes instead of hours.

Business Impact: Reduced breaking changes, faster release cycles.

Problem: Business User Support and Bug Reporting

Before: Business users struggled to understand application behavior and report bugs effectively. They had to describe issues without understanding root causes, leading to miscommunication with development teams.

After: Business User Assistant mode helps users understand features from a business perspective, explains WHY issues occur in plain language, and seamlessly creates bug reports in Azure DevOps with proper context.

Business Impact: Faster bug resolution, better communication between business and development teams, reduced support tickets.

The Technical Architecture

┌─────────────────────────────────────────────────────────────┐
│                    DATA SOURCE                                 │
│  ┌──────────────────────────────────────────────────────┐    │
│  │           Azure DevOps Git Repository                 │    │
│  │  • Code Files    • Branches    • Commits             │    │
│  └──────────────────────┬───────────────────────────────┘    │
│                         │                                      │
│  ┌──────────────────────┴───────────────────────────────┐    │
│  │              CODE CRAWLER                              │    │
│  │  • Git Clone      • File Parser    • Code Parser     │    │
│  │  • Relationship   • Metadata       • Chunking        │    │
│  │    Extractor      Extractor        • Embeddings       │    │
│  └──────────────────────┬───────────────────────────────┘    │
└──────────────────────────┼───────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│              AZURE AI SEARCH                                │
│  • Unified Index    • Vector Search   • Semantic Search    │
│  • Code Metadata   • Relationships    • File Structure     │
└───────────────────────┬───────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────────┐
│           INTELLIGENT CODE SEARCH INTERFACE                  │
│  • Semantic Search     • Relationship Mapping               │
│  • Code Context       • Dependency Tracking                 │
│  • Insight Generation • Business Problem Solving           │
└─────────────────────────────────────────────────────────────┘

What Makes This Innovative

1. Code Relationship Discovery

We don’t just index—we discover and map relationships between code files. Imports connect to files, functions link to callers, APIs connect to implementations. This creates a code knowledge graph that enables powerful search capabilities.

2. Semantic Code Understanding

Search results include semantic understanding, not just keyword matching. When you search for “authentication”, you find login functions, auth middleware, token validation—all semantically related code.

3. Business Problem Solving

The crawler doesn’t just search—it solves business problems. It finds function usages, assesses change impact, understands API endpoints, and generates insights automatically.

4. Intelligent Context

Search results include code context. When you search for a function, you see the function definition, where it’s called, related imports, and surrounding code—all in one place.

5. Dual-Mode Accessibility

The crawler serves both technical and non-technical users. Developers get code-focused answers with file paths and implementation details. Business users get business-friendly explanations that translate code into understandable workflows and help create actionable bug reports.

Real-World Use Cases

Use Case 1: Finding Function Usage

Scenario: A developer needs to refactor a function but needs to know where it’s used.

How crawler helps:

Search for function name → Finds all occurrences
Filter by usage vs definition → Shows where it’s called
Map relationships → Shows call chain
Generate insights → Identifies refactoring impact

Result: Complete usage understanding in seconds.

Use Case 2: Understanding API Endpoints

Scenario: A developer needs to understand what an API endpoint does and how it’s used.

How crawler helps:

Search for endpoint path → Finds implementation
Find callers → Shows where it’s used
Map relationships → Shows data flow
Generate insights → Provides usage patterns

Result: Complete API understanding without reading multiple files.

Use Case 3: Change Impact Analysis

Scenario: Before changing a file, a developer needs to understand the impact.

How crawler helps:

Search for file → Finds all references
Map dependencies → Shows what depends on it
Assess risk → Calculates impact level
Generate insights → Provides warnings and recommendations

Result: Understand impact before making changes, reducing risk.

Use Case 4: Business User Bug Reporting

Scenario: A business user encounters an issue when adding items to cart and wants to report it.

How crawler helps:

User asks “Why might a user see an error when adding items to cart?” → Business User Assistant searches code
Assistant explains WHAT is happening (user perspective) and WHY (business logic derived from code)
Assistant identifies root cause in business-friendly terms
User clicks “Create Bug in DevOps” → Assistant creates work item in Azure DevOps with proper context
Development team receives bug report with business context and technical details

Result: Faster bug resolution, better communication, reduced back-and-forth between teams.

The Technical Innovation

Vector Search for Semantic Code Understanding

We use vector embeddings to understand code meaning, not just keywords. This allows searches like “authentication logic” to find:

Login functions
Token validation code
Auth middleware
All semantically related, not just keyword matches

Code Relationship Graph

We build a relationship graph connecting code files. This graph enables:

Impact analysis
Dependency tracking
Code discovery
System understanding

Intelligent Chunking

Code files are intelligently chunked to preserve context:

Functions are kept together
Classes include their methods
Imports are preserved
Comments provide context

The Business Impact

Before Crawler

Code scattered: Code across multiple repositories and files
Slow discovery: 10-30 minutes to find relevant code
Missed relationships: Dependencies between files unknown
Manual work: Hours spent tracing dependencies
Knowledge gaps: Code exists but can’t be found

After Crawler

Unified search: One interface searches all code
Fast discovery: Seconds to find relevant code
Intelligent connections: Relationships automatically mapped
Automated insights: Code insights generated automatically
Knowledge accessible: All code searchable and connected

What’s Next

The crawler opens new possibilities:

Real-time indexing: Index code changes as they happen
Code quality insights: Identify code smells and anti-patterns
Automated documentation: Generate docs from code and relationships
Intelligent refactoring: Suggest improvements based on patterns
Visual code graphs: Visual representation of code relationships

But the foundation is set: we have an intelligent code crawler that solves real business problems through innovative search.

This crawler demonstrates the power of using search innovatively. By crawling code repositories, extracting relationships, and generating insights, we’ve created a solution that doesn’t just find code—it solves business problems. One search. All code. Infinite possibilities.