CASE STUDIES

Problems we have solved with our customers.

Thirteen PoCs we have run, on code security and on performance and compute. See whether one looks like yours.

01 / 4 cases

Code security

What we have deliveredVulnerability-detection engines, source audit tools, an agent that analyzes binaries, and detection models trained on the customer’s own data. They can sit in your development flow or run in your own environment. Related product:Coding agents · code review and security

01 / Automatic vulnerability scanning in development

A telecom operator’s cloud

Vulnerability scanning built into the development flow.

Engagement
PoC
Stage
Completed
Runs on
The customer’s existing development flow (commit, merge, release)
Tech
Static analysis · symbolic execution · deep learning · dependency CVEs
The problem
They wanted vulnerabilities, including high-severity CVEs in dependencies, caught automatically at commit and merge, without setting up another system.
What we delivered
A vulnerability-detection engine at the commit and merge steps, combining static analysis, symbolic execution and deep learning.

Effect

  • About 50%lower false-positive rate

About half the false alarms are gone, so the security team no longer wades through alerts and can spend its time on real vulnerabilities.

How we did it

What we did

  1. 01The flow: enterprise code → commit / merge → automatic vulnerability scan → release
  2. 02The detection engine: static analysis + symbolic execution + deep learning
  3. 03Flags high- and medium-severity CVEs in dependencies and supports fixing them

Talk to us if this sounds familiar

  • Your pipeline already has a scanner, but nobody reads it any more because of the false alarms
  • You depend on many third-party libraries and want to know which high-severity CVEs really affect you
  • You want vulnerability checks added without replacing your CI
Book a PoC like this

02 / Java application security audit

A leading content platform

Finding critical vulnerabilities in Java code, automatically.

Engagement
PoC
Stage
Completed
Tech
Java · data-flow tracking · call chains completed by a large model
The problem
They needed to audit the source of their Java services for injection flaws that let an attacker run code.
What we delivered
A Java source audit tool. It tracks data flow, uses a large model to complete call chains, then checks whether an input can trigger command execution.

Effect

  • 77.9%of vulnerabilities detected
  • 24new remote code execution vulnerabilities
  • 130applications reviewed before launch as a result

All 24 new findings are remote code execution vulnerabilities, the most dangerous kind: an attacker could run any code on the server.

How we did it

The need

  • Audit Java service source code for inputs that can trigger code execution

What we did

  1. 01Track the data flow
  2. 02Complete the call chains with a large model
  3. 03Check whether an input can trigger command execution

Delivered

  • A Java source audit tool
  • A completed Java vulnerability-detection evaluation

Talk to us if this sounds familiar

  • Your back end is mostly Java and has to pass a security audit before launch
  • You worry about injection and deserialization flaws that lead straight to code execution
  • You have many applications, few security staff, and can’t audit them all by hand
Book a PoC like this

03 / Vulnerabilities and backdoors in stripped binaries

A leading internet company

Automated binary analysis to locate vulnerabilities and backdoors.

Engagement
PoC
Stage
Completed
Tech
Stripped binaries · reverse-engineering tools · agents
The problem
They had binaries to audit, with no source and not even function names. Manual reverse engineering was too slow, and they needed vulnerabilities and backdoors found fast, with evidence.
What we delivered
BinReX, an agent that analyzes binaries. It calls reverse-engineering tools itself, fixes its own mistakes and hands the evidence to an engineer to check.

Effect

  • Total analysis time87.9 hours (OpenAI Codex with IDA)36.1 hours (BinReX)
  • Task success rate43.1% (OpenAI Codex with IDA)83.3% (BinReX)
  • 83.3%task success rate
  • −58.9%total analysis time

Analysis takes less than half the time, succeeds almost twice as often as the baseline, and every finding comes with evidence.

72 tasks across 7 kinds of scenario.

How we did it

The need

  • No source code and no function names: manual reverse engineering takes a long time
  • Vulnerabilities and backdoors have to be located quickly, with evidence

What we did

  1. 01Similar-function search narrows down the location
  2. 02An agent breaks the task down
  3. 03It calls reverse-engineering tools and corrects its own mistakes
  4. 04It returns the evidence for engineers to review

Delivered

  • BinReX, an automated analysis tool

Talk to us if this sounds familiar

  • You have to audit third-party SDKs, firmware or closed components without the source
  • You suspect a backdoor and need evidence
  • Only a few experts can do reverse engineering, and the queue is long
Book a PoC like this

04 / Vulnerability detection and app acceleration on devices

A device operating-system vendor

A vulnerability-detection model trained on its own data, and faster device apps.

