INDEPENDENT R&D / SOFTWARE / AI / SECURITY

Build for reality.
Test beyond the happy path.
Follow the evidence.

Ghost Labs designs and builds custom software and AI systems, Solidity and EVM applications, and specialist tools for rigorous testing and technical research. We take on problems from architecture through implementation—and help teams understand how their systems behave when conditions get complicated.

DESIGN WITH INTENTBUILD FOR REALITYVALIDATE WITH EVIDENCE
SYSTEMS IN MOTION / GHOST LABS LIVE ARCHITECTURE
Ghost Labs systems in motion An animated systems constellation connecting software engineering, applied AI, EVM engineering, and security research through a central research and engineering core. CORE / GL GHOST LABSRESEARCH → ENGINEERING 01 / BUILDSoftware systemsBACKEND · APIS · PRODUCTS 02 / APPLYAI systemsMODELS · WORKFLOWS 03 / EXECUTEEVM engineeringSOLIDITY · TOOLING 04 / VALIDATESecurity researchTESTS · TRACE · EVIDENCE
THE LOOPdesign → build → test → learn
SOFTWARE · AI · EVM · SECURITY● SIGNALS CONNECTED
Custom Software/AI Systems/EVM Engineering/Security Research/Developer Tools

Independent R&D studio

Independent by design.
Evidence-led by habit.

Ghost Labs works across product engineering, applied AI, blockchain systems, and security research. We turn ambiguous technical goals into architectures, implementations, and tools that fit the real environment—not just a convincing demo.

Some engagements need a complete application; others need a stateful contract failure reproduced, a complex execution trace explained, or compiler behaviour made measurable. We start with the uncertainty that matters, then choose methods that can produce useful, inspectable evidence.

Alongside client work, we build our own engineering technology—from EVMTraceX, our execution-trace explorer, to STATEHOUND, our stateful EVM fuzzing and research engine. Our internal R&D also explores complete AI workflows, reproducible transaction analysis, and compiler-level performance evidence.

See how we work

What we build

Engineering across
the full system lifecycle.

Product engineering, applied AI, blockchain systems and deep technical investigation—combined to fit the actual problem, not forced into a fixed package.

01 BUILD

Custom Software & Product Engineering

Engineering the product behind the idea.

We design and deliver software around the way a product actually operates: backend services, APIs, integrations, internal platforms, automation and complete application workflows. Architecture, data contracts, observability, deployment constraints and maintainability are part of the delivery—not an afterthought.

PRODUCT ENGINEERING · BACKEND & API SYSTEMS · INTEGRATIONS · AUTOMATION
02 APPLY

AI Systems & AI Product Development

AI products engineered beyond the API call.

We do more than connect a model to an existing app. We can build the AI system around a use case from the ground up: application logic, data pipelines, custom model or agent components where the scope calls for them, orchestration, evaluation loops, APIs, interfaces, asynchronous jobs, and controls that make the workflow dependable. Existing models and providers are options—not the entire solution.

CUSTOM AI SYSTEMS · MODEL ORCHESTRATION · EVALUATION PIPELINES · AI PRODUCTS
03 ENGINEER

Solidity, Smart Contracts & EVM

Contracts, integrations and execution-level tooling.

We work where contract logic meets protocol state and production tooling. Scope may include Solidity implementation, EVM application architecture, blockchain integrations, debugging multi-contract calls, storage-change analysis, and execution-aware developer utilities. The focus is on how components interact across callers, dependencies, state, and deployment assumptions.

SOLIDITY · EVM APPLICATIONS · EXECUTION ANALYSIS · BLOCKCHAIN INTEGRATION
04 INVESTIGATE

Smart Contract Security & Web3 Research

Focused reviews backed by adversarial testing.

We examine the security properties of smart contracts through scoped manual review and adversarial testing: permissions, trust boundaries, upgrade paths, external calls, state transitions, and economic assumptions. Findings are tied to observable behaviour and practical remediation guidance, with the scope and limitations made explicit.

SMART CONTRACT REVIEW · THREAT MODELING · STATEFUL FUZZING · REMEDIATION
05 VALIDATE

Verification, Developer Tools & R&D

Tools that make complex behaviour observable.

We build test infrastructure and developer tools for problems where conventional tests provide limited coverage. Our work includes purpose-built fuzzing engines, execution-trace analysis, reproducible test generation, compiler-optimization evidence, and low-level systems research. The objective is an answer engineers can inspect, reproduce, and act on—not another layer of guesswork.

AUTOMATED TESTING · FUZZING · TRACE ANALYSIS · COMPILER INTELLIGENCE · R&D TOOLS

Security R&D / Stateful EVM Research

EXPLORE THE STATE.
LEARN THE BEHAVIOUR.

SMART CONTRACT SECURITY / ADAPTIVE FUZZING

