Legacy code goes in.
A canonical semantic form comes out.
Verified modern systems are generated from it.
CodeIntent® does not modernize by guessing at the next line of code. It decomposes supported legacy source into a canonical semantic form — the CodeIntent® — then uses that form to generate modern target code, documentation, and verification artifacts with deterministic traceability back to the original system.
The operating sequence. From source to verified target.
This is the practical answer to "what happens to my code?" Source enters on the left, a canonical artifact is constructed in the middle, and verified target code emerges on the right. The same loop also produces documentation, traceability, and review records.
Parse
Source is decomposed by language-specific accelerators — rule-based assets that encode the semantics of each supported language. Accelerators are permanent: built once per language, applied to every engagement, sharpened as new dialects are encountered. The decomposition is reversible; every intermediate step is inspectable.
Construct
The decomposed source is unified into the CodeIntent® — the program's canonical form. Syntactic specifics are abstracted away; the program's behavioral content is captured in full. Same source → same CodeIntent®, deterministically.
Generate
Target code is constructed as a projection of the CodeIntent® onto a target-language model. Style and idiom matter: target code matches the conventions of engineers writing in the target language, not transliterated source. Different targets are different projections of the same CodeIntent®.
Verify
The generated target is re-projected back to the CodeIntent®. If the re-derived form matches the original, equivalence is established. Verify is built into the pipeline, not a separate quality-check layer. Divergence is detected before output is considered shippable.
When intent cannot be derived, we stop locally.
This is the trust mechanism. Some behavior depends on unavailable hardware, compiler-specific quirks, missing runtime state, or business rules not actually represented in the source. CodeIntent® does not fill those gaps probabilistically.
This is structural, not policy. There is no confidence threshold and no fallback to probabilistic completion. Either the CodeIntent® can be constructed cleanly for a given source construct or it cannot.
When it cannot, the construct is isolated, presented to a reviewer with full source location and analysis context, and the rest of the pipeline continues unaffected. A domain expert resolves the ambiguity once. The resolution becomes part of the engagement's permanent record and informs future runs.
The same property handles intentional variance: when the target state deliberately changes behavior — modernized data model, new operational assumption — the change is captured as an approved deviation rather than a silent rewrite.
# Intent Review Record · auto-generated legacy_artifact: PAYMENT_SETTLEMENT_042 source_location: cobol/settlement/proc_042.cbl:218 source_construct: platform-specific retry branch status: intent_not_derivable reason: Required behavior depends on runtime state not represented in the source artifact set. Cannot be resolved from available context. review_options: - preserve_retry_semantics - replace_with_target_policy - mark_as_intentional_variance pipeline_state: construct: quarantined downstream: blocked_for_this_path other_paths: continuing resolved_by: (awaiting human review)
Explicit failure is what makes audit-grade conversion possible. Every construct in the source was either converted with deterministic equivalence or escalated for human resolution. There is no third category of silently converted, may or may not be correct.
The canonical form underneath the pipeline. One source of truth.
The pipeline works because the system is not translating syntax directly into syntax. It is constructing a language-agnostic semantic artifact first. The right intuition is a hologram, not a photograph: one captured form, many reconstructable views.
The CodeIntent® is not a graph, an embedding, an index, or an LLM. The mathematics sits between rule-based expert systems and probabilistic models — it has the expressive coverage of a rule system without the brittleness, and the generality of a probabilistic model without the non-determinism. The internal representation is proprietary. The property is the public claim, and it is what the rest of this page depends on.
Within supported languages and execution models, equivalent behavior normalizes into the same canonical semantic representation. Given the same CodeIntent® and the same target-language conventions, generation produces the same target code. All generated output carries a chain of proof back to the canonical form, and through it to the originating source construct. The conversion is reproducible, verifiable, and audit-traceable by construction.
The same business logic, expressed in three source languages, produces the same
CodeIntent®. From that single form, target code can be reconstructed in any
supported language.
Same semantics → same form. Same form → any view.
Reproducible
Same source produces the same CodeIntent®. Same CodeIntent® produces the same target. The full conversion is deterministic by construction — not by discipline, not by tuning.
Projectable
Any specific output is a projection of the CodeIntent® onto a target view: code in any supported language, structural documentation, behavioral specifications. The canonical form is unchanged across all of them.
Traceable
Every byte of generated output carries a chain of proof back to the canonical form and through it to the originating source construct. Audit reviewers see the actual transformation path, not an inferred reconstruction of it.
See it on your code.
Technical deep-dives are run by Holonic engineering on a representative section of your codebase. 60 minutes, under NDA, with your architects in the room. We show the pipeline, the review mechanics, and how deterministic traceability would apply to your environment.