Engagement
PoC, with the model developed with the University of Leeds
Stage
Completed
Runs on
Inside the customer’s system, deployed at system level with real-time detection
Tech
Closed-source repositories · security data · vulnerability-detection model
The problem
They had a lot of closed-source code and security data, and wanted to train their own vulnerability-detection model on it and deploy it in their system. They also wanted device apps to run faster.
What we delivered
A vulnerability-detection model developed with the University of Leeds, deployed at system level for real-time detection.

Effect

  • ≥200Ksecurity data records curated
  • >80%detection accuracy in the target scenarios
  • >20projects with vulnerabilities found
  • 150%code speedup

The model was trained on the customer’s own data and runs in its own system. Beyond finding vulnerabilities, app code reached a 150% speedup.

How we did it

What we did

  1. 01Data: security data curated from closed-source repositories
  2. 02Model: vulnerability-detection models and algorithms, developed with the University of Leeds
  3. 03Deployment: system-level deployment with real-time detection

Talk to us if this sounds familiar

  • You have plenty of your own code and security data and want a detection model just for you
  • Code and data cannot leave the company
  • You need vulnerabilities found and device apps running faster
Book a PoC like this

02 / 7 cases

Performance and compute

What we have deliveredCode and compiler optimization, training memory optimization, big.LITTLE scheduling and cluster scheduling, delivered as patches, tools, schedulers or a model running on your own premises. Related product:Deployment and optimization · heterogeneous compute

05 / On-premises code optimization with a 13B model

An AI code-optimization company

A 13B model on-premises, optimizing enterprise code.

Engagement
PoC
Stage
Completed
Runs on
On the company’s premises, on its own hardware
Tech
13B model · sub-task fine-tuning · statistical evaluation
The problem
They wanted a large model to optimize their code, deployed on their own machines.
What we delivered
A 13B code-optimization model, fine-tuned for their tasks and running on their own hardware.

Effect

  • 50%lower labour cost
  • 110–180%code speedup

Half the labour cost of optimizing code, a code speedup of 110% to 180%, and the model never left the customer’s machines.

How we did it

What we did

  1. 01Enterprise code and optimization tasks
  2. 02A 13B model, fine-tuned for sub-tasks
  3. 03Statistical evaluation and multi-expert analysis
  4. 04Deployed on the company’s own hardware

Talk to us if this sounds familiar

  • You want a large model to optimize code but cannot use an outside cloud model
  • You have your own compute and want the model to run on it
  • Code optimization is done by hand by senior engineers, at a high cost
Book a PoC like this

06 / Memory optimization for training billion-parameter models

A leading e-commerce and cloud company

Training a 39.5-billion-parameter model on one GPU.

Engagement
Joint development
Stage
In the customer’s production environment
Runs on
The customer’s production training environment
Tech
32 GB V100 · 8 A10 GPUs · against Megatron-LM, ZeRO-Offload / L2L
The problem
They wanted to train larger models on GPUs with limited memory.
What we delivered
A training memory optimization, developed with the customer, that needs no change to training code and is in use in their production environment.

Effect

  • Largest model on one 32 GB V1006B (mainstream offloading)39.5B
  • 39.5Bparameters trainable on one 32 GB V100
  • 6.5×the model size of mainstream offloading (6B)
  • 1.2–3.7×higher training throughput
  • 82.1Bparameters trainable on 8 A10 GPUs

The same card trains a model more than six times larger, without touching a line of training code.

How we did it

What we did

  1. 01A training memory optimization developed jointly with the customer
  2. 02No changes to the user’s training code

Talk to us if this sounds familiar

  • GPU memory limits the size of model you can train
  • You don’t want to rewrite training code to save memory
  • You want to train large models on fewer or cheaper cards
Book a PoC like this

07 / big.LITTLE core scheduling

A global chip-design company

Big or little cores chosen by workload: 63.5% less energy.

Engagement
PoC
Stage
Completed
Runs on
big.LITTLE mobile chips, at run time
Tech
big.LITTLE scheduling · offline learning · compiler optimization
The problem
Big cores are for speed and little cores for saving power, but the scheduler kept putting tasks on the wrong ones, making them slow and power-hungry.
What we delivered
Run-time selection of big or little cores. It learns how each workload behaves offline, then tunes for speed or for energy.

Effect

  • 63.5%less energy
  • 45%shorter load time
  • 81%better energy-delay product

Pages load faster on over 60% less energy. The energy-delay product counts speed and power together, and it improved by 81%: neither was traded away.

Measured on 500 popular web pages, against the Linux default scheduler.

How we did it