Find behaviour
the test suite never described.

Smart-contract behaviour is shaped by sequences, callers and evolving state. A contract can pass isolated tests while a less obvious combination of interactions exposes a behaviour its developers never anticipated. STATEHOUND is built to explore that space.

Our in-house EVM research engine combines stateful sequence exploration with a multi-model learning architecture: PPO, Actor–Critic, ICM, RND, CPC, World Model and MCTS. These components bring together adaptive policy learning, curiosity-driven state-transition learning, behavioural novelty, temporal representations and model-guided planning.

Give STATEHOUND a contract and its execution environment. The engine discovers the callable interface and explores without requiring manually written target-specific invariants, a hand-picked selector list or a reference exploit trace. It searches execution and state behaviour for implicit invariants and relationships that were never explicitly described in the test setup.

Research can start from a local deployment or a pinned blockchain state. STATEHOUND can preserve interesting sequences for POC and replay workflows, including Foundry-oriented reproduction. The engine is proprietary Ghost Labs technology, presented through private demonstrations and selected research engagements.

↳Multi-model reinforcement learningPPO, Actor–Critic, ICM, RND and CPC, supported by predictive exploration and planning.
↳Autonomous stateful explorationAutomatic interface discovery, generated sequences and search beyond manually specified target properties.
↳POC-oriented research workflowPreserve the discovered sequence and move selected results into replay and reproducible testing.
Request a private STATEHOUND demo Explore the engine

GHOST LABS PROPRIETARY R&D / RUST + PYTHON

STATEHOUND
learn the behaviour beyond the test case.

MULTI-MODEL LEARNINGSTATEFUL EVM EXPLORATIONIMPLICIT INVARIANT DISCOVERY

STATEHOUND is our proprietary adaptive EVM fuzzing engine. It combines automatically generated stateful interactions, runtime feedback and multiple learning and planning models to explore contract behaviour beyond manually prepared test scenarios.

Start with a contract and its execution environment. STATEHOUND discovers the available interface, generates and mutates interactions, follows evolving state and adapts its exploration using execution feedback. It does not require the operator to supply target-specific invariants, a manual selector allowlist or a reference exploit trace. The goal is to discover implicit behavioural constraints that were never explicitly written into the test suite.

RUST EVM EXECUTION COREPurpose-built execution, runtime observation and state-aware research components.
PYTHON LEARNING ORCHESTRATIONPolicy training, multi-model learning, workers and exploration control.
MULTI-MODEL RL STACKPPO, Actor–Critic, ICM, RND, CPC, World Model and MCTS.

LIVE TERMINAL DEMO / 34 SECONDS

Watch the research loop in motion.

A short capture from a live STATEHOUND run. See target setup, interface discovery, stateful exploration and runtime feedback in the terminal.

34 SEC · H.264 · 1920 × 978
Open the demo video ↗
01 / DISCOVER

Automatic target exploration

Provide the contract and its execution environment. STATEHOUND discovers the callable interface and builds its exploration space without a manually supplied selector list or reference exploit sequence.

02 / LEARN

Multi-model reinforcement learning

PPO and Actor–Critic adapt action selection. ICM and RND contribute curiosity and novelty signals. CPC learns temporal representations, while the World Model and MCTS support predictive exploration and planning.

03 / EXPLORE

Implicit invariant discovery

Explore multi-transaction sequences, changing storage and cross-function behaviour to surface state relationships and behavioural constraints that were never manually specified for the target.

04 / REPRODUCE

POC and replay workflow

Preserve interesting execution sequences and move selected findings into a reproducible test workflow, including Foundry-oriented POC generation and replay verification.

STATEFUL EVM RESEARCH

What the engine explores

STATEHOUND investigates behaviour across calls and evolving state, rather than limiting exploration to isolated function tests.

A / SEQUENCES

Multi-transaction behaviour

Longer call sequences, action ordering, callbacks and interactions whose effects emerge only after earlier state transitions.

B / STATE

Storage and implicit invariants

Storage reads and writes, evolving state, relationships between variables and behavioural constraints not manually encoded for the target.

C / INTERACTIONS

Cross-function and cross-contract paths

Interactions between callable functions, external contracts, callers and execution contexts.

D / VALUE FLOW

Permissions and asset behaviour

Control transitions, access boundaries, native/token value movement and other state-dependent behaviours.

FROM TARGET TO POC

One adaptive research loop.

01

Provide the target

Supply a local contract or a target with a pinned chain-state execution context.

02

Discover, learn and explore

Automatically discover the interface, generate stateful sequences and adapt exploration through the multi-model learning stack.

03

Capture and reproduce

Preserve a discovered sequence and move it into POC, replay and reproducible testing workflows.

SELECTED RUNTIME SNAPSHOTS

See what the engine exposes.

