EKOS — Enterprise Knowledge Operating System
A compiled app, no source.
Same results in Python.
EKOS reads a compiled .NET library it has never seen the source of, recovers what every method does,
and a Python rewrite is written from that. The rewrite is then checked against the running original
and produces byte-identical output. Below is every step, with the real screen for each.
MarkdownSharp.dll→
ekos recover→
statement-level spec→
Python rewrite→
characterize + fuzz
RFC 0148 · RFC 0150 · RFC 0149 (private extension)
§ 00 / why this app
Open source, real, deterministic, and small enough to check completely.
MarkdownSharp is the Markdown engine that powered Stack Overflow. It is a text-to-HTML function with no
files, network or database, so "same results" means identical bytes. It leans on regular expressions,
which is where a port most easily goes wrong.
- InputThe compiled net40 assembly from NuGet, MIT licensed.
- Recovered99 of 101 method bodies as fully structured statements, 98%.
- Scope.NET only today. A Java jar would stop at structural facts; see the last slide.
§ 01 / start
A DLL and nothing else
MarkdownSharp 2.0.5 (MIT), a 51 KB compiled .NET assembly. No repository, no source. Only its string constants are readable.
§ 02 / baseline
Run the original: this is the behaviour to reproduce
A 12-line harness calls new Markdown().Transform(text). It runs on wine-mono, with no .NET SDK installed.
§ 03 / observe
ekos build reads the bytes
The assembly is parsed, never executed. It becomes a content-addressed artifact.
§ 04 / recover
Recovery: 101 method bodies, 99 fully structured
A hand-written CIL decoder builds control-flow graphs and structures them into if/loop/switch/try statements. No LLM key was set, so none was used.
§ 05 / ledger
The result is queryable knowledge
Types, methods and the call graph are evidence-backed objects in the append-only ledger.
§ 06 / plan
The spec, and the order to port it in
ekos_binary_explain over MCP, the same server an AI agent uses. Callees come first, so every port step only depends on finished work.
Recovered pseudo-code, all types
§ 07 / spec
One method, statement by statement
Every recovered line cites its IL offset. Regexes and replacement templates arrive as exact constants.
Recovered pseudo-code, all types
§ 08 / honesty
Where recovery falls short, it says so
Normalize is control_flow with one unstructured goto. EKOS marks it partial and tells the porter not to guess. Two of 101 methods are in this state.
Recovered pseudo-code, all types
§ 10 / static check
What the rewrite touches vs what the original touches
Evidence, not a verdict. It caught the config-file constructor that was left out on purpose. The rest are constants that moved files.
Python rewrite: markdown.py · _literals.py · __main__.py
§ 11 / sandbox
Executing untrusted code, so prove the sandbox first
Five escape attempts, all blocked. The probe was itself validated by running it unsandboxed, where all five succeed.
§ 12 / characterize
Record the original, check the rewrite
The original runs once in the sandbox and its results become a golden file. The check needs only Python.
§ 13 / compare
Same inputs, both programs, byte for byte
wine mdcli.exe against python -m mdport. Identical sha256 on all 15 fixtures.
§ 14 / rendered
What a user sees
The HTML of both programs rendered in a browser. Identical output, not just similar-looking output.
§ 15 / fuzz
3,000 generated documents, and a planted bug
Identical on every one. To show the fuzzer can fail, one regex flag was removed from a copy of the port. It found 44 differences in 300 documents.
§ 16 / limits
The one non-deterministic path
The original builds System.Random for email obfuscation. The spec shows it, so the port is random too, and the comparison decodes entities.
§ 17 / part 2
How EKOS helps in this demo
EKOS does not write the port. It makes the input trustworthy and the output checkable.
| Step | What EKOS did here | What you would do without it |
|---|
| Read the binary | In-process CIL decoder, control-flow graphs, structuring: 101 method bodies, 99 as full statements. No SDK, nothing executed. | A PE file is not text an LLM can read. You need a decompiler first, and its output has no per-line evidence. |
| Constants | 37 regex and format literals, 12,009 characters, delivered verbatim and copied into the port by a script. | Recall or retype them. One wrong character in a verbose regex changes behaviour and nothing complains. |
| Evidence | Every statement cites its IL offset; every fact is a ledger object with provenance. | Claims about what a method does cannot be traced back to anything. |
| Gaps | 2 methods marked control_flow / partial, with "do not fill the gaps by guessing". | A model fills a gap with plausible code, and nobody sees where. |
| Order | Migration order, callees first, for all 78 methods of the type. | Ad hoc, and easy to port a caller before what it depends on. |
| Verify | Static check, sandboxed record of the original, replay against the port, and a fuzz that caught a planted bug. | "Looks right" review of code that was never compared to the running original. |
§ 17 / part 2
Why this is harder for a plain LLM
Knowing Markdown is not the same as knowing this program.
- Behaviour, not conceptMarkdownSharp has its own quirks, for example a list that follows another gets nested inside the previous item. Two mature generic libraries match the original on 1 of 15 fixtures byte for byte, and 10 and 8 of 15 ignoring whitespace. The port written from the spec matches 15 of 15.
- Dialect traps.NET and Python regexes differ:
\z vs \Z, variable-width lookbehind, atomic groups need Python 3.11+, options are integers in the IL. None of these show in a plain read of the code. Tests found them.
- Silent guessingWhere the recovered structure is incomplete EKOS says so per method. A model asked to "port this" gives no such signal.
- No ground truthWithout running the original there is nothing to compare against. Here the original ran in a sandbox, and a one-flag bug that a review would likely miss showed up as 44 differing documents in 300.
Honest limits: no head-to-head against an LLM was run, and the rewrite here was itself written by an LLM using EKOS's spec, check and harness. The generic libraries are a proxy. A plain LLM given a general decompiler such as ILSpy would do better than that proxy; it would still lack per-line IL evidence, fidelity flags, callee ordering, and the run-against-the-original loop.
§ 17 / baseline
What general Markdown knowledge produces instead
Two mature generic libraries against the original's output. This is a proxy, not an LLM run. It shows how far Markdown the concept is from this program.
§ 18 / result
Scoreboard, and what this does not prove
Numbers come from the frames, not from this page.
Reproduce it
Every screenshot comes from one script.
terminal
# runs all 18 stages, real commands, writes frames/NN-*.txt
$ demo/binary-demo/run_demo.sh
# renders each frame to a PNG (and the browser comparison)
$ python3 demo/binary-demo/capture.py
# later: string the frames into a GIF or video
$ demo/binary-demo/tools/make_gif.sh 3
The code: Recovered pseudo-code, all types · Python rewrite: markdown.py · _literals.py · __main__.py
Not proven here: behaviour on the .NET Framework itself (the original ran on wine-mono); inputs outside the fuzzer's grammar; the app.config constructor (not ported). The decompiler is a private RFC 0149 extension; the screenshots show its output.