What we did

  1. 01Learn workload features offline
  2. 02Choose big or little cores automatically at run time
  3. 03Tune for speed or for energy

Talk to us if this sounds familiar

  • Your chips have performance and efficiency cores, and tasks land on the wrong ones
  • You build phones or embedded devices that need both speed and battery life
  • The default scheduler doesn’t know your workloads
Book a PoC like this

08 / Reinforcement-learning compiler autotuning

A global technology company

Reinforcement-learning autotuning: 1.75× faster search at deployment.

Engagement
Joint research, published at CC 2022
Stage
Completed
Tech
Reinforcement learning · Halide · TVM · LLVM · STOKE
The problem
They wanted image processing, neural-network code and compiled programs to run faster and be smaller, without the tuning search taking too long.
What we delivered
An autotuning framework based on reinforcement learning, from joint research published at CC 2022.

Effect

  • 1.75×faster search at deployment, on average
  • >11×Halide image pipelines, on some benchmarks against the default scheduler
  • 1.74×TVM neural-network code, against the default schedule
  • 1.57×LLVM code size, against -Oz, best on 90% of benchmarks

The same method beat the defaults on all three kinds of code.

Against 8 autotuning frameworks, search was up to 100× faster.

Talk to us if this sounds familiar

  • Your compiler or deep-learning framework has too many settings to tune by hand
  • You need code that is both fast and small
  • Autotuning searches too slowly for your release schedule
Book a PoC like this

09 / Hot-spot GPU operator optimizationIn progress

A domestic GPU maker

Agents optimizing domestic GPU operators, tested on a real inference workload.

Engagement
Joint PoC
Stage
In progress
Runs on
A domestic GPU, one real inference workload
Tech
Domestic GPU · hot-spot operators · correctness tests · agents
The problem
They want to see whether an agent can optimize the hot-spot operators on a domestic GPU in a real inference workload, measured against a baseline both sides confirm.
What we delivered
Reproducible code patches, an automated verification flow and a performance report.

Targets

  • 20%+faster hot-spot operators, on average
  • 10%+higher end-to-end throughput
  • 30%+less manual optimization work

The aim is for an agent to do the operator tuning, with results that can be reproduced and verified, so engineers spend far less time tuning by hand.

Still under way: the figures above are the targets agreed with the customer.

How we did it

What we did

  1. 01Pick the workload: one real inference scenario
  2. 02Pick the operators: 3–5 kinds of hot-spot operator
  3. 03Keep it correct: pass the correctness tests first
  4. 04Optimize: an agent optimizes automatically

Delivered

  • Reproducible code patches
  • An automated verification flow
  • A performance report

Talk to us if this sounds familiar

  • Inference is slower than expected after moving to a domestic GPU
  • Only a few engineers who know the hardware can tune operators
  • You need reproducible patches and a performance report, not just a verdict
Book a PoC like this

10 / Compiler optimization for heterogeneous architecturesIn progress

A telecom-equipment research lab

Unlocking the performance of big.LITTLE architectures.

Engagement
PoC
Stage
In progress
Runs on
ARM big.LITTLE architectures
Tech
LLVM · active learning · evolutionary search · multi-version code generation
The problem
One compiler configuration can’t suit every chip, and with so many parameter combinations, tuning by hand is expensive. When performance suffers, it’s hard to tell whether the hardware design or the compiler strategy is to blame.
What we delivered
A tuning tool, a compiler-strategy prediction model and a hardware–software co-optimization prototype, all built on LLVM.

Targets

  • +20%average program performance, against the default configuration
  • −50%manual tuning cost
  • 2×tuning efficiency

The aim is to hand most of the tuning to automated search and prediction, and to tell whether a bottleneck is in the hardware or the compiler.

Still under way: the figures above are the targets agreed with the customer.

How we did it

The need

  • One configuration cannot suit every chip
  • A huge space of parameters makes manual tuning expensive
  • It is hard to tell whether a bottleneck comes from the hardware design or the compiler strategy

What we did

  1. 01Search for optimal configurations automatically: active learning and evolutionary search, with fewer dead ends
  2. 02Predict compiler strategy from the code: learn how code relates to configuration and recommend parameters directly
  3. 03Hardware–software co-optimization: model the hardware’s influence and generate several versions of the code

Delivered

  • A tuning tool and a compiler-strategy prediction model
  • A hardware–software co-optimization prototype

Talk to us if this sounds familiar

  • One compiler configuration has to suit several chips
  • Compiler flags are found by trial and error
  • When performance drops, you can’t tell whether it is the hardware or the compiler
Book a PoC like this

11 / Dynamic cluster schedulingIn progress

A domestic processor maker

