NAV Insight gives you a clear, business-level picture of everything your NAV does — explore how any feature works down to the exact source line, ask questions in plain language and trust the answers, and get documentation that follows the business process, not the code. Weeks of reverse-engineering, done in days.
Move to Business Central without losing sight of what your system does. Every generated AL line traces back to its NAV source, so you verify the port instead of trusting a black box. Your own AI agent drives it, and your code never leaves your perimeter.
How it works
Nothing else to prepare: upload your NAV object export — the platform does the rest.
Export your objects with standard NAV tools and upload the file. Indexing starts immediately and runs in the background.
See the indexed code →Each modification is decomposed into concrete functional features with descriptions — by area, sub-area, and purpose. Understand the system in business language, not objects and lines of code.
See the breakdown →Per feature: the required setup, user actions, and result — in a single format, ready to export. Living documentation that's always current: built from the actual implementation, not from prose typed by hand.
See living docs →Answers questions about the system in business language — and when a detailed audit is needed, drills down to the object, procedure, and exact source line.
Meet the agent →Business-context breakdown
The platform decomposes every code modification into the concrete business features it actually implements — each with a plain-language name and description derived from the code itself. Expand a modification to see what's inside.
Code |
Name |
Features |
Objects |
|---|
Straight from the Modifications view — click a row to reveal the features inside it.
NAV Insight
For every feature, the agent holds the full business context: how it's triggered, which fields are mandatory and how to fill them, and what the outcome looks like — the ledger entries it posts, the files it exports, the integrations it calls. Not generic guesses — facts extracted straight from your code.
Living documentation
Not prose someone typed once and forgot. Every per-feature report is rebuilt from the actual code on each run — so the documentation can’t drift from the system. Browse the whole catalog, open any report from prerequisites to result, and export it wherever you work — Word, Markdown, or your wiki.
All of this — per feature, with export to Word (.docx), versioning, and search.
NAV X-Ray
Find any object, walk the call tree, expand the table-relations graph and trace a single field’s value flow — then scope it all to a specific customization. Everything you know from a NAV/C/AL static analyzer, but interactive: scoped to customizations and bridged to the AI agent — at a friendlier price.
Openness and portability
Documentation, inventory, and analysis results are delivered in open formats and flow into your own tools — we keep nothing locked away. Take it as Word for the client, or as Markdown to index in your own RAG.
Client-ready per-feature documents — versioned and citable.
We hand you .md — index it in your own RAG / knowledge base.
JSON/CSV: objects, fields, dependencies, gap view — into your pipelines.
Export documentation to your wiki (e.g., in development).
(Migration) Standard artifacts — straight into your Git repository and CI.
The same context is available to your AI agents over the network — not just to people.
Context Layer for AI agents
Your own agents — a support bot, an internal copilot, analytics automations — reach the knowledge about your NAV system over the network: they send a functional question and get a grounded answer with a citation to the object, procedure, and line (or the precise documentation section). The same understanding of the system that people see in the dashboard is available to machines too. The key is scoped to your project, answers are traceable, usage is metered, and your code stays inside your perimeter.
Send a question — get a grounded, cited answer. REST /api/v1/migration/ask (+ SSE) and the MCP tool ask_migration_expert.
The agent runs its own reasoning loop over our MCP primitives nav_*: call graph, fields, entry points, semantic search over features and documentation.
How migration works
NAV Insight already understands your system feature by feature. Migration turns that understanding into a plan, the data, and the tests — driven by your own AI agent, grounded in the real code.
Point your AI agent (Claude Code, Copilot, your own automation) at the migration MCP. It gets business-level, code-grounded context for your NAV instead of guessing.
The context layer →The project is split into waves from the real dependency graph, so teams work in parallel inside a wave — and each feature is testable together with everything it depends on.
See the plan →A per-feature NAV → BC field mapping, deterministic transfer SQL for import into Azure/BC, and a cleansing pass before anything moves.
See the data mapping →Process-oriented documentation drives automatic unit-test generation; your agent runs them through CI/CD — deploy, execute, self-heal — so acceptance happens per feature.
See test automation →Step 1 The context layer · MCP
The migration MCP server is a thin, deterministic wrapper over the fact store extracted from your code. Your agent asks structured questions and gets answers grounded in the actual C/AL — with a citation to object, procedure, and line. Nothing is invented.
The user-initiated Page/Report actions through which a feature is actually launched. Field triggers are child processes and are excluded — so the agent starts where the business process starts.
The deterministic behavioural slice: per entry point, every effect with when (the path condition), what (the value + its provenance), and how (the operation trace). Plus process, call-tree and scenario views.
Every result-bearing effect of an entry point, broken down by surface (DB · Document · Integration · UI) × contribution (adds · gates · standard), with its preconditions. Exactly what the feature produces and under what conditions.
Every field a feature's call tree reads or writes — not just marked ones — with its owning modification and table category. Plus the fields a feature adds, and end-to-end value lineage for a single field across the whole base.
An inventory of everything leaving the modification (standard BC · other mod · .NET · ISV), cross-mod dependency facts on both code and field channels, and where to hook the behaviour in BC as events.
Send a functional question and get a cited answer — the navigation agent runs its own reasoning loop over the same fact store and grounds every claim in the code.
Step 2 Planning
The real payoff is parallelism. The platform decomposes the whole migration into independent, shippable blocks, so several teams can build and test at the same time instead of queuing behind one long sequence — cutting idle time and calendar length. Each block carries its own dependencies, so its functionality can be tested on its own the moment it's ready: problems surface early, not in an end-of-project big-bang. The blocks and their order come from the real dependency graph (circular clusters included) — that's what makes them genuinely independent.
Step 3 Data migration
A per-feature NAV → BC field mapping shows what matches 1:1, what BC lacks (a gap), and what's custom — grouped by module. On top of it, the platform deterministically generates the transfer SQL for import into Azure/BC, and surfaces the conflicts to resolve before you move a single row. Your SQL stays yours — preview it, and run it on your side.
Step 4 Code migration
Built-in converters do the routine, mechanical port of each object type; the AI agent takes over only where deterministic conversion can’t — adapting the feature to standard BC and driving it to a clean compile.
Table, Table Extension, Page, Report, Enum, XMLport and more are converted deterministically per object type — the routine ~90% of the port at no token cost.
A single registry of all objects with assigned BC IDs and canonical names — no invented names, no ID collisions across the extension.
A stored NAV → BC field mapping is the source of truth: the AL tables and table extensions — the data model — are generated from it.
Where deterministic conversion falls short — semantic rewrites, non-mechanical constructs — the AI agent steps in, grounded in the dependency graph and behaviour model, not guessing.
The agent sees the feature’s business context and functional scope and performs the final migration — adapting the code to standard Business Central functionality, not porting line-for-line.
The agent compiles the generated AL and resolves compilation errors in a loop — enriched with live BC metadata — until the feature builds clean.
Step 5 Test automation
Because NAV Insight documents each feature as a process, it can generate the unit tests that prove that process still holds in Business Central. Your agent then drives CI/CD end to end — so a feature is accepted when its process passes, with its dependencies, not by ad-hoc manual clicking.
From the process-oriented specification and the standard AL test library, unit tests are emitted per feature — the regression baseline is derived from the analysis, not written by hand.
The agent has access to the BC CI/CD automation and can auto-deploy the functionality to a test sandbox and run the autotests — Docker or cloud sandbox, integrated with Jenkins, results to JUnit / Allure / TestOps.
A compile-and-fix loop enriches errors with live BC metadata and resolves them, with a fallback to human review. The goal: the agent will work test failures down on its own.
For AI agents · works with both products
The same context layer powers both NAV Insight and Migration. The key is scoped to your project, every answer is traceable to the code, and usage is metered. Your agent stays in control — the MCP grounds it, it doesn't drive by itself.
Send a question — get a grounded, cited answer. REST /api/v1/migration/ask (+ SSE) and the MCP tool ask_migration_expert.
The agent runs its own reasoning loop over our MCP primitives nav_* / alc_* — graph, fields, entry points, dependencies, AL generation.
Enterprise & security
Tenant isolation, code-only uploads, encrypted secrets and scoped keys — built into the architecture, not bolted on.
The platform runs on Microsoft Azure, hosted in a European region — your project data stays in the EU.
Partitioned by company + project, three-tier RBAC; keys scoped to your own projects.
You upload business logic (a NAV object export) — no records or PII; semantic search runs on a local model, code never goes to third parties.
People via Microsoft Entra ID; machines via sha256-hashed, scoped, revocable API keys — checked on every call.
TLS in transit; secrets and credentials in Azure Key Vault, Fernet at rest.
Azure infrastructure: ISO 27001, SOC 1/2, and GDPR.
Pricing · two products
NAV Insight — understand and document your NAV.
Flat monthly · per user
€19 / user · mo
Unlimited projects · 14 days free.
Pay-as-you-go · metered
$2.50 / 1M tokens
Answers in business language, grounded at the code level with a citation to every claim. Metered at Azure OpenAI GPT-4o rates — $2.50 / 1M input, $10 / 1M output. Pay only for what you use.
Flat monthly
€49 / mo
Connect your own AI agents (Claude Code, Copilot, automation) over MCP & API to context that's not just code-grounded but enriched with business context — the same understanding people see, over the network.
Subscription covers Report Builder & NAV X-Ray and unlimited projects; the AI agent is metered per use; the MCP server is a flat add-on. Cancel anytime.
NAV Migration — migrating to BC, you choose how to pay. Billed on one account; free assessment scopes it up front.
Flexible · self-service
€1 / migrated object
Each object includes its code conversion and access to the MCP server with business context for your AI agent. Monthly invoice across all projects — pay only for what's migrated, start/stop anytime.
Flat · per project
€499 / project · instance
A predictable, all-in price for one project (instance). MCP server included, no user limit, and no cap on the volume of migrated functionality — no per-object metering. Scope is confirmed up front by the free assessment.
MCP calls and AI tokens are included — we don't bill you for them. Pay only for your own customizations; dead code is excluded. v1 figures are illustrative.
We'll show you, on your own NAV export, what the platform finds: an inventory, living per-feature documentation, and an AI agent that cites the code. Turn on migration when you're ready.
We'll show you, on your own system, how the migration plan is built from the real dependency graph and how compilable AL is generated — on the foundation of the analysis we do first.