Deep Context: Workspace Tools
- Deep Context means your agent understands your code, infrastructure, and operational history — not just generic Azure knowledge
- It builds this understanding through three pillars: code analysis, persistent memory, and background intelligence
- Connected source code repos (GitHub, Azure DevOps) give the agent direct access to read, search, and navigate your codebase
- Your agent gets smarter with every conversation — it remembers what worked, what failed, and what your systems look like
Deep Context is the agent's accumulated understanding of your environment — your code, your infrastructure, your team's procedures, and what happened in past investigations. Unlike a generic AI assistant that starts from zero every time, your agent builds a growing picture of how your systems work. Deep Context is not a single feature you enable — it's the combination of three pillars that work together automatically.
| Pillar | What it does | How it builds |
|---|---|---|
| Context analysis | Reads code, searches knowledge, and navigates your environment in real time | Connected repos + knowledge base + user preferences |
| Persistent memory | Remembers past investigations, team context, and operational patterns | Conversation learning + knowledge files |
| Background intelligence | Continuously learns from your environment — even when nobody is chatting | Codebase analysis + insight generation + data source enrichment |
Why Deep Context matters
Your team's expertise lives in a dozen different places — source code in GitHub, logs in Azure Monitor, configs in YAML files, runbooks in a wiki nobody updates, and tribal knowledge in the heads of your senior engineers. When an incident hits, the hardest part isn't reasoning about the problem — it's gathering enough context to start reasoning in the first place.
Engineers spend most of their investigation time hunting for information: which service changed recently? Where's the retry logic? What did we do last time this happened? The answers exist, but they're spread across tools that don't talk to each other. Every investigation starts from scratch.
Deep Context solves this by giving your agent continuous access to all of these sources — and the ability to remember what it learns from each interaction.
Pillar 1: Context analysis
Your agent has continuous, direct access to your connected repositories, knowledge base, and user preferences. It doesn't wait for you to ask a question before reading your code — it explores your repositories, learns your project structure, and builds understanding proactively. When an incident hits, the agent already knows where your retry logic lives, how your services connect, and what changed recently.
Your agent reads, searches, and navigates your codebase using built-in tools like Azure CLI, Python execution, file search, and terminal commands. It chains these tools together automatically to accomplish complex tasks. For example, when you ask "Find where authentication errors are handled in our API," the agent searches for patterns across your codebase, reads the matching files, traces the error handling flow, and presents a structured analysis.
You can add more context to your agent at any time:
- Connect repositories — Link GitHub or Azure DevOps repos so your agent can read your source code. See Connectors.
- Upload knowledge documents — Add runbooks, architecture guides, and team procedures. See Memory & Knowledge.
- Tell your agent to remember — Type
#rememberin chat to save facts your agent should know (e.g., "our Redis cache uses Premium tier with 6GB"). See Memory & Knowledge. - Create skills — Package troubleshooting procedures with tools. See Skills.
For the full list of available tools, see Tools.
Security
All workspace operations run in a sandboxed environment. Code execution happens in isolated containers, not on the agent host. Azure CLI write commands require explicit user approval before execution.
Pillar 2: Persistent memory
Your agent remembers what it learns. After every conversation, the agent extracts structured facets — tool success rates, root causes, key learnings, and which Azure services were involved. These are stored as persistent knowledge and used to improve future investigations.
Your team can also upload knowledge documents — architecture guides, runbooks, team context — that the agent references automatically. When a similar issue comes up again, the agent recalls what worked and what didn't, without anyone needing to re-explain context.
Learn more → Memory and Knowledge
Pillar 3: Background intelligence
Your agent continuously builds operational understanding — even when nobody is chatting — through three background systems:
Codebase analysis
When you connect a code repository, the agent automatically analyzes it — project structure, technology stack, deployment configs, and service dependencies. It creates an SREAGENT.md file as a PR to your repo. Once merged, the agent uses it to map Azure resources back to the code that owns them.
Insight generation
A background service periodically aggregates data from multiple sources — past conversations, incidents, workspace context — and uses semantic matching to generate, reconcile, and evolve operational insights over time. For example, the agent might surface that a particular service consistently fails after Tuesday deployments, or that a specific error pattern correlates with a recent configuration change.
Kusto schema enrichment
When you connect an Azure Data Explorer (Kusto) cluster, the agent automatically discovers your databases and tables, documents each table's schema, generates human-readable descriptions, and builds KQL query templates — so it writes accurate queries without manual configuration.
The result: your agent gets smarter with every conversation, not just every software update.
How it connects to other concepts
| Capability | What it adds |
|---|---|
| Deep Investigation → | Structured hypothesis testing powered by workspace tool access |
| Python Code Execution → | Data analysis and visualization using the code interpreter |
| Incident Response → | Automated incident analysis with source code correlation |
| Connectors → | Connect GitHub, Azure DevOps, and other data sources |
| Scheduled Tasks → | Automate recurring workspace operations |
Next steps
- Connect a GitHub repository — Give your agent access to source code
- Connectors — All connector types and how they work
- Agent Reasoning — How the agent thinks through problems