A bank adopted all three. The governance office mapped its controls to COBIT. Operations ran change enablement and configuration management on ITIL. The architecture team published baseline and target architectures in TOGAF. When auditors asked a single question, which applications process customer financial data and what do they depend on, three teams produced three answers: a control register listing 214 applications, a configuration database listing 301, and an architecture repository listing 187. Every framework was being followed faithfully. None of the three could say which list was right.
The frameworks themselves are easy to tell apart. COBIT asks what should be governed and who is accountable. ITIL asks how services are delivered, changed, and supported day to day. TOGAF asks how the architecture is designed and how it evolves from the current state to a target. Most comparisons stop there, with a table of scope, size, and certification paths, and a recommendation to combine them. That is useful, and it leaves out the question the bank could not answer.
All three frameworks consume the same input: an accurate account of which applications exist, what they do, what data they handle, and what depends on them. None of the three produces it. In estates built on COBOL, shared databases, and batch chains, that account lives in code rather than in any register. The comparison below sets out what each framework is, how they differ, how they layer, and what each demands from the portfolio, then uses that comparison to show where legacy estates break all three at the same point.
Impact Checks Inside the CAB Meeting
SMART TS XL gives configuration, risk, and architecture teams one code-derived inventory, so the numbers finally agree.
FIND OUT MORE…The Short Answer: Govern, Manage, Design
The shortest accurate summary is that COBIT governs, ITIL manages, and TOGAF designs. COBIT sits closest to the board and the audit committee, setting the objectives that technology must serve and the accountabilities for achieving them. ITIL sits closest to operations, defining the practices that keep services running and changing safely. TOGAF sits between them, translating strategy into an architecture and a plan for getting there. None of the three replaces the others, and treating them as competitors is the most common mistake organizations make when choosing between them. The table sets them side by side on the dimensions that matter most for selection.
| Dimension | COBIT | ITIL 4 | TOGAF |
|---|---|---|---|
| Steward | ISACA | PeopleCert (Axelos) | The Open Group |
| Core question | What should we govern, and who is accountable? | How do we deliver and change services reliably? | How do we design and evolve the architecture? |
| Primary lens | Governance and management of enterprise IT | Service management | Enterprise architecture |
| Structure | Governance and management objectives grouped into five domains | Service value system, value chain, and practices | Architecture Development Method, repository, and content framework |
| Typical outputs | Control mappings, capability assessments, accountability charts | Process definitions, service levels, change and incident records | Baseline and target architectures, gap analysis, migration plans |
| Primary audience | Boards, risk, audit, CIOs | Service owners, operations, support | Enterprise architects, CIOs, programme leads |
| Strength | Auditable, risk-aware, tied to enterprise goals | Operational consistency and service accountability | Structured target-state design and stakeholder alignment |
| Blind spot | Does not tell you how to build or verify the inventory it assumes | Steady-state focus; migrations are outside its core | Governs architecture compliance, not enterprise IT as a whole |
Each Framework in Brief
Each framework has a distinct centre of gravity, and understanding it explains both its strengths and its limits. COBIT is organized around governance and management objectives and is explicit about accountability. ITIL is organized around the flow of value through services and is explicit about operational practice. TOGAF is organized around a method for producing and maintaining architecture and is explicit about stakeholders and transitions. The three also differ in how they are adopted. COBIT is typically tailored through design factors, ITIL is adopted practice by practice, and TOGAF is applied through its method and then adapted. The sections below summarize each in turn, with the part of it that depends most on accurate portfolio data.
COBIT
Purpose. COBIT is ISACA’s framework for the governance and management of enterprise information and technology. COBIT 2019 organizes forty governance and management objectives into five domains: Evaluate, Direct and Monitor; Align, Plan and Organize; Build, Acquire and Implement; Deliver, Service and Support; and Monitor, Evaluate and Assess. Design factors help an organization tailor the system to its goals, risk appetite, and operating model, and capability levels measure how well each objective is performed.
Strength. It connects technology to enterprise goals and to risk, and it produces evidence an auditor can follow, which is why it is favored in regulated industries and for board reporting.
Where it needs portfolio data. Objectives for managed assets, managed configuration, managed IT changes, managed risk, and managed compliance with external requirements all assume that the organization knows what it has and what it touches.
ITIL 4
Purpose. ITIL 4 describes a service value system and a value chain of activities (plan, improve, engage, design and transition, obtain and build, deliver and support), supported by 34 management practices. It is the most widely adopted of the three, and its practices, such as incident management, problem management, change enablement, release management, and service configuration management, define how operations work.
Strength. It gives operational teams a shared vocabulary and consistent processes, with clear accountability for service levels.
Where it needs portfolio data. Change enablement needs to assess the impact of a change before it is approved. Service configuration management needs configuration items and their relationships. Problem management needs a way to trace a failure to its cause. Each of these is only as good as the dependency data behind it.
TOGAF
Purpose. TOGAF, from The Open Group, centres on the Architecture Development Method, a cycle that moves from architecture vision through business, information systems, and technology architectures to opportunities, migration planning, implementation governance, and architecture change management. It works from a baseline architecture toward a target and identifies the gaps between them.
Strength. It gives modernization and integration programs a structured way to define a target state and align stakeholders around it.
Where it needs portfolio data. The baseline is the starting point of the whole method. Gap analysis and migration planning require knowing the current applications, data, and dependencies accurately enough to sequence the work.
Where They Overlap and Where They Collide
The three frameworks overlap on change, risk, and architecture, and they collide on one thing in particular: each keeps its own record of what the estate contains. COBIT’s asset and configuration objectives, ITIL’s configuration management and asset management practices, and TOGAF’s baseline application architecture all describe the same applications. They are typically owned by different teams, built at different times, from different sources, and maintained to different standards. The table shows how the same question is answered in each.
| Question | COBIT | ITIL 4 | TOGAF |
|---|---|---|---|
| Which applications exist? | Managed assets and configuration objectives expect an accurate inventory | Service configuration management and IT asset management practices | Baseline application architecture in the ADM |
| What depends on what? | Relationships support risk and change objectives | Relationships feed change impact assessment | Dependencies drive gap analysis and migration planning |
| What changed? | Managed IT changes objective | Change enablement and release management | Architecture change management phase |
| Is it compliant? | Managed compliance with external requirements | Controls and practices evidenced through operations | Implementation governance and compliance reviews |
| Who is accountable? | Accountability charts per objective | Practice and service owners | Architecture board and governance framework |
Three registers of the same estate are not a governance strategy. They are three opportunities for the numbers to disagree, as they did for the bank in the opening.
How the Frameworks Layer in Practice
Organizations that use more than one framework usually arrange them in layers: COBIT for direction and accountability, TOGAF for target state and transition, and ITIL for day-to-day delivery and change. The layering works because each answers a different question at a different altitude. It works only if the layers share a foundation. The diagram adds that foundation explicitly.
Direction and accountability COBIT objectives, risk appetite, assurance
|
Target state and transition TOGAF baseline, target, gaps, migration plan
|
Day-to-day delivery and change ITIL 4 incidents, changes, configuration, releases
|
Shared input to all three One evidence baseline: applications, dependencies, data
The bottom layer is the one most programs omit. Without it, each framework builds its own picture, and the layering produces three confident answers instead of one.
Choosing Between Them
The right starting point depends on the problem the organization is trying to solve, not on the framework’s reputation. The table maps common problems to a sensible first move. Sequencing matters more than selection: adopting all three at once rarely succeeds, and the evidence baseline should come first because every framework depends on it. One comparison guide puts typical implementation effort at roughly 6 to 12 months for COBIT, 3 to 9 months for ITIL, and 9 to 18 months for TOGAF, though estimates vary widely with scope and should be treated as orders of magnitude.
| If your main problem is | Start with | Why |
|---|---|---|
| Audit findings, regulatory accountability, board reporting | COBIT | Gives governance structure and evidence an auditor can follow |
| Unstable services, repeated incidents, failed changes | ITIL 4 | Standardizes the operational practices that cause the instability |
| Modernization or integration with an unclear target state | TOGAF | Defines baseline, target, gaps, and a migration path |
| Post-merger integration | TOGAF baseline, then COBIT governance | Establishes the combined estate before accountability is assigned |
| Regulated enterprise running both legacy and modern estates | COBIT overlay on ITIL operations, with a TOGAF baseline | Governance on top, operations beneath, shared baseline under both |
The Evidence Problem: What Each Framework Needs From Your Portfolio
Every framework has artifacts that depend on portfolio facts. In modern, well-instrumented estates those facts come from discovery tools, tags, and service maps. In estates built on COBOL, JCL, shared datasets, and batch dependencies, they do not exist in any register, because the relationships live in code: which programs include which copybooks, which jobs run which programs, which datasets flow between them. The table lists the framework artifacts that depend on those facts and the failure that follows when the facts are missing.
| Framework artifact | What it requires | Typical failure in legacy estates |
|---|---|---|
| COBIT managed configuration and managed assets | Accurate configuration items and relationships | Configuration database lacks programs, copybooks, jobs, and datasets |
| COBIT managed risk | Inventory and dependencies to build risk scenarios | Unknown dependencies make risk ratings guesses |
| COBIT compliance with external requirements | Where regulated data is processed | Regulated fields never located in record layouts |
| ITIL change enablement | Impact assessment before approval | No impact data across batch and shared-data dependencies |
| ITIL service configuration management | Complete configuration records | Records built by hand, stale within months |
| ITIL problem management | A way to trace failures to causes | Investigation starts from memory, not from the code |
| TOGAF baseline architecture | Current applications, data, and technology | Baseline built from interviews and diagrams that predate the code |
| TOGAF gap analysis and migration planning | Dependencies to sequence the work | Retirements blocked by consumers nobody listed |
| TOGAF implementation governance | A way to verify projects conform to the architecture | No structural check, only document review |
One record can serve all three frameworks if it is derived from the code instead of assembled by hand. The annotated example shows a single application record and which framework consumes each part of it.
yaml
application: BILLRUN
# COBIT managed configuration, ITIL service configuration: items and relationships
components: {programs: 118, copybooks: 31, jobs: 12, datasets: 24}
relationships:
inbound_dependents: 41
outbound_dependencies: 12
# COBIT managed risk and compliance
data_classes: [financial, pii]
regulatory_functions: [quarterly_capital_report]
# ITIL change enablement: input to impact assessment
change_impact_scope: derived_from_dependency_graph
# TOGAF baseline and gap analysis
baseline_status: derived # assumed | derived | verified
technical_health: {avg_cyclomatic_complexity: 24, dead_code_pct: 31}
Governing a Modernization: Where Each Framework Runs Out
Modernization exposes a limit shared by all three frameworks. A recent practitioner framework paper makes the case that existing frameworks leave a gap around actively executing migrations: ITIL provides strong steady-state change and incident practice but does not say how a migration in flight should be governed, COBIT defines what governance should achieve and who is accountable but not what governed execution looks like, and TOGAF defines target-state architecture but offers little on controlling the transition. The gaps cluster around the same things: mapping legacy dependencies before decommissioning, keeping architecture decisions auditable across months of migration, and validating data quality across a platform transition.
The checkpoints below show how the frameworks can be combined to close that gap, with the evidence each checkpoint requires.
| Modernization checkpoint | Framework home | Evidence required |
|---|---|---|
| Wave scope is dependency-closed | TOGAF migration planning, COBIT change transition objective | Verified dependency graph for the wave |
| Each change is impact-assessed | ITIL change enablement | Impact scope derived from code, not estimated |
| Regulated data and functions are accounted for | COBIT compliance objective | Located regulated fields and the programs that process them |
| Architecture decisions are traceable | TOGAF architecture governance | Decisions linked to the structural evidence behind them |
| Decommissioning is verified | COBIT asset lifecycle, ITIL retirement practice | Zero inbound dependencies confirmed; retirement certificate |
Frequently Asked Questions
Which is better, COBIT, ITIL, or TOGAF? They answer different questions, so none is better in general. COBIT suits governance and audit, ITIL suits service operations, and TOGAF suits architecture and transition planning. Most large organizations use more than one.
Can you use all three together? Yes, usually in layers: COBIT for governance, TOGAF for architecture, ITIL for operations. Adopt them in sequence, starting with whichever addresses the most pressing problem, and give them a shared baseline of applications and dependencies.
Is TOGAF a governance framework? It includes architecture governance, covering compliance of projects with the architecture, but it is not an enterprise IT governance framework in the way COBIT is. Its governance concerns architectural decisions and conformance.
Is ITIL governance or management? ITIL is a management framework. It defines how services are planned, delivered, and improved, and it is commonly run beneath a governance layer such as COBIT.
Do these frameworks help with legacy modernization? They provide structure, and each assumes an accurate inventory and dependency picture. For legacy estates, that picture usually has to be derived from code before the frameworks can do their work.
How SMART TS XL, ASK AI, and the MCP Connector Feed All Three Frameworks
SMART TS XL supplies the evidence baseline that the three frameworks share, and its ASK AI and MCP Connector capabilities decide how many people across governance, architecture, and operations can use it.
Enterprise search across languages builds the inventory from source libraries, load libraries, and job schedules, which is what COBIT’s configuration objectives, ITIL’s configuration records, and TOGAF’s baseline all need and what hand-built registers miss. Application dependency mapping supplies the relationships: callers, shared copybooks, dataset flows, and downstream consumers, refreshed as the estate changes. Structural impact analysis turns that graph into the impact scope that ITIL change enablement and COBIT change objectives call for before a change is approved. Static code analysis measures complexity, coupling, and security patterns, which gives the risk and technical health inputs for governance reporting and architecture decisions. Legacy modernization analysis identifies dead and unreachable code, which removes programs from migration scope and anchors verified retirement.
ASK AI over verified context lets auditors, architects, and service managers ask for evidence in plain language against a scoped result set. A request such as mapping every job and program that touches a given table, or extracting every validation rule from a payment cycle, produces an answer whose findings stay linked to the source lines they came from, which is the kind of traceability an audit trail relies on. Saved and shared prompts turn recurring audit requests into repeatable queries. The SMART TS XL MCP Connector makes the same answers available inside approved assistants such as ChatGPT, Claude, Copilot, Gemini, and Grok, so a change manager in a review board meeting can ask which programs a proposed change touches without leaving the tool they are already using. Access is read-only, authenticated, and role-based.
| Framework need | Evidence | Capability |
|---|---|---|
| COBIT and ITIL configuration records | Programs, jobs, datasets, and relationships | Enterprise search and application dependency mapping |
| ITIL and COBIT change impact assessment | Impact scope of a proposed change | Structural impact analysis |
| COBIT risk and compliance | Technical health, security patterns, regulated data locations | Static code analysis and ASK AI |
| TOGAF baseline and gap analysis | Current-state applications, data, and dependencies | Enterprise search and application dependency mapping |
| TOGAF migration planning | Dependency-closed wave scope and dead code | Impact analysis and legacy modernization analysis |
| Audit and review questions | Source-linked answers in plain language | ASK AI and the MCP Connector |
Three boundaries keep expectations accurate. SMART TS XL is not a GRC platform, a CMDB, or an enterprise architecture repository. It supplies evidence to those systems and does not replace them. It does not define policies, processes, or control objectives, and it does not certify an organization against any framework. And it does not hold cost, contract, or service level data. The frameworks still require the organizational work of assigning accountability and running the processes. What the evidence baseline removes is the argument about whose list is correct.
Pick Any Framework. Feed It the Same Facts.
The bank in the opening did nothing wrong in adopting three frameworks. Each team did its job well, with the artifacts its framework prescribes. The failure was a missing foundation: no single, evidence-based account of the estate that all three could draw on, so each built its own and each was plausible.
Choose the framework by the problem in front of you. Govern with COBIT when accountability and audit are the issue, manage with ITIL when service stability is the issue, design with TOGAF when the target state is the issue. Then derive the baseline from the code once, and let all three read from it. Three frameworks that agree about the facts will govern better than any one framework applied to three disagreeing lists.


