Teams can access frontier models, yet many experiments never become dependable parts of everyday work. Workflows need to change. Data and systems need to connect. Security, governance, ownership, and human judgment must be designed into the system. People need the confidence to use it and the knowledge to improve it.
CROZ has joined the OpenAI Partner Network. For CROZ, the partnership connects more than two decades of enterprise delivery, shared learning, and community building with a global ecosystem focused on AI systems and workflows that deliver measurable outcomes.
The OpenAI Partner Network addresses the work that begins after access to the model. It is also where CROZ’s work already lives.
GPT‑6 Astra makes that shift visible. OpenAI’s new flagship combines reasoning with computer use, browsing, coding, and professional document creation. It can carry out multistep workflows and stay oriented when requirements change. For organizations, the question is no longer only what a model knows, but how reliably it can work within real systems, controls, and ways of working.
Why OpenAI is building a partner network
OpenAI created the Partner Network because access to frontier models is only one part of enterprise transformation. Organizations must still identify where AI can improve work and redesign the affected workflows. They also need to connect existing technology and data, manage risk, and support adoption.
The network brings together management consultancies, systems integrators, engineering companies, data and AI specialists, adoption experts, and technology platforms. Each contributes a different part of the work. No single company can serve every organization, market, and need.
OpenAI Partner Network
“Partner programs should accelerate customer outcomes. That means helping partners … co-deploy solutions that land AI use cases in production … and build differentiated OpenAI practices.”
OpenAI says it is investing $150 million to support the partner ecosystem and aims to train and enable 300,000 certified consultants by the end of 2026. At that scale, knowledge-sharing becomes part of the network’s operating model.
For CROZ, the designation is not a finish line. It strengthens the work of connecting capable technology with the conditions that make it useful.
Where CROZ contributes
CROZ has spent more than two decades working where business and technology meet. We help organizations identify where change matters, build the systems that enable it, and establish practices that let people own the result after launch.
Our Enterprise AI practice follows the same path. It begins with the business problem and the people closest to it. From there, CROZ connects data, applications, models, and controls inside the organization’s existing environment. Governance, security, observability, cost, human approval, adoption, and operations are part of the design from the beginning.
Carbon, our Enterprise AI approach, turns that experience into a governed foundation and adaptable building blocks. Organizations can use those building blocks for application modernization, agent workflows, operations, and knowledge work.
The architecture may be cloud-based, on-premise, or hybrid. The choice follows the organization’s context rather than a predetermined technology answer.
Working with OpenAI expands what CROZ can bring into that environment. It opens another path for our teams to deepen their knowledge of OpenAI models and products, then apply that knowledge in production. The standard remains the same: the system must fit the organization, withstand real operating conditions, and produce results people can observe.
A larger network and a greater responsibility
Joining the OpenAI Partner Network gives CROZ a wider community to learn from and build with. We can carry more of that knowledge into client work, education, partnerships, and professional communities across Croatia, the DACH region, and beyond.
The value of the designation will not be measured by the badge. It will be measured by what happens next. Does an experiment become a dependable workflow? Can people trust and improve the system they use? Does knowledge gained in one project strengthen the next team and the wider community?
The frontier has moved from the model to the organization. That is where CROZ will continue the work.
]]>Getting there takes more than access to the latest tools. It requires the right knowledge, clear business objectives, a solid technical foundation, and a shared understanding of AI across the organization. To help companies build these capabilities at every level, CROZ has introduced six new one-day AI training courses organized into four learning tracks.
The program is designed to be flexible. You can choose a single course, combine several, or complete the full set of six. You can also start with one course now and expand the learning path as your needs evolve.
Each course lasts six hours and can be delivered either at your premises or at CROZ. If you choose to join us at CROZ, lunch in our canteen is included.
Whether your priority is preparing leaders to make informed decisions, strengthening technical capabilities, supporting organizational change, or helping employees use AI more confidently in their daily work, you can shape the program around the needs of your organization.
Six Courses for Four Different Teams
AI for Leaders
- Understanding AI: From Hype to Reality
- Enabling AI Value Creation
Before organizations can create value with AI, their leaders need to understand both its potential and its limitations. These courses help decision-makers recognize realistic opportunities, assess risks and organizational readiness, and approach AI governance, regulation, and investment with greater confidence.
AI for People and Culture
- Leading AI Adoption and Change
Turning an AI strategy into lasting change depends on people as much as technology. This course helps HR, L&D, and change professionals understand how AI affects roles, skills, and organizational culture, while providing practical guidance for supporting employees, addressing resistance, and encouraging adoption.
AI for Technical Teams
- AI Platform Fundamentals
- AI in Software Development
Once the direction is clear, technical teams need the right foundations to put it into practice. These courses explore key platform and architecture decisions, as well as the practical use of AI throughout the software development lifecycle, with a strong focus on quality, security, and control.
AI for Everyday Work
- Working with AI: Practical AI Skills
Ultimately, AI creates value when people know how to use it well in their daily work. This hands-on course helps employees write better prompts, delegate suitable tasks to AI, verify the results, recognize limitations, and build reliable AI-assisted workflows.
Build Your Own AI Learning Path
Explore the complete AI Edu Package and detailed course descriptions or contact us to find the right combination for your organization.
Frequently Asked Questions
How long does each AI training course last?
Each course lasts one day, or six hours.
Do we have to select the complete package?
No. You can choose one course, all six courses, or any combination that suits your organization’s needs.
Where are the courses delivered?
The courses can be delivered at your organization’s premises or at CROZ. When a course is held at our premises, lunch for participants is included.
Who are the AI training courses designed for?
The program covers four main groups: business leaders; HR, L&D, and change professionals; technical teams; and employees who use AI in their everyday work.
Are the courses only suitable for IT companies?
No. The program is suitable for organizations across different industries because it connects the business, organizational, and technical aspects of AI adoption.
Can the program be adapted to our organization?
Yes. The selection of courses and the overall learning path can be aligned with participant roles, existing knowledge, business priorities, and the specific needs of your organization.
For reasons having to do with AI-enabled innovation, we find ourselves working more and more with something in between. Something reusable enough not to start from scratch, and flexible enough not to force a generic fit. It helps us accelerate the delivery, yet allowing to be shaped around a customer’s processes, data, systems and decisions. The end result, from a client perspective, is a business outcome achieved faster, with less compromises.
That is what I mean when using the term asset in this context.
Assets bring reusable headstart, tailored to context
An asset is a proven, hardened starting point that covers the engineering nobody should have to reinvent. The repeatable parts of every AI-infused solution (model gateways, observability, approval gates, agent runtime, delivery patterns,…) arrive pre-built and battle-tested, so the engagement begins further ahead.
What gets built together is the part that must belong to the customer, and usually involves the workflow logic, business rules, integrations, data access, and human approval decisions that carry the actual competitive differentiation. The result is product-grade speed with the fit of a custom solution, shaped around how your organization actually works.I believe that the real value of an asset is not in the asset itself but in the distance it removes between the current state and the desired business outcome.
New question: how does it fit in the procurement buckets?
In the Enterprise AI and IT world, buyers often try to put assets into one of two familiar buckets: software license or services engagement. The problem is that AI-based assets fit neither of these buckets perfectly, and most buyers don’t yet have the vocabulary or evaluation criteria for the third category.
The reality is that we need a hybrid buying category for this. The one that would allow for some characteristics of a product (pre-built pieces of engineering, a runtime, potentially some recurring costs, maybe some form of maintenance…), and also accommodate for necessary custom work to make it fully fit to your organization.
Asset’s value is contextual
The same asset can create very different value in two organizations. In one context, it may save a few weeks. In another, it may reduce months of uncertainty, avoid wrong architectural decisions, or make a complex transformation possible at all. As an example, the value of Carbon.run to a bank with 40+ internal AI agents already in production completely differs from a smaller bank deploying its first AI agents. The asset is the same in both cases, the starting position of the buyer determines almost everything. Similarly, the value of Carbon.modernize is not the same when it is used to modernize a large COBOL-based legacy system for a social insurance agency, compared with migrating a handful of satellite core-banking applications written in ASP.NET.
Assets have two lifecycles
Assets age differently depending on who is looking at them.
From a customer’s perspective, an asset is almost like a tool. It exists to help achieve a specific business outcome faster, with less risk and less reinvention. Once that outcome is achieved, the asset may no longer be needed in its initial form. Unless the same type of outcome needs to be repeated in another part of the organization.
From the builder’s perspective, the lifecycle is different. An asset does not end when one customer outcome is delivered. It has to stay aligned with what is happening in the market. If we do not evolve it, it becomes stale. If we over-customize it, it stops being reusable. So the real discipline is keeping the asset alive enough to remain relevant, but flexible enough to remain an asset. I’ll let you know how that’s going in a couple of months 🙂
How to start? With the outcomes!
Theoretical considerations aside, the fact is that the concepts of AI-assisted engineering have made it possible for us to experiment faster and build great AI-based assets for various business and technology domains. I believe there is great value in using them, both for our customers and for us as vendors.
Btw., this does not make existing or future platform investments less important. Quite the opposite: good assets can and should complement the platforms customers already trust, whether that means Red Hat, IBM, AWS, Azure or similar ecosystems, and help translate those investments into business outcomes faster.
When the repeatable engineering is already handled, the conversation with a customer changes. Instead of spending the first weeks debating architecture, runtime choices, and governance plumbing, we can get to the question that actually matters faster – how much sooner will you see the business outcome? The shift from talking about how to build, to talking about what gets achieved and when, is where assets earn their place. ]]>
In today’s data-driven organizations, clarity and consistency are non-negotiable. Leaders expect reports that highlight what matters, analysts need visual standards they can rely on, and organizations want reporting processes that scale efficiently.
This is where the International Business Communication Standards (IBCS) Association played a leading role in advancing the topic, driving its evolution toward global adoption through ISO 24896 – Notation for business reporting, published on 11 June 2026. ISO provides the international framework as the owner of the standard, while IBCS Standards remain fully aligned with and contribute to the broader ISO approach to business reporting notation.
- International Business Communication Standards (IBCS)
- ISO/DIS 24896 – Notation for business reporting
IBCS is built around the well-established SUCCESS formula, a set of visual communication principles designed to make business reports clearer, more comparable, and easier to interpret.
As an IBM Partner, CROZ brings these standards directly into IBM Cognos Analytics through our new visualization extension based on ISO 24896. We also offer services to customize your IBM Cognos reports, tailoring dashboards, templates, and charts to your organization’s specific needs. This enables companies to modernize dashboards, unify reporting practices, and accelerate decision-making.
Use Case Example: Income Statement Visualization (P&L Redesign)
Problem
The finance team distributes a monthly P&L in a traditional table format. Analysts spend hours scanning rows to identify trends, anomalies, or variances. Commentary is often unclear or buried in text, making it difficult for management to grasp the real story.
Solution
Redesign the P&L using a vertical waterfall chart
Features include:
Calculation waterfall: shows how revenues, costs, and other line items cumulatively build toward net profit (e.g., Sales revenue → Operating result → Group result).
Variance visualization: additional waterfall tiers display absolute and relative deviations from plan or prior year.
Notation: solid, outline, or hatched bars clearly distinguish actuals, budgets/plans, forecasts, and prior-year values.
Message-driven titles and consistent formatting: key insights are immediately visible without deep analysis.
Benefit
Monthly review time decreases dramatically – from hours to minutes.
Management instantly sees which line items drive profit or loss.
Variances are transparent, enabling faster root-cause analysis and corrective action.
Clear, comparable visualizations improve board-level reporting and accelerate decision-making.
Waterfall & Comparison Charts
Waterfall and comparison charts reveal contributions, deviations, and trends that tables hide, while standard notation ensures semantic consistency and improves comparability across periods and projects.
5 Advanced Charts Form Our Offering That Upgrade Corporate Reporting
Standard visuals fail when reports require deep hierarchies, dynamic variance, or multi-location comparisons. Advanced chart customization bridges the gap—giving executives instant clarity and report authors full control without complex workarounds.
1. Small Multiples Chart
- Primary Usage: Compare the same KPI across dozens of categories (locations, business units, product lines) using a grid of identical mini-charts.
- Business Scenario: Track net profit trends, yearly absolute variances, or operational performance across 10 to 25+ distinct store locations or subsidiaries simultaneously.
- Executive Impact: Leaders spot outliers and macro trends across entities instantly without toggling interactive filters or flipping through multi-page decks.
2. Stacked Column Chart
- Primary Usage: Compare total values over time while breaking down how individual sub-components contribute to the whole.
- Business Scenario: Monitor overall revenue alongside product category mix, analyze operational expenditure by cost center, or evaluate channel performance across fiscal quarters.
- Executive Impact: Replaces clutter with context—decision-makers see macro trajectory and micro drivers simultaneously in a single view.
3. Multi-tier Column Chart
- Primary Usage: Visualize time-series or category data structured across multi-level vertical hierarchies.
- Business Scenario: Present financial metrics across structured timeframes (Year → Quarter → Month) or organize corporate performance across reporting levels.
- Executive Impact: Delivers structured business context without forcing leaders to decipher complex data tables or disconnected sub-reports.
4. Multi-tier Bar Chart
- Primary Usage: Navigate multi-level hierarchical data horizontally—ideal for long category titles and detailed member listings.
- Business Scenario: Audit department budgets, compare operational KPIs across global cost centers, or analyze detailed business function metrics.
- Executive Impact: Long, descriptive labels remain fully readable without horizontal scrolling or angled text, enabling faster review cycles during executive meetings.
5. Vertical Waterfall Chart
- Primary Usage: Explain step-by-step positive and negative variances that bridge a starting value to an ending result.
- Business Scenario: Present actual vs. budget vs. plan variances, Income Statement Visualization, or Year-over-Year growth analysis.
- Executive Impact: C-suite leaders immediately identify the core drivers behind financial results, keeping strategic discussions focused on key actions rather than math checks.
Key Takeaways
- Consistency drives clarity: Visualizations reduce interpretation errors and strengthen trust in data.
- Standardization unlocks speed: Teams save hours weekly with unified, automated Cognos templates.
- Better insights lead to better decisions: Clear visualizations focus executives on what matters.
- CROZ + IBM Cognos Analytics: a powerful combination for modern, standards-aligned reporting.
- Customization & future-ready: Tailor dashboards to your needs based on ISO 24896.
Executive Summary
CROZ extends IBM Cognos Analytics with DataWizz custom extension, based on ISO 24896 enabling organizations to deliver clearer, more consistent, and more trustworthy reports to gain faster decision cycles, improved communication, and unified dashboards and reports across all teams.
Real-world implementations - from standardized management dashboards and redesigned income statements to project budget controlling—demonstrate time savings, reduced complexity, and elevated analytics quality for leadership. Our Cognos customization services, reports and dashboards are tailored specifically to your organization’s needs, ensuring maximum clarity and impact.
Clear reporting drives confident decisions. If you want to modernize your IBM Cognos Analytics dashboards and reports the CROZ team can help.
We offer services to customize your IBM Cognos Analytics reports, tailoring dashboards, templates, and visualizations to your organization’s needs. Ask yourself: are you using the right visualizations for the insights you need? CROZ ensures your Cognos environment delivers actionable, decision-ready visualizations.
Find out more - contact CROZ sales or book a 30-minute meeting.
]]>This episode is different.
Our guest is Stephanie Schoss – leadership expert, executive coach and lecturer at the University of St. Gallen, one of Europe’s leading business schools.
Stephanie Schoss studied at the University of St. Gallen, Singapore Management University and Harvard. She holds a PhD from RWTH Aachen University and is a Director of the Competence Center for Top Team Research at the Institute of International Management at the University of St. Gallen.
Besides her academic career, Stephanie is a passionate commercial and seaplane pilot and has been an active entrepreneur for the past 20 years – for which she was recognised as manager of the year in 2013 by Generation CEO.
Besides her professional life, she is a dedicated mother of 4 children and 4 stepchildren and lives part of the year in New Zealand with her family.
Stephanie studied business with a focus on finance, but throughout her career, she became fascinated by a different question: What makes people truly grow?
In this conversation, we explore leadership beyond titles and management techniques. We talk about developing the capacity to hold contradictions, why excitement and anxiety often come from the same place, how art and nature quietly shape the way we think, and why hope may be one of the most underrated leadership skills today.
We also discuss:
- Ambidextrous leadership and leading through paradoxes
- Learning through every decade of life
- The difference between surface-level and deep-level diversity
- Why does exposure to art and nature matters more than we realize
- And what Pippi Longstocking can teach us about courage:
“I’ve never done this before, so I must be brilliant at it!”
If you’re expecting another business podcast, this episode may surprise you!
P.S. – you can even pick your favourite listening platform 😁
🎧 𝗗𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝘁𝗵𝗲 𝗺𝗽𝟯: LINK
▶️ 𝗙𝘂𝗹𝗹 𝗲𝗽𝗶𝘀𝗼𝗱𝗲 𝗼𝗻 𝗬𝗼𝘂𝗧𝘂𝗯𝗲: LINK
🤖𝗖𝗵𝗲𝗰𝗸 𝗼𝘂𝘁 𝗼𝘂𝗿 𝗦𝘂𝗯𝘀𝘁𝗮𝗰𝗸: LINK
Over the past few months, I’ve had many conversations about AI-assisted development, and each one came from a different perspective.
“Yes, but we’re building a brand-new piece of software…”
“Yes, but we already have an existing system that’s 15 years old, and we must build on top of it, there is no way around it…”
“Yes, but we don’t actually build any new features. This is pure refactoring and modernization of an existing legacy system…”
So, how do you come up with a single AI-assisted methodology to cover all these cases? You already know the answer: there isn’t one. And in today’s 0800-DEVOPS, I’m sharing the approach that we at CROZ took to tackle this issue.
From greenfield development to legacy modernization
In our experience, there’s The Spectrum of development projects.
All the way to the left are greenfield projects. They start from scratch, no legacy, no baggage, sky’s the limit. Frameworks such as BMAD fit well here.
A Little further to the right are brownfield projects. They start with an existing system that gets modified as new features are added. The existing system can’t be thrown away, even though documentation for it is mostly nonexistent and nobody really knows how they work.
All the way to the right are pure modernization and refactoring projects. No new functionality is considered. It’s all about optimizing and modernizing the existing implementation.
This isn’t a spectrum with just three distinct states, but rather a continuum along which there are countless different cases and circumstances.
Most modern frameworks, such as BMAD, address the left-hand side of The Spectrum — projects that are completely or mostly greenfield. Rarely does anyone address the right-hand side, and should we blame them for that? The right-hand side is dirty, messy, full of constraints, sometimes a minefield. Are you old enough to remember Minesweeper?
As a BizTech consultancy, we don’t ignore the fact that these messy systems represent the biggest challenge for our clients. That’s why we developed and battle-tested a methodology that gradually assists dev teams as they move along The Spectrum toward the right-hand side. It’s called Carbon.modernize.
Carbon.modernize is a comprehensive suite of tools and practices that helps development teams get familiar with undocumented legacy systems and apply agentic force to refactor and modernize them. It’s not an all-or-nothing suite, but rather a collection of tools and practices where you pick and choose the right tool for the job.
How Carbon.modernize supports modernization projects
If you operate on the left side of The Spectrum, you’re in a greenfield project, and you’re probably doing well with a framework like BMAD. As soon as you start moving to the right, Carbon.modernize starts assisting you.
In the middle of The Spectrum are brownfield projects. Their typical challenge is poor documentation. Carbon.modernize helps teams get familiar with the legacy system while generating well-structured business and technical documentation for it. It does so intelligently — recognizing where it’s fully confident, but also where confidence is lower and human input is needed. This documentation isn’t a wall of text, but a well-structured, machine-readable, and smartly interlinked resource that provides a strong foundation for using BMAD and similar frameworks, even on brownfield projects.
If you move all the way to the right of The Spectrum, you’ll end up in modernization projects. Remember those legacy systems that are anywhere between 15 and 40+ years old? Think of 5M lines of COBOL, PL/I, Oracle Forms, Java 1.4, classic ASP.NET. Nobody wants to build new functionality in those systems. Everyone just wants to upgrade the technology, runtime, and middleware.
This is where Carbon.modernize shines. I already explained how it generates well-structured business and technical documentation. Here, it uses that documentation to custom-build agents that perform the modernization. In cases where LLM power is needed during modernization, Carbon.modernize protects organizational privacy by running a private, airgapped, fully-controlled LLM inside the Carbon.core foundational platform. That way, non-sensitive data can be processed by frontier models, while sensitive data always remains in a protected environment, far away from frontier models.
I’m sharing the approach we took with Carbon.modernize because it’s different from everything we’ve seen out there. It doesn’t claim to be a silver bullet you should reach for on every challenge. Rather, it’s a collection of tools and practices that support you when you need them. It’s like an electric bike, giving you a nudge exactly when you need it most.
If your organization is sliding to the right-hand side of The Spectrum, give me a shout, there’s a way to stop you from sliding into the abyss.
And if you haven’t seen it by now, check out my book BizTech Evolution. It introduces an innovative framework for transforming how businesses and their technology service providers collaborate in an increasingly complex digital world, ultimately creating more value for both parties and the broader community.
Your feedback is much appreciated. Or as I would put it recently: Ich bedanke mich bei Ihnen für Ihr Feedback!
]]>Everybody agrees that AI has brought plenty of good news for mainframe customers. Frontier LLMs keep pushing the boundaries – they can read and understand COBOL (or just about any other language) with ease. Some even claim the mainframe skills gap is now a thing of the past: no need for years of specialized experience when anyone can write a prompt in natural language. (Of course, it helps to have a healthy budget for all those tokens.)
The reality, however, is a bit more nuanced. I’ve seen quite a few AI initiatives stall along the way; sometimes because vendors overpromised, but more often because implementing AI in a complex mainframe environment requires deep domain expertise. Every mainframe shop is unique, with decades of customizations, integrations, and tribal knowledge built into its systems. Success comes from combining strong mainframe expertise with practical AI skills – not from relying on either one alone.
In the heat of the European summer, we’re bringing you a real-world story of AI-assisted mainframe modernization.
And while you’re reading, save the date for the Mighty Mainframe Conference ’27. We’d love to see you there.
From Lost Documentation to Mainframe Clarity
Imagine inheriting a mainframe environment with no reliable documentation, no accurate system model, and no access to the original data access layer. Sound familiar? That was exactly the situation we faced in one of our recent projects.
The challenge was to rewrite a business-critical module and make it maintainable. To tackle it, we turned to CROZ Carbon.modernize, our modernization methodology, powered by AI-driven technology. By uncovering application flows, dependencies, and embedded business logic, it provides deep visibility into the application landscape. Instead of spending months piecing together system behavior from source code and scattered documentation, we could focus on validating insights and solving the actual modernization challenges.
Armin Kramer and Krunoslav Funtak share a first-hand, step-by-step account of the journey. Read it here.
THE Conference 2027 – Save the date!
The Mighty Mainframe Conference already has a date, and we thought you might like to be among the first to know.
We’re moving to a new venue, but don’t worry – we’re keeping everything you love: insightful content, a friendly atmosphere, and plenty of mind-blowing moments. If you’re wondering what to expect, check out this year’s feedback on our website.
Industry Insights
Mainframe Modernization in the AI Era
HyperFRAME recently published a well-written report on the current state of mainframe modernization in the age of AI.
Read the report here.
The Human Side of AI: Burnout and Rising Expectations
Andy McCandless recently shared a thought-provoking post on the growing pressure facing software developers—and why AI may be making the situation even more challenging. While this affects the IT industry as a whole, our small mainframe community is likely even more exposed to the risks of increased workloads and higher expectations.
The article includes an eye-opening interview and is well worth a read.
Read the full story here.
]]>We had COBOL. And that was about it.
The business still relied on the system every day, yet most of its critical knowledge was buried deep within programs, copybooks, JCL, files, screens, and database calls that few people had examined in years. To make matters even more challenging, this was a business-critical module that would need to support the organization for years to come. A “do nothing” approach was simply not an option.
Management recognized that the risks associated with limited system knowledge were no longer sustainable and engaged our team to stabilize the application, reduce operational uncertainty, and make it manageable again.
Before we could modernize the system, we first had to understand it.
To tackle this challenge, we turned to Carbon.modernize, our methodology built on CROZ’s hands-on experience.
Carbon.modernize combines deterministic mainframe preprocessing with AI-assisted analysis techniques to deliver a deep, comprehensive understanding of legacy systems. By uncovering software flows, dependencies, and embedded business logic, it provides complete visibility into the application landscape while significantly reducing manual analysis effort through automation and knowledge reuse.
What followed was a journey of discovery, one that transformed a collection of disconnected legacy artifacts into a clear, navigable map of the system.
Step 1: Rebuilding the Story from Code
We quickly learned that reading one COBOL program at a time would not work.
Logic jumped through GO TO chains, shared working storage, multiple entry points, and long paragraph sequences that didn’t look anything like a business process. One operation might start in one program, validate in another, hit the database in a third, and finish somewhere else entirely.
The first job for Carbon.modernize was to bring order to this chaos.
It collected everything it could see, programs, copybooks, jobs, database operations, files, screens, and shared data structures, and stitched them into a connected system view instead of a pile of isolated source files.
Even without the original IMS access layer, Carbon.modernize could infer how the database was used by following keys, record access, status checks, and later data usage in the code.
Slowly, a picture emerged: Not just what the code said, but what the system actually did.
In one core process, a single IMS call was surrounded by dozens of flags, counters, and GO TO branches. At first glance, it looked like defensive error handling with some retry logic. Only after Carbon.modernize linked the surrounding paragraphs, the calling jobs, and the later data usage did the real meaning become clear: The code was enforcing a strict update window on a specific set of agreements, silently rejecting changes outside that window. Without that reconstruction, we would have either reproduced unnecessary complexity or broken a subtle business rule.
Step 2: Separating Business from Noise
Once we could follow the flows, a second problem appeared: Most of the code was not business logic.
It was technical scaffolding, record movements, platform-specific flags, navigation through IMS, defensive checks, and error handling. Somewhere inside all that sat the real rules that mattered to the business.
Carbon.modernize treated this as a sorting job:
- What is true business behavior that must survive modernization?
- What is technical behavior that still matters (consistency, order, recovery)?
- What is just legacy implementation detail we should not copy?
Care for an example? There was a nightly file job that appeared to simply consolidate data. The flow and data analysis by Carbon.modernize showed that a small branch inside that job was actually driving a critical notification process for a specific customer segment. That insight turned a “background job” into a visible requirement, ensured a proper design in the new system, and prevented a silent loss of business behavior.
A long chain of paragraphs walking through IMS records might boil down to a simple sentence: “Find the agreement, make sure it can be changed, and decide what to do next.”
That sentence is what we want in the new system, not the old mechanics that happened to implement it.
Step 3: Using AI Without Losing Control
At this point, AI could have easily become a dangerous shortcut.
Throwing a large COBOL program at a generic model and asking “explain the business logic” sounds attractive, but it ignores jobs, copybooks, interfaces, and data context that sit outside that file.
Carbon.modernize took a different approach.
Standard analysis tools and generic AI models tend to treat each program, job, or file in isolation. They can highlight syntax, detect patterns, or propose refactorings, but they rarely understand how a specific IMS call, a flag, or a paragraph chain fits into the wider business context. Our custom approach starts from a deterministic system map and then uses task-specific agents on top of that context. That combination is what allows it to answer questions such as “is this rule business-critical or just technical scaffolding?” and “what exactly happens if this path is removed?” questions that conventional tools cannot reliably address at scale.
A deterministic preprocessing layer first prepared the facts: structures, flows, dependencies, data operations.
On top of that, task-specific AI agents did focused jobs, explain a program, reconstruct a logical flow, identify business objects, or review generated artefacts.
When metadata was not enough, they went back to the raw source and verified their conclusions instead of guessing.
The result was not “AI’s opinion about the code”, but repeatable, reviewable analysis grounded in the original evidence.
Step 4: Designing the New System Instead of Translating the Old One
Once we understood the behavior, the temptation was obvious: Translate COBOL to a new language and declare victory.
We did the opposite:
The target system remained in place; the real work was cleaning up the job flows and program structure around it. The only migration step was moving the data-access layer from IMS to Db2.
Carbon.modernize artefacts defined what had to be preserved, operations, decisions, inputs, outputs, data effects, and externally visible behavior.
Then we designed the target system around that:
- Paragraph chains became clear service operations
- Shared working storage became explicit request/response models
- IMS navigation became structured repository queries
The old system dictated behavior, not shape. That gave us room to fix decades of accumulated complexity instead of re-creating it line by line.
Step 5: Proving That We Got It Right
There was no complete specification to test against, so we built one from the system itself.
Carbon.modernize created a traceable chain:
legacy source → logical behavior → requirements → new implementation → tests
Where both systems could run, we executed the same scenarios and compared decisions, outputs, messages, and data changes. When something didn’t match, traceability pointed us straight back to the original evidence and the new code implementing it.
Testing stopped being a final gate and became part of a continuous correction loop.
What Carbon.modernize Really Changed
In the end, Carbon.modernize did more than “explain COBOL”.
It allowed us to modernize a system where:
- Documentation was unreliable,
- The database access environment was missing,
- And business behavior was buried under technical noise.
What made Carbon.modernize particularly valuable was its flexibility. Rather than being a rigid, preconfigured tool, it is a methodology supported by dynamically generated AI-assisted assets. This allowed us to adapt quickly to the unique characteristics of the system, often addressing new challenges within the same day.
As a result, modernization became more than a large-scale translation exercise. It became a controlled, evidence-based process: understand, separate, redesign, and validate.
And for once, we had something rare in large legacy programs: A traceable line from what the old system really did to what the new system is now required to deliver.
This context-aware approach is what sets Carbon.modernize apart. Instead of mechanically translating legacy code and behaviors, it focuses on identifying and preserving true business functionality while separating it from outdated technical implementation details.
]]>We think of AI in the same way: one AI philosophy, one set of principles, obeyed and reused everywhere to build the specific implementation for a particular problem.
Our AI approach at CROZ is called Carbon. Just like carbon in real life, Carbon is a single AI philosophy that takes many different shapes and forms, depending on the purpose. Whether you aim to modernize legacy systems, run agents in a controlled environment, simplify your infrastructure operations, or turn organizational tribal knowledge into a knowledge base, the same AI philosophy will help you do that. Where it matters, on a sovereign, air-gapped, private AI infrastructure.
Carbon Principles
Carbon is a methodology built on CROZ’s hands-on experience delivering complex technology projects in real-world enterprise environments. It is not a theoretical framework or a vision statement. It is a practical approach shaped by engineers solving real problems, overcoming real constraints, and delivering measurable results.
Carbon is also more than a collection of principles. It includes a set of proven assets, frameworks, and accelerators designed to help organizations adopt AI faster and with less risk.
Rather than building rigid off-the-shelf products, we develop configurable and extensible assets that are “80% ready-made” and capable of handling the heavy lifting from day one. The remaining 20% is tailored to each organization’s unique business processes, technical landscape, and governance requirements.
Carbon Is Always Custom-Tailored
As software development becomes faster and more affordable, organizations increasingly seek ways to differentiate themselves. We believe that one-size-fits-all products often impose unnecessary limitations and make differentiation more difficult.
Our approach is therefore different. We build powerful, reusable components that provide a strong foundation while remaining fully adaptable to each client’s specific needs. This allows organizations to leverage the strengths of their existing technology landscape without being constrained by the assumptions built into commercial off-the-shelf solutions.
The Carbon Platform
The Carbon platform consists of foundation platform and four specialized components:
- Carbon.core is the foundation platform, including on-premises LLM. It enforces policy, tracks adoption and cost, provides full tracing across every agent and run, and gives your organization the choice to run frontier cloud models, self-hosted models, or both.
- Carbon.modernize accelerates legacy system modernization by discovering and documenting business logic, dependencies, data flows, and application interactions. Legacy can be mainframe system, vintage Java applications, or .NET system.
- Carbon.run provides a governed environment for building, orchestrating, and managing AI agents and workflows.
- Carbon.operate supports AI-driven infrastructure operations while maintaining human oversight and control.
- Carbon.know transforms enterprise documentation, standards, and institutional knowledge into a searchable knowledge layer for both users and AI agents.
Together, these components enable organizations to modernize, automate, operate, and govern AI solutions securely and at scale.
The Carbon platform follows a “freemium-like” commercial model. Since it is not a packaged product, there is no need for a substantial upfront investment before project initiation. Instead, we begin with a cost-free pilot project that enables customers to experience and validate the platform’s value in a real-world setting.
After the pilot phase successfully demonstrates measurable benefits, we establish a commercial model that reflects the value created and the responsibilities shared between the customer and the CROZ team. This approach minimizes initial risk while ensuring that investment is aligned with proven business value.
Learn more about Carbon here.
Carbon.modernize: A Mainframe Perspective
Let’s take a closer look at Carbon.modernize from a mainframe modernization perspective. The methodology is designed to address one of the most challenging aspects of enterprise transformation: understanding, preserving, and evolving decades of business logic embedded within complex legacy environments.
Deterministic Mainframe Preprocessing
One of the greatest challenges in mainframe modernization is understanding the current environment. Mainframe ecosystems contain complex, interconnected components, including infrastructure, applications, databases, batch jobs, transactions, files, screens, and interfaces. Critical business knowledge is often embedded in code, copybooks, JCL, and database interactions. Many components have not been reviewed for years, and the original architects or subject matter experts are frequently no longer available.
Carbon.modernize addresses this challenge through deterministic preprocessing of the complete source landscape. It systematically identifies, parses, and correlates all available artifacts to create a verified representation of the application before AI-assisted analysis begins.
This deterministic foundation provides comprehensive visibility into software flows, data dependencies, interfaces, and application interactions. It also prepares the structured context needed to further analyze the system accurately, consistently, and at scale—reducing ambiguity, limiting unsupported assumptions, and ensuring that important relationships are not overlooked.
The result is a deeper and more reliable understanding of the legacy environment, with findings that are repeatable, traceable to the underlying source, and suitable for validation. Modernization decisions can therefore be based on evidence rather than inference, while AI is used to accelerate and enrich analysis without compromising accuracy or control.
Enabling Incremental Modernization with Continuous Verification
Large-scale modernization programs often carry significant business risk because they attempt to transform entire systems in a single project phase. Carbon.modernize takes a different approach by enabling incremental modernization with continuous verification.
Instead of requiring a “big bang” migration, applications can be modernized step by step while preserving operational stability. Individual components, business functions, services, or application domains can be transformed independently while maintaining compatibility with the remaining legacy landscape.
The AI capabilities supporting modernization must evolve in the same way. As project-specific knowledge increases, the analysis models, transformation rules, validation mechanisms, and AI-assisted workflows must be progressively refined to reflect the application’s technologies, architecture, business logic, and modernization objectives.
This adaptability is essential for fully realizing the value of AI in complex modernization programs. Closed or monolithic tools may perform well for predefined scenarios but can become constrained when they cannot incorporate newly discovered system knowledge, project-specific rules, expert feedback, or changing transformation requirements. Carbon.modernize enables AI capabilities to be incrementally extended and aligned with the needs of each modernization stage.
At every stage, modernization outputs are continuously verified against the original system to ensure:
- Functional equivalence
- Preservation of business rules
- Data consistency
- Process integrity
- Compliance with modernization objectives
This continuous verification approach significantly reduces project risk, provides measurable progress throughout the transformation journey, and allows organizations to deliver modernization benefits earlier rather than waiting for a final cutover event.
Reducing Manual Analysis Effort Through Knowledge Reuse
Traditional modernization projects often require extensive manual analysis by highly specialized experts. A significant amount of effort is spent repeatedly discovering the same information across applications, teams, and project phases.
Carbon.modernize dramatically reduces this effort through knowledge capture and reuse.
As the platform analyzes the legacy environment, it generates structured modernization assets, including:
- Enterprise knowledge graphs
- Application dependency maps
- Business process models
- Searchable technical dictionaries
- Data lineage information
- Interface and integration catalogs
These assets create a continuously expanding knowledge repository that can be reused across the entire modernization lifecycle.
Built on this application knowledge base, live AI assistance enables teams to interactively explore the system and obtain context-specific explanations and insights on demand.
This enables teams to quickly locate application functionality, understand relationships between components, identify dependencies and impacts of change, discover business rules embedded in code and reuse insights across modernization initiatives.
A Hybrid AI Architecture
Carbon.modernize employs a hybrid AI architecture designed to balance automation, performance, privacy, and governance requirements.
On-Premises Script Engine
A key principle of the Carbon.modernize architecture is that all source code and modernization artifacts are processed by an on-premises Script Engine by default. The Script Engine executes deterministic analysis and transformation workflows, ensuring predictable, repeatable, and auditable results. As a result, customer source code, configuration files, documentation, and other sensitive assets never need to be uploaded to public cloud services or external LLM platforms.
The Script Engine itself can be generated and enhanced using either the Carbon.core platform or, where appropriate, frontier commercial LLM technologies. For scenarios that benefit from additional intelligence and automation, agentic workflows can be selectively introduced to support more advanced analysis and modernization activities.
On-Premises LLM (Carbon.core)
For use cases that require natural language understanding, knowledge extraction, code interpretation, documentation generation, or other AI-driven capabilities, Carbon.modernize leverages Carbon.core, an on-premises LLM environment.
Through custom agents, Carbon.core combines project-specific knowledge, specialized tools, deterministic workflows, and validation mechanisms to maximize the capabilities of on-premises LLMs. This enables sophisticated, multi-step modernization tasks that would not normally be expected from the underlying model alone.
Carbon.core enables organizations to apply AI to highly sensitive workloads while ensuring that all data remains within controlled customer environments and in compliance with internal security, privacy, and governance policies.
Full Protection of Privacy and Intellectual Property
Privacy and intellectual property protection are foundational principles of the Carbon.modernize methodology. We strictly adhere to customer policies regarding:
- Data privacy
- Security requirements
- Intellectual property protection
- Regulatory compliance
- AI governance
The flexibility of the Carbon.modernize architecture allows customers to determine how individual activities should be executed based on their risk profile and governance requirements.
Depending on customer preferences, specific tasks can be handled by on-premises script engine, on-premises Carbon.core LLM or selected public LLM services (where permitted).
This flexible execution model allows organizations to achieve the desired balance between security, compliance, cost, and modernization speed while retaining complete control over their sensitive assets and proprietary business logic.
]]>And then AI agents entered the room.
Suddenly, innovation is no longer necessarily scarce. It can appear almost anywhere. Useful, enthusiastic, sometimes duplicated, sometimes half-baked, sometimes surprisingly good.
Welcome to the beautiful mess of agentic innovation!
The cost of building is shrinking
A few years ago, if someone had an idea for an internal tool, testing assistant or domain-specific accelerator, the path was predictable.
Someone would write a proposal, estimated budget, asked who will pay for it or approve it. Very often, the idea would die somewhere between “interesting” and “not now”.
Today, any motivated individual can often build the first working version before anyone has even noticed that the idea exists. That is both great and scary – great because it creates energy (people can now automate and improve things without waiting for a programme to approve them), and scary because energy alone is not a system.
At CROZ, we see agentic assets appearing in many corners of the organization. Some improve delivery, some support internal operations, others help with knowledge access. Some are born from customer needs, others from curiosity and enthusiasm.
I like that energy, and I must acknowledge one thing – the old innovation process is too slow for this new reality.
The new question is when to notice
The new problem is how to notice the right ideas early enough, without killing them too soon. This is a delicate balance.
If you (the organization) get involved too soon, you can slow everything down. A small creative experiment suddenly becomes a project, a project needs a sponsor who needs a plan which needs a budget. And the original spark disappears.
But if you get involved too late, you may end up with ten similar tools, unclear ownership, security questions and a growing pile of assets that someone will eventually have to maintain.
The organizations simply need a much better mechanism for rapid validation after something is born. Let people build, and then quickly ask the hard questions – the ones about value, risks, lifecycle.
Runtimes matter
Organizational governance is not the whole story. There is also a more technical issue that is easy to miss at first: runtimes.
Most of these new assets are agentic in nature. They do not just sit there as static tools: they use models, call APIs, they depend on prompts, memory, permissions, data sources, orchestration, logging, tracing and evaluation.
In the beginning, every team naturally builds its own little runtime around its own agent, and that works for a while. If every agentic asset brings its own runtime, we create fragmentation in many areas: handling identity, model routing, security assumptions, cost visibility, deployment patterns, different answers to the same governance questions.
We have seen this pattern before in IT – local optimization creates global complexity.
So the question becomes obvious: should every asset manage its own runtime, or do we need a shared agentic runtime layer? I think we do. Centralization is not always good, but some capabilities should not be reinvented every time. Identity, security, model access, observability, cost control, evaluation, deployment and lifecycle management are part of making agentic assets safe and useful in a real organization.
This is where platform thinking enters the story again. Or, at least, that is how we decided to approach the runtime challenge around agentic assets. My colleague Ivan Krnić wrote a great article about what we learned from building an agent control plane. Yes, that is an agentic asset as well.
The goal is to learn faster
Agentic innovation creates new skills, new offerings, new delivery capabilities, new technical perspectives and new enthusiasm. But if we do not adapt our processes, we will not harvest the value, we will only create a new kind of mess.
The better way to manage it means more freedom at the beginning, faster validation after the first version, clearer ownership, better lifecycle management and a pragmatic way to decide which assets stay internal, which become part of services, and which deserve a more serious business model.
This is not a solved problem. At least not for us, not yet.
But it is one of the most interesting problems we are working on right now. And I suspect many of you are facing the same thing, even if you use different words for it.
Finally, I would like to share some of the AI initiatives that made it through the first round of experimentation at CROZ. We have brought them together under the Carbon brand, showcasing how we use our own AI tools today to modernize, build and operate enterprise-grade systems and solutions.
]]>