How It Works

Launch REDOC

Illustrated hillside with a construction crane

Discover · Reconstruct · Verify

Reverse engineer anything.

Understand how software works, learn from its architecture, and reconstruct verified capabilities for your own AI agents.

COMPONENTS

STAGES

Py · TS

PLANNED SDKS

Open

SOURCE

RUN

/example

illustrative · not a live run

INPUT

{
  “source”: “./authorized-repo”,
  “targets”: [{
    “capability”: “parse”,
    “verify”: “against
      reference tests”
  }]
}

ANALYSIS

http_client

0.96

out of scope

parse_config

0.94

selected

auth_flow

0.91

needs access

render_ui

0.88

unsupported

Scores show spec coverage, not quality claims.

RESULT

pass

41/43

2 diffs

parse_config rebuilt as a standalone module. 41 of 43 reference cases match. Two differences logged.

report

r_9f3ac210

Discovery

Map interfaces and dependencies

Reconstruction

Rebuild selected capabilities

Verification

Test against reference behavior

Integration

Package for agent runtimes

The REDOC pipeline, stage by stage.

Built around

Discovery

Reconstruction

Composition

Integration

Verification

Repositories

APIs

Interfaces

Dependencies

Specifications

Execution paths

Test suites

Reference behavior

Provenance

Modules

SDKs

Agent tools

Python

TypeScript

Documentation

CLIs

Limitations

Licenses

Permissions

One pipeline

from authorized source to verified, reusable agent capabilities.

Why REDOC

Software is knowledge. Make it reusable.

Every repository, API, and agent contains valuable engineering knowledge. REDOC is building the infrastructure to understand that knowledge and turn supported functionality into portable capabilities.

Starting from scratch

REDOC, by design

Understanding a codebase

Read it by hand

Mapped interfaces

Reusing a capability

Rewrite it from memory

Reconstruct from a spec

Trusting a rebuild

Manual spot checks

Tested against reference

Known limitations

Found in production

Reported explicitly

Provenance

Lost in copy-paste

Recorded per capability

Agent integration

Custom glue per framework

Portable modules

Discover

Start by understanding.

REDOC analyzes authorized repositories, APIs, and AI agents to identify their capabilities, dependencies, and execution behavior. Nothing is reconstructed until it is understood.

Discovery Engine: analyze repositories, APIs, documentation, and software interfaces.

Reverse Engineering Engine: extract specifications and execution behavior.

Dependency mapping across modules, packages, and external services.

Inaccessible functionality is flagged, not guessed.

How It Works

Targets

/parser

active

Analysis scope

authorized source only

target:

/parser

scope:

source_backed

min_coverage:

0.94

max_files:

800

capabilities:

- parse_config

- http_client

- cli_args

report_gaps:

true

CAPABILITY

DEPS

TIME

COVER

IN SCOPE

parse_config

180 ms

0.95

yes

http_client

410 ms

0.97

yes

cli_args

520 ms

0.96

yes

auth_flow

140 ms

0.86

no access

Reconstruct

parse_config.spec

run #12

▲ 2 differences from reference behavior. Logged.

0.87

reference suite · 43 cases

CASE

CHECK

EXPECTED

MATCH

ref-0042

schema

valid

1.00

ref-0117

behavior

≥ 0.90

0.71

ref-0203

exact

utf-8

1.00

ref-0288

edge case

≥ 0.85

0.63

ref-0341

schema

valid

1.00

Logged limitation: locale-specific date formats.

Reconstruct

Rebuild it. Then prove it.

Selected capabilities are transformed into independent implementations and tested against known reference behavior. Differences are recorded, not hidden. Nothing is called equivalent until the tests say so.

Capability Compiler: portable implementations from source-backed specs.

Verification Engine: compare against reference behavior.

Behavioral differences reported for every capability.

Provenance recorded from source to final module.

See the roadmap

Integrate

Reuse what already works.

Bring verified capabilities into compatible agent environments and build new functionality without starting from scratch. Integration targets are planned.

Agent Integration: expose capabilities to agent runtimes.

Python and TypeScript packaging, planned first.

Standard tool interfaces for agent frameworks, so one capability works across runtimes.

Capability Composition: combining compatible capabilities. A longer-term goal.

See the roadmap

Coverage

parse_config

illustrative

Cases by module

/parser

/encoder

/errors

other

By capability

share of cases

parse_config

61%

26 cases

http_client

29%

12 cases

auth_flow

4 cases

cli_args

1 case

How it works

How REDOC works.

From existing software to reusable agent capabilities. Six steps, each one inspectable.

Discover

Point REDOC at an authorized repository, API, or agent. It maps interfaces and dependencies.

Analyze

The Reverse Engineering Engine extracts functional structure and execution behavior.

Specify

Selected functionality is written down as a source-backed specification.