Two views from the same research workflow: target preparation and automatic interface discovery, followed by live learning telemetry and exploration feedback.

STATEHOUND terminal showing target loading, baseline creation, selector discovery and a live runtime HUD.
01 / TARGET SETUP & INTERFACE DISCOVERY Target loading, baseline snapshot, ABI inspection, selector discovery and live worker telemetry.
STATEHOUND terminal showing multi-model training metrics, batch statistics, coverage feedback and runtime HUD.
02 / LEARNING TELEMETRY & RUNTIME FEEDBACK Training metrics, batch statistics, coverage-map feedback and live exploration throughput.

STATEHOUND is proprietary Ghost Labs technology, available through private technical demonstrations and selected research engagements. For selected, explicitly authorised targets, we can offer a limited pilot assessment with no upfront assessment fee; success-based compensation terms are agreed in writing before testing.

Request a private STATEHOUND demo

Tools & Research

Tools that turn execution
into evidence.

We build tools to inspect runtime behaviour, reconstruct complex transactions, and reason about low-level system performance. EVMTraceX is our public project; other research systems remain in development.

IN-HOUSE R&D BUILD / TEST / ANALYSE

A wider research stack, built in-house.

Beyond the public trace explorer, our lab develops complete AI workflows, reproducible trace-to-test pipelines, and compiler-intelligence tooling for Rust/LLVM. Some systems remain internal R&D rather than public releases; the research informs how we build applications, test complex behaviour, and investigate performance.

See our security testing approach

How we work

A method built around
evidence, not assumptions.

The steps stay transparent; the technical methods adapt to whether we are building a product or investigating system behaviour.

01

Frame the problem

Define the objective, constraints, systems in scope, the decision to support, and observable success criteria.

SCOPE()
02

Design the approach

Map dependencies, data and state boundaries, failure modes, and test strategy before implementation or investigation.

MODEL()
03

Build and probe

Implement the solution, exercise realistic scenarios, and use tests, traces, and measurements to refine it.

EXECUTE()
04

Verify and hand over

Reproduce key results where possible, document the evidence and limitations, and deliver the agreed code, findings, or next steps.

VERIFY()

Frequently asked questions

Before we
get to work.

Answers to the questions that matter before a technical engagement begins.

GL / FAQ01—07
01 What kind of work does Ghost Labs take on?

We build custom software and AI systems, engineer Solidity and EVM applications, and work on smart-contract security, developer tooling, and technical R&D. The capabilities section outlines the main disciplines; selected work and R&D shows how some of that engineering takes shape.

02 Do you build AI systems, or only integrate existing models?

We build the system around the use case: application logic, data handling, model orchestration, evaluation, APIs, interfaces, and asynchronous workflows. Integrating an existing model may be the right choice, but it is only one design decision—not the whole service. See our AI product engineering scope.

03 Can you review smart contracts and EVM applications?

Yes. Depending on the agreed scope, a review can combine manual Solidity analysis, threat modelling, targeted tests, stateful fuzzing, execution-trace investigation, and remediation guidance. We define the contracts, assumptions, dependencies, and deliverables before work starts. Details are in our smart-contract security approach.

04 How does your custom smart-contract fuzzer work?

STATEHOUND is our in-house adaptive EVM fuzzing engine, built around stateful exploration and multi-model learning. It combines PPO, Actor–Critic, ICM, RND, CPC, a World Model and MCTS. You provide a contract and its execution environment; the engine discovers the callable interface and explores generated sequences without requiring a manually supplied target-specific invariant list, selector allowlist or reference exploit trace. One research goal is to surface implicit behavioural constraints that were never explicitly described in the test suite. See the STATEHOUND overview.

05 How do you validate a security finding?

We inspect the relevant execution and state changes, identify the assumptions behind the result, and reproduce the behaviour where feasible. For suitable transaction evidence, replay tests can help distinguish an observed signal from a demonstrated outcome. Our EVMTraceX tool helps engineers examine traces; it is an analysis tool, not an automatic vulnerability scanner.

06 How are projects scoped and priced?

We align on the objective, systems in scope, dependencies, constraints, deliverables, and acceptance criteria before agreeing on a plan. Pricing depends on the type and complexity of the work; we do not publish a one-size-fits-all package. Start the conversation through the contact section and we can establish a suitable next step.

07 Can you guarantee that a system is secure?

No review or testing strategy can prove the absence of every possible defect. We define scope, choose methods appropriate to the system, report evidence and limitations, and provide practical findings or remediation guidance. Our approach is designed to reduce uncertainty—not to promise absolute security. See how we validate engineering work.

Have a difficult technical problem?

Let's turn it
into clear next steps.

Share the goal, the constraint, or the behaviour you cannot explain. We will help identify the engineering questions, define a practical scope, and agree on what a useful result should demonstrate.

Trace call tree