A password-recovery cluster on domestic accelerators, with no idle cards and no long tail.

Engagement
PoC
Stage
In progress
Runs on
A cluster of domestic accelerators
Tech
Hashcat · keyspace splitting · heterogeneous scheduling · failover
The problem
When authorized password recovery (Hashcat) moved from one machine to a cluster of domestic accelerators, the old static splitting couldn’t keep up: some cards sat idle while the last few blocks dragged on.
What we delivered
A cluster scheduling and fault-tolerance scheme that splits work by live compute, assigns it by node status and takes over failed nodes automatically.

Targets

  • ≥90%cluster compute utilization
  • −30%tail completion time
  • < 1 minto take over a failed node
  • ≈ 0repeated work and conflicts

The aim is for every card to stay busy, for the last few blocks to stop holding the job up, and for failed nodes to need no one’s attention.

Still under way: the figures above are the targets agreed with the customer.

How we did it

The need

  • Static benchmarks and keyspace splits cannot keep up with a changing cluster
  • Run times vary, nodes differ, status lags and nodes fail
  • The result: idle devices, a long tail and conflicts over which node owns a task

What we did

  1. 01Dynamic keyspace splitting: live compute measurements replace static benchmarks, and blocks follow each node’s capacity
  2. 02Heterogeneity-aware scheduling: tasks go by each node’s compute and status, cutting idle time and the long tail
  3. 03Fault tolerance and de-duplication: failed nodes are taken over automatically, with no repeated work or ownership conflicts

Talk to us if this sounds familiar

  • You are scaling a single-machine job to a multi-card, multi-node cluster
  • Your cluster mixes cards of different models and speeds
  • Long jobs are often held up by one or two slow or failed nodes
Book a PoC like this

03 / 2 cases

Platform integration

What we have deliveredWe plug into the steps your platform already has, without replacing any system, and code and models stay in the environment you choose. Related product:Coding agents · links to your repositories and tools

12 / Code security and compute utilization

A cloud and data-centre provider

Security and compute optimization across three platforms.

Engagement
PoC
Stage
Completed
Runs on
The customer’s MLOps platform, HPCaaS compute platform and AICC compute centre
Tech
Vulnerability detection · compiler optimization · multi-backend support · heterogeneous scheduling
The problem
They wanted safer code on their platforms, and to get more out of their compute at a lower cost.
What we delivered
Three capabilities, one in each of the customer’s MLOps platform, HPCaaS compute platform and AICC compute centre.

Effect

  • 80%+vulnerability detection accuracy (MLOps platform)
  • −30%compute used, and −20% energy per task (HPCaaS platform)
  • −20%compute cost, from heterogeneous scheduling (AICC centre)

The code on the platforms is safer, and the same jobs use less compute and less power.

How we did it

What we did

  1. 01MLOps development platform: vulnerability detection in source code and dependencies
  2. 02HPCaaS compute platform: code and compiler performance optimization
  3. 03AICC compute centre: multi-backend support and hot-spot analysis

Talk to us if this sounds familiar

  • You run a compute centre or AI platform and want to offer its users code security and optimization
  • Your platform has several chip back ends to support
  • Compute is expensive and you want higher utilization
Book a PoC like this

13 / Integration across the development pipeline

A code-hosting platform

AI checks at every step from coding to release.

Engagement
PoC
Stage
Completed
Runs on
A designated environment, at the existing development steps
Tech
IDE · commit / merge · CI · approval · release and rollback
The problem
They wanted AI across the whole development process without replacing existing systems, and with code and models kept in a designated environment.
What we delivered
Five integration points: scans in the IDE while coding, vulnerability and performance analysis at commit, reports in CI, review at approval, and rollback at release.

Effect

  • 5development steps covered, from coding to release

Every step from coding to release has checks, findings are reviewed before anything ships, and code and models never leave the designated environment.

How we did it

What we did

  1. 01Coding: lightweight scans in the IDE
  2. 02Commit / merge: vulnerability and performance analysis
  3. 03Continuous integration: compliance and compatibility reports
  4. 04Verification / approval: results checked and reviewed
  5. 05Continuous delivery: releases and rollbacks

Delivered

  • A controlled boundary: enterprise code and models stay in a designated environment, with approval for identities, keys and tools
  • Controlled iteration: execution records → evaluation sets → optimization suggestions → release after verification

Talk to us if this sounds familiar

  • You run a code-hosting or development platform and want to offer AI code checks
  • Code and models must stay in a designated environment
  • You want AI findings reviewed by a person before release
Book a PoC like this

Next step

Want to try it on your own chips?

Book a PoC