Reconstruct

The Capability Compiler generates an independent, portable implementation.

Verify

Behavior is tested against the reference. Differences and limitations are reported.

Integrate

Verified capabilities are packaged for compatible agent runtimes, with provenance attached.

Engine

Built for software understanding.

A modular architecture for analyzing, reconstructing, and integrating capabilities. Here is what it is designed to do for each.

Agent builders

Platform teams

Researchers

Open source

Give agents capabilities that already exist.

What REDOC is for

Capability Discovery identifies reusable functionality inside authorized projects. Behavioral Reconstruction turns supported, source-backed specifications into implementations your agents can call, with tests attached.

Design goal

Reuse a verified capability instead of rebuilding it from scratch.

Launch REDOC

Reconstruct

parse_config.spec

▲ 2 differences from reference behavior. Logged.

0.87

reference suite · 43 cases

CASE

CHECK

EXPECTED

MATCH

ref-0042

schema

valid

1.00

ref-0117

behavior

≥ 0.90

0.71

ref-0288

edge case

≥ 0.85

0.63

ref-0341

schema

valid

1.00

Reverse anything

Understand what’s already been built.

Explore software from the inside out. REDOC aims to make existing implementations easier to analyze, learn from, and reconstruct into reusable capabilities.

CAPABILITY

FILES

DEPS

TESTS

TIME

MATCH

full pipeline

all

240 ms

94.1

http_client

410 ms

96.3

parse_config

180 ms

88.7

cli_args

520 ms

95.8

auth_flow

140 ms

86.2

render_ui

690 ms

91.4

stream_io

n/a

40 ms

n/a

Illustrative example run. Not a benchmark.

“Reverse anything” is a direction, not a claim of universal support. Unsupported functionality is reported explicitly.

OPEN SOURCE

Built in the open.

Transparent specifications, reproducible implementations, and verifiable results. REDOC is designed as infrastructure developers can inspect, extend, and build upon.

Authorized sources only

Designed for software you may analyze. Licenses and access limits apply.

Reproducible by default

Every reconstruction should be repeatable from the same inputs, specs, and tests.

Provenance recorded

Each capability keeps a record of where it came from and how it was verified.

Limitations reported

Behavioral differences and unsupported functionality are surfaced, not hidden.

See the roadmap

“

Make software understandable, reconstructable, and reusable by AI agents.

REDOC

PROJECT MISSION

Workspace live

We’re building REDOC.

Starting with real open-source repositories, reproducible reconstruction, and automated verification. One capability at a time.

Discovery

Phase 01

Analyze authorized repositories, APIs, documentation, and software interfaces.

Phase

Repos

First

APIs

Reconstruction

Phase 02

Specs from behavior

Extract functional specifications, dependencies, and execution behavior.

Reverse Engineering Engine

Composition

Combine compatible capabilities. Longer-term research.

Phase

Integration

Phase 04

Expose verified capabilities to compatible agent runtimes.

Phase

Py · TS

Planned targets

Verification

Phase 03

Test against reference behavior

Diffs

Always reported

Phase

Interoperability

Portable by design. Python and TypeScript first.

What REDOC is designed to read, and the forms it aims to produce. Integration targets are planned, not shipped.

Python

TypeScript

Git repos

OpenAPI

{ }

REST

CLI

Docs

Specs

Test suites

Agent tools

SDK modules

Provenance

Workflow

From understanding to execution.

An illustrative workflow, from an authorized repository to a verified capability.

Select a source

Choose an authorized repository or API. REDOC maps its interfaces and dependencies.

Reconstruct a capability

Pick one function. REDOC writes a spec, then an independent implementation.

Read the report

Tests, behavioral differences, limitations, and provenance, in one place.

from redoc import Pipeline

run = Pipeline()
cap = run.reconstruct(
target=“parse_config”,
verify=[{“against”: “reference”, “cases”: “all”}],
)

# illustrative: API not final

Roadmap

What we’re building.

A focused path from software analysis to portable agent capabilities. Integration and composition come next.

Now

IN DEV

Discovery

Identify supported functions, interfaces, and dependencies in authorized source repositories.

PLANNED

Reconstruction

Generate independently executable implementations of selected capabilities.

Later

PLANNED

Verification

Create automated tests and record behavioral differences, limitations, and provenance.

FAQ

Frequently asked questions.

Scope, status, and limits. Short answers.

What is REDOC?

An open-source infrastructure project for understanding existing software and reconstructing selected capabilities for reuse by AI agents, packaged as executable modules, SDK integrations, or standard agent tools.

Can REDOC reverse engineer any software?

How is REDOC different from an AI coding assistant?

Does REDOC copy existing agents?

Is REDOC open source?

Understand. Reconstruct. Extend.

Open infrastructure. Real engineering. Built in public.

Launch REDOC

How It Works