Modernize mission-critical enterprise systemsbetter & faster than ever
Juno pairs TSRI's deterministic modernization engine with generative AI agents and expert oversight. You modernize faster, with higher quality, and can prove every change.
- Deterministic
- Generative
- Fully Traceable
- Human-verified
Engineer-first workspace
Dev Mode: 30 years of modernization expertise supercharged.
An engineer-first workspace where agents call TSRI's built-in skills and tools. Upload source, describe the goal, and Juno sets up the application, agents and plan.
Set up claims-core with 3 agents and a 3-step plan.
- TSRI tool · Application blueprint
- TSRI tool · Readiness report
- TSRI tool · Transformation
- 1.Assess PREMCALC and its dependencies
- 2.Transform to Java 21
- 3.Test against legacy output
TSRI tooling on tap
Skills and product agents give agents hardened TSRI tools. Tools become available as the transformation moves through each stage.
Work the way your team works
Share conversations, and sync tickets with Jira, Azure DevOps and Linear. Assign a ticket to an agent and give final approval yourself.
See everything it did
Tracked code changes, run logs and previews for every conversation.
The platform
Juno understands 100% of your code, architecture & data model.
It documents, transforms, tests and deploys, to get you modern fast and keep you modern forever.
- claims-core · model01
Model the application's architecture, dependencies, data flows and business logic, completely and accurately.
- 02
Convert legacy code, databases, interfaces and architectures into modern, maintainable technology.
- equivalence runPASS
- Unit tests
- Integration tests
- Output comparison vs. legacy
- Traced to source
03Validate functional equivalence through full traceability and comprehensive testing.
Open by design
Connect your code. Choose your cloud.
Modernization shouldn't lock you into someone else's ecosystem. Juno connects directly to your existing source code and delivers modern Java, C# or Python that runs on the clouds, databases and partner platforms you choose.
- You own the modernized code outright
- You control where it runs and how it evolves
- You decide who supports it
Source
- git.example.com/claims-coreConnected
- z/OS · PROD.CLAIMS.COBOLConnected
Target language
Deploy to
Database
Wiki · Knowledge graph · Business rules · Compare
Deep Docs: Comprehensive documentation for the agent age.
Zoom from a system overview to files and functions, down to every decision in the code. Wiki, knowledge graph, business rules and version comparison are linked, for people and agents alike.
Rates policies, posts claims and updates policy records. A nightly batch job refreshes rates.
- 1,740
- Programs
- 2
- Data stores
- 2
- Business rules
Three levels of detail
System overview, then files and major functions, then every decision point (each AND/OR condition) from the blueprints and knowledge graph.
One codebase, four linked views
Wiki, knowledge graph, business rules, and compare. Click any statement to see it in the other views.
Legacy to modern, line by line
Click a COBOL line to jump to the Java that replaced it, and back.
Compare any two versions
Legacy against modern, or last week's release against today's branch, with a full change history.
Business rules you can take with you
Rules are captured in an open standard that business-rule tools can ingest.
Answers you can verify
Juno answers questions about your code from structured data that spans the entire codebase and is fully traceable across all programs.
Built for the agent age. The same documentation that people read is what agents use, so they work from facts instead of re-reading the code.
Application blueprints & business docs
Know your current system. Transform for the future.
Juno builds a precise model of your application, then turns it into blueprints and documentation that map every dependency, data flow and embedded business rule.
See everything. Miss nothing.
Ground truth for generative AI.
LLMs hallucinate without ground truth. Juno provides it: a knowledge graph of your entire application, deterministically mapped before generative AI touches a line of code, so every output traces back to the source.
Knowledge graph example: programs PREMCALC, CLMPOST and POLUPDT connect to data elements, dependencies such as DB2 · CLAIMS, VSAM · POL-MASTER and NIGHTLY-RATE.jcl, and business rules BR-0412 and BR-1180. A highlighted path traces BR-0412 through PREMCALC, CLMPOST, BR-1180 and POLUPDT to POL-ISSUE-DT.
Agentic tooling
Agents, teams, workflows, skills, models & goals.
Build agents, group them into teams and workflows, and wrap them in a goal with acceptance criteria. Schedule automations for repeat work. A configurable run limit keeps every run in bounds.
Agents
Each agent works in its own isolated sandbox. Assign it a ticket and give final approval yourself.
Teams & workflows
Group agents into teams and chain them into workflows. Each workflow step has its own goals.
Skills & memory
Agents call hardened TSRI tools as the transformation moves through each stage. Import your own skills from a zip or tar file.
Models & access
Choose the model profile each workspace uses. Heavy workloads run in the platform under API controls.
Assessments & readiness reports
Know your whole estate before a line changes.
Budgets, timelines and priorities should be set on facts, not assumptions. Juno's assessment delivers a clear readiness report with an accurate scope and a transformation plan.
- Inventory every program, language, database and dependency
- Measure complexity and code quality
- Surface dead code, integration points and risks
| Language | Programs | Lines | Complexity |
|---|---|---|---|
| COBOL | 1,142 | 2.1M | High |
| JCL | 486 | 94K | Low |
| PL/I | 88 | 310K | Medium |
| Assembler | 24 | 41K | High |
- 11%Dead code
- 214Integration points
- 37Risk flags
Transformation & refactoring
Transform your code. Refactor for performance.
A deterministic, rule-based process guided by experienced engineers avoids the hallucinations and rework common with generative-only approaches.
- Clean, object-oriented code built to your standards
- Nested logic simplified, GOTOs eliminated
- Dead code removed
- Unit and integration tests confirm functional equivalence
3100-APPLY-TIER. IF POL-ISSUE-DT < 19980101 GO TO 3100-EXIT. IF RISK-SCORE > 700 MOVE 4 TO RATE-TIER ELSE IF RISK-SCORE > 500 MOVE 3 TO RATE-TIER ELSE MOVE 2 TO RATE-TIER. PERFORM 3200-CALC-PREM. 3100-EXIT. EXIT.void applyTier(Policy policy) { if (policy.issuedBefore(TIER_CUTOFF)) { return; // BR-0412 } policy.setRateTier(tierFor(policy.riskScore())); calculatePremium(policy);}private static int tierFor(int risk) { if (risk > 700) return 4; if (risk > 500) return 3; return 2;}Use the arrow keys to trace each Java line back to its COBOL source.
Data & batch modernization
We modernize everything, not just the code.
Whether your data mapping runs through Syncsort utilities or another ETL pipeline, Juno models the jobs, files and database structures that feed your applications, then migrates them alongside the code, with auditable traceability of exactly what changes and where.
Legacy
- Batch jobsJCL · job streams
- Sort & ETL stepsSyncsort · other ETL
- Files & databasesVSAM · flat files · DB2
- models jobs, files & schemas
- maps every field
- generates migration logic
Modern
- Modern batch & servicesJava · C# · Python
- Relational databasesPostgreSQL · Oracle · SQL Server
- Auditable lineagesource → target, every change
- POL-ID PIC X(10)→policy_id varchar(10) PK
- POL-ISSUE-DT PIC 9(8)→issue_date date
- POL-HOLDER-NM PIC X(40)→holder_name varchar(40)
- POL-PREM-AMT S9(7)V99 COMP-3→premium_amount numeric(9,2)
- POL-STATUS PIC X→status policy_status
- POL-RIDERS OCCURS 5→policy_rider table · FK policy_id
- migrate_policy.sql
- PolicyRepository.java
Data migration
Legacy data, modern structure.
Re-engineer your schema for the cloud without losing what your data means. Juno maps VSAM files, DB2 tables and hierarchical records to a modern relational schema.
- Every field traced from source to target
- Migration logic generated for you
- Data-access code updated to match
Testing & cutover
Go live with complete confidence.
Prove your modernized application works exactly like the original, whether it runs batch jobs, online transactions or anything in between. Juno generates unit and integration tests and compares behavior and outputs against the legacy baseline to demonstrate functional equivalence.
Full traceability pinpoints the source of any discrepancy, so issues are resolved before they reach production.
- Test generation
- Unit
- Integration
- Parallel run
- Cutover