Afunana is built for organizations that depend on IBM i, mainframe, or Oracle applications they no longer fully understand. These are the situations where it earns its keep.
Onboarding new developers
A developer who has never seen the codebase needs months to become productive on a large legacy application. The call graphs are deep, the field names are cryptic, and the business logic is buried in PERFORM chains across dozens of programs.
With Afunana, a new developer opens a program and reads a plain-language description of what it does, who calls it, what files it touches, and which business rules it enforces — with every statement linked back to the source line it came from, so they reach productivity without weeks of manual archaeology. See the Executive Summary.
Knowledge capture before retirement
The single biggest risk in legacy shops is the retirement of the people who hold the system in their heads. Once they leave, the knowledge is gone — and the community-wide skills shortage means it is rarely replaced.
Afunana captures that knowledge from the code itself — including the why-layer of business rules and intent that usually lives only in an expert's memory. The documentation is generated, current, and stays in sync with the source through incremental rebuilds that re-analyze only what actually changed.
Impact analysis before a change
Before changing a program or a file, you need to know what else depends on it. Doing that by hand means grepping source and hoping you found every reference.
Afunana's cross-reference and dependency data answer the question directly: which programs call this one, which programs read or write this file, and where a given field is defined and used. You see the blast radius before you make the change, not after the abend. Ask it in plain language — "what breaks if we lengthen the policy number?" — and get a cited impact analysis and compile order back.
Finding the silent failures
Some bugs only surface on the day a value finally exceeds a field's capacity, or a caller and callee disagree about a parameter's size, or a file read's status is never checked. They pass every test until real data triggers them, and in financial systems they can corrupt amounts or account numbers with no error message at all.
Afunana's deterministic quality checks find these structurally — parameter count and byte-size mismatches across CALL boundaries, MOVE operations that truncate data, unhandled I/O status, unsafe control flow, and (for Oracle) swallowed exceptions, DML without a WHERE clause, and dynamic-SQL injection — without running the code and without false positives from a probabilistic model. See Code Quality Analysis.
Planning and safely making a change
Understanding a program is half the job; changing it safely is the other half. Switch the chat assistant into Plan mode, describe the change you want, and Afunana produces a structured, validated modification plan grounded in the live codebase — which members to edit, what to change on which lines, the compile order, and the regression tests to run.
For teams that want it, the plan can be executed back to the live system under explicit human approval, with the new code written in the codebase's own coding style. The default posture is deliberately conservative: stop at the plan and hand off to a developer, with full automated execution available as an option rather than the assumed default. See Program Documentation and the AI pipeline docs.
Audit and compliance evidence
Auditors ask what a system does, who can access it, and how changes are controlled. Answering by manually reading code and pulling logs is slow and error-prone.
Afunana provides structured documentation as evidence, a tamper-evident security audit trail (a SHA-256 hash chain with database-enforced immutability and SIEM forwarding), and exportable reports. Compliance teams get objective, repeatable artifacts instead of tribal knowledge, with controls mapped to OWASP Top 10, ISO/IEC 27001:2022, and SOC 2. See Security & Compliance.
Scoping a modernization or rewrite
Modernization projects fail when the team rewrites code without understanding what the original was really doing — missing edge cases, special-case business rules, and implicit dependencies.
Afunana's why-layer, system overview, and cross-reference data give a modernization team an accurate map of the existing system and its traps before they commit to a target design. Its lane is deliberately "understand and maintain," not "rip and replace": the rewrite is scoped against reality, not assumptions — whether you keep the system where it is or eventually move it.
Answering business questions about the system
"Where do we calculate the cancellation penalty?" "Which programs touch the customer master?" "What happens when a policy lapses?"
These questions normally require an expert and an afternoon. With the AI chat assistant, anyone authorized can ask in plain language and get a cited answer in seconds, grounded in the actual code. The assistant has two live modes: Ask, for cited question-and-answer, and Plan, which turns the conversation into a validated change plan you can review before anything is touched — with an Agent mode shown as coming soon. You can also fold in your existing specs and manuals so the assistant reasons over what the code reveals and what your team already wrote. See Chat Capabilities.
Working inside your own tools
Teams already live in their editors and AI assistants, not in yet another web app. Afunana meets them there.
Through the authenticated MCP server, AI tools such as claude.ai, Cursor, VS Code, and Copilot can query the analyzed codebase directly — asking what a program does, tracing a field, or pulling the call tree without leaving the assistant. And the VS Code extension brings documentation and chat into the editor, where developers can view and edit the IBM i source alongside the generated explanations. See MCP Integration and VS Code Extension.
Enterprise and regulated on-premise deployment
Regulated organizations — banks, insurers, government — often cannot send source code to an external service or run an unvetted database, and may be fully air-gapped.
Afunana fits these constraints without compromise: bring your own external SQL Server instead of the bundled container, terminate TLS at your own managed reverse proxy (nginx, F5, HAProxy) instead of the built-in Caddy, pull images from your internal registry or install fully offline from a tar bundle, and point LLM routing at Azure OpenAI inside your own tenant or at a local Ollama model so that no data ever leaves the network. Everything runs on Docker or Podman on your infrastructure. See System Architecture and Installation.
Where to go next
- System Architecture — how Afunana is built.
- Program Documentation — the documentation it generates.
- AI & Analysis Pipeline — how the analysis works under the hood.