Most firms use LLMs to guess what your code does. We treat AI as a component, not the whole solution — bounded by formal logic, validated by the compiler, and honest about what it doesn't know. Intelligence, not probability.
Careers at the architecture, solution-design, and integration level — across financial services, insurance, and government.
Structural engineering of AI systems: neuro-symbolic architectures, RLCF, and compiler-verified generation. Not consumer demos.
A deterministic foundation under every AI output — so your governance, audit, and compliance teams get artifacts that hold up to review.
The AI vendors don't really know IBM i. The IBM i specialists aren't building with AI. We've spent careers in IBM i at the architecture and solution-design level — and we went deep into AI specifically to understand how these two worlds actually fit together.
Neuro-symbolic architectures, agent design, formal guardrails, compiler-verified generation. We did the work because our clients' systems are the ones where AI failure isn't acceptable. When your team is trying to figure out which of the hundred things launching each month is worth paying attention to — and how any of it applies to a platform the LLM vendors don't speak — we can help them separate signal from noise.
Platform architecture. High-availability design. Integration strategy. The constraints of systems that can't afford to be wrong.
Applied work in the techniques that make AI safe to run in enterprise environments — not the consumer demos.
We spent the last year going deep into the structural engineering of these models — not just to see if they could write code, but to see if they could actually reason through 40-year-old RPG and COBOL. What we found is that you can't just "prompt" your way through a monolith. We had to build a compiler-driven feedback loop where the AI is forced to prove its logic against a formal Haskell-based validator. It's a self-correcting approach that fundamentally changes the "un-weaving" process from a manual developer slog into a high-fidelity, automated engine. It allows us to treat the IBM i core as an intelligent service rather than just a legacy database.
Every few months, new "AI-powered" modernization tools appear — each promising to transform your legacy codebase with minimal risk and maximum speed. Most of them are Surface AI: an LLM asked to guess what 40-year-old RPG and COBOL does, wrapped in a demo. In mission-critical IBM i environments, that produces silent failures — code that compiles but quietly means the wrong thing.
Excessive manual effort. Struggle with complex legacy. Slow, brittle, specialist-heavy.
Models guess semantics, invent variable names, drop fields, and produce code that compiles but quietly fails — the definition of a silent failure.
The developers who built your RPG and COBOL are leaving. The logic lives in their heads — not in documentation.
Surface AI optimizes for probability: the most likely answer. Deep AI engineers for intelligence: a provable one. The difference isn't a better prompt — it's a different architecture. One where AI is a component inside a system of formal guardrails, not the whole solution.
Two pillars separate Deep AI from Surface AI: a mathematical guardrail that bounds what the model can do, and a self-correction loop that removes humans from the quality-control critical path. The output isn't code the AI thinks is right — it's code the compiler has proven is right.
Haskell · Formal symbolic logic · Abstract Syntax Trees
Before the AI ever touches your code, a Haskell-based validator builds a rigid map of your RPG and COBOL using formal symbolic logic. Control flow, data structures, and dependencies are captured exactly. Anything that can't be resolved with certainty is flagged as Unknown — not guessed.
Reinforcement Learning from Compiler Feedback
We don't rely on human review to catch AI mistakes. The compiler judges every output; if compilation fails, the error is fed back to the model until the code is syntactically and logically perfect. Quality control is automated, not outsourced to a reviewer hoping to spot a silent failure.
We aren't just "modernizing" your application — we're injecting intelligence into the core. The mathematical guardrail extracts Semantic Intent: the meaning of your business rules, not just RPG-to-Java syntax. That makes your legacy logic readable and actionable for the next generation of AI agents. The IBM i stops being a database to query and becomes an intelligent service to reason with.
The Mathematical Guardrail and the Self-Correction Loop, implemented end-to-end. Symbolic layers bookend the neural layers: the Deterministic Foundation enters first, RLCF closes the loop. It's the engine behind audits, API work, and agent foundations — built for systems where a silent failure is not an acceptable outcome.
A Haskell parser reads your RPG and COBOL into a structured map of the program — an Abstract Syntax Tree. Known logic (control flow, data structures, dependencies) is captured deterministically. Anything that can't be resolved with certainty is flagged as Unknown, not guessed.
A solid, deterministic foundation before any AI is allowed near the code. No "garbage in, garbage out."
A small, fine-tuned model looks only at what was flagged. It reads intent — naming conventions, UI cues, structural patterns — to resolve ambiguity deliberately. The kind of decision-making that usually needs a developer to review line-by-line.
Automates the judgment calls that normally depend on a specialist who's been in the code for years — and may be close to retiring.
Once the code is fully understood and tagged, an LLM generates whatever the engagement calls for — an API endpoint, a tool signature for an agent, a refactored module, or modern equivalent code. The LLM is working against a strict specification, not improvising.
LLM speed and syntax fluency, applied only after the logic is strictly defined. Errors drop, variables are preserved.
The compiler judges every output. If compilation fails, the error is fed back to the model for self-correction — reinforcement learning from compiler feedback (RLCF). The loop runs until the output is syntactically correct and every original variable is accounted for.
Automated self-healing. Final deliverables are complete and compile — not "probably correct."
A Haskell-based formal validator orchestrates the workflow. We start with math, not guesses.
We don't just translate syntax — we extract the meaning of your business rules so the logic is portable, auditable, and agent-ready.
Reinforcement Learning from Compiler Feedback. The system corrects itself until output is syntactically and logically perfect.
Take them independently, or in sequence. The right starting point depends on where your team is today and where the pressure's coming from.
We run the Mathematical Guardrail over your RPG and COBOL to surface the Semantic Intent of your programs — the actual meaning of the business rules, not just their syntax. Then we identify where AI would deliver practical value (claims review, pricing analysis, customer-service summarization, risk scoring) and where it wouldn't. You leave with a prioritized plan your team can act on.
APIs built without subject-matter experts in the room — because the Deterministic Foundation already has the logic captured. Your RPG and COBOL runs as it always has; we wrap it in an Agent-Ready layer with AI on the response, so modern applications receive finished insights instead of raw rows. The institutional knowledge lives in the API, not in a few peoples' heads.
We build the Agent-Ready Core: your IBM i structured as a reliable foundation for enterprise AI agents. RLCF-validated tools. Formal guardrails preventing hallucination in production. The IBM i stops being a system of record and becomes an intelligent service your agents can reason with — governed by your team, not a vendor.
Your business rules extracted and exposed at the meaning level — not just syntax. No longer trapped inside green-screen layers or a shrinking pool of specialists' heads.
RLCF-validated. Variable-accurate. Formally constrained. Your governance and audit teams get artifacts that hold up to review — no silent failures.
The logic encoded in your IBM i is captured, documented, and exposed as code — not as tribal knowledge that leaves when a senior developer does.
Your IBM i becomes something the next generation of AI agents can actually reason with — an intelligent service, not a legacy database. The foundation is ready when you are.
Share a bit about your environment and the problems you're trying to solve. We'll come back with a candid view of what's realistic and where we'd focus. No obligation, no sales process.