ODC Readiness: Automating Platform Governance with AI Agents
For 20 years, my career has been defined by one mantra:
“The best way to deal with errors is to prevent them, but the second best is to react in real-time before the user even notices.”
I first built a proactive log alert system 15 years ago at Crédito Agrícola. Later, I re-implemented it at Interprefy, where it became a strategic asset. Instead of users calling the tech team, our engineers were proactively calling users to resolve issues they hadn’t even reported yet.
But in 2026, we have a new superpower: AI Agents.
What if we didn’t just identify the error, but had an AI Architect prescribe the cure—and even audit if that error would survive a migration to OutSystems Developer Cloud (ODC)?
The Challenge: Noise vs. Intelligence
In any large-scale OutSystems factory, the `Log_Error` table is a chaotic place. Thousands of logs, redundant entries caused by parallel requests, and “noise” from dynamic data like IDs, Timestamps, and Milliseconds.
Sending raw logs to an AI Agent is technically imprudent: it’s expensive (token burn) and inefficient. To build a solution that truly scales for Enterprise, I had to move beyond the “Chatbot” and into Data Engineering
The Solution: KORE AI (Architectural Overview)
I decided to build a hybrid solution that addresses the most pressing market need today: Governing OutSystems 11 stability while strategically planning the leap to ODC.
1. The O11 Sanitizer (C# Batch Processing)
Instead of a simple fetch, I developed a custom C# Extension that processes logs in batches.
- Normalisation: Using advanced Regex, the system masks UUIDs, Dates, and Execution Times.
- Fingerprinting: By hashing the normalized message and context, we extract the “DNA” of the error.
- Result: 10,000 ruidous logs collapse into 5 unique logical problems. This is where the real ROI of AI is decided.
/// <summary>
/// (Sneak peak)
/// Normalization by removing patterns to allow log adn grouping
/// </summary>
private string NormalizeString(string input)
{
if (string.IsNullOrEmpty(input)) return "";
string result = input;
result = Regex.Replace(result, @"\d+\s*(ms|secs|seconds|ms)", "[TIME]");
result = Regex.Replace(result, @"Timer duration = \d+ secs", "Timer duration = [X] secs");
result = Regex.Replace(result, @"\[retry \d+ of \d+ scheduled\]", "[RETRY]");
string patternGuid = @"[a-fA-F0-9]{8}-([a-fA-F0-9]{4}-){3}[a-fA-F0-9]{12}";
result = Regex.Replace(result, patternGuid, "[ID]");
result = Regex.Replace(result, @"\b\d+\b", "[N]");
string patternDate = @"\d{2,4}[-/.]\d{2}[-/.]\d{2,4}|\d{2}:\d{2}:\d{2}";
result = Regex.Replace(result, patternDate, "[DATETIME]");
return result.Trim();
}
2. The Intelligence Bridge (REST + ODC Agent)
The clean, deduplicated data is sent via REST to an AI Agent running in ODC. This agent isn’t just a generalist; it’s a trained KORE Architect that analyzes the stack trace and provides a structured response:
- Root Cause: Immediate technical origin.
- Fix (O11): Concrete steps to stabilize the current environment.
- ODC Strategy: Strategic warnings (e.g., “This pattern will fail in ODC because of stateless libraries”).
Example: The agent detected a circular dependency pattern in an O11 Service Action and warned that this must be refactored into an ODC Library to maintain the stateless architecture.
3. Human-in-the-Loop Governance
The UI follows a strict State Machine:
`Created` -> `Waiting for Agent` -> `Waiting Acceptance` -> `Validated`.
AI triages the noise and prescribes the solution, but the Architect remains the final governor, validating and accepting the suggestions to ensure quality control.


Seeing it in Action
The “KORE Explorer” dashboard provides a high-level view of your factory’s health. The AI assigns a dynamic Severity (Yellow, Orange, Red) and even identifies typos in Exception messages (as seen in my demo).
You can try the live demo here: [Kore Explorer Demo]
*(Note: The ingestion job runs every 5 minutes. If you generate errors using the demo buttons, give the “Wizard” a moment to catch up.)*
Conclusion
Transitioning to ODC is not just a “lift and shift” of code—it’s an opportunity to implement proper Platform Ops. With KORE AI, I’ve proven that we can use AI Agents to turn chaotic logs into a roadmap for modernization.
The future of OutSystems is Low-Code + AI Governance.
*What are your thoughts on using AI to audit architectural debt during migrations? Let’s discuss in the comments!*