Why we built it
A one-line request reaches across the application
A requirement describes a change someone wants. Before it is built, our engineers need to know where it belongs: the code that implements the behaviour, the rules it must preserve, the components it affects and the decisions it leaves open. We built Cutlass Loom to make that investigation part of how we engineer.
An illustrative request
“Allow customers to cancel an order before dispatch.”
- Which transition counts as dispatch?A state change in the code
- Where is cancellation eligibility checked?A rule the code enforces
- Who releases reserved stock?A responsibility between components
- What happens if cancellation succeeds but a refund fails?A decision for our engineers
How it works
Knowledge built from the code, put to work three ways
We index the application’s source with Cutlass Loom, check what it finds against the code, and put the result to work through its two components, ATLAS and SCRIBE, and an MCP layer for our coding agents.
Source
The application’s code
Its repositories, indexed at a recorded revision
Shared foundation
Each claim’s evidence checked before it is supplied as fact
ATLAS
Explains the application
Source-linked documentation from the product down to modules, files and journeys, with the rules, roles and data behind them.
SCRIBE
Specifies the change
A business brief researched against the code into a product requirements document (PRD): what exists, what to extend, what is new, with one decision record for what is still open.
MCP layer
Guides the engineering
Our engineers and coding agents query it through the Model Context Protocol as they plan, build, test and review, and get cited evidence back, whether the work changes the application or builds on it.
As the code changes. Every finding keeps its revision. We re-index the source, ATLAS publishes a new account, and SCRIBE re-grounds a PRD to show how its evidence moved or rebases it into a new version.
What keeps it dependable
Every answer keeps its evidence, and its limits
Compilers, code indexes and language servers establish what is in the code. Language models investigate and write, and what they state is checked against that evidence.
Every statement shows what it rests on
Each finding’s evidence is checked before it is supplied as fact, and keeps its location, the code revision and whatever could not be confirmed, so our engineers can trace what a statement rests on.
SupportedInferredOpen questionSource locationCode revisionWhat was not confirmedAbsence is claimed only as far as the search reached
Only an exhaustive search of the code it covered can show that something is absent there; a search that simply found no match leaves an open question. Its coverage and unresolved areas travel with the answer, so a plan does not quietly inherit an assumption of absence.
Fuller analysisLess establishedUnresolvedEvery account is challenged
Separate reviewers test ATLAS’s documentation along six lines of challenge, and a criticism counts only when it cites its rule and quotes its evidence. Every PRD from SCRIBE faces three examinations of its own.
ATLASAccuracyHonestyCoverageConsistencyClaritySensitivitySCRIBEClaimsBrief coverageClear and testableOur engineers settle what the code cannot
Questions the code can answer go back to investigation. Questions of policy, priority and intent go to our engineers, recorded with their evidence and alternatives, and no proposal changes the specification without an engineer’s approval.
A question the code can answerBack to investigationA question of policy or intentOur engineers decide
Where it began
Contributing to an unfamiliar codebase in just over two weeks
An enterprise education-technology customer needed to change engineering partners, and we had thirty days to show we were ready to take on a complex application spread across multiple repositories. We mapped its code’s structure and relationships and made that context available to our coding agents through queryable tools, the work that laid the foundations of Cutlass Loom. In just over two weeks we understood enough to begin contributing.
Read the story
Cutlass
Our Agentic Toolkit
Agentic tools we built to understand, change, test, secure and diagnose the software we take on. Our engineers adapt each one to the engagement.
- Cutlass Loom Understanding the application This page
- Cutlass Forge Carrying out large changes
- Cutlass TestGlide Testing user journeys and APIs
- Cutlass Shield Proving security findings
- Cutlass Synops Tracing outages back to code


