Skip to main content
Glama

FEA (Forensic Evidence Agent) lets an AI agent such as Claude Code examine forensic disk images the way an examiner does: list and recover files, read registry hives and event logs, query SQLite and ESE databases, parse prefetch and shortcuts, sweep unallocated space, and build timelines. Everything is read-only, runs locally, and every answer comes back with the evidence behind it (image, partition, path, inode, hash, tool) and its limitations.

It is the forensic counterpart of REA, which does the same for reverse engineering.

Targets

Target

What FEA does with it

Backed by

Raw, split raw (.001...) and E01 images

partition table, file-system probing, raw and block reads

The Sleuth Kit (pytsk3)

NTFS, FAT/exFAT, ext2/3/4, HFS+, APFS, UFS, ISO9660, YAFFS2

list, find (incl. deleted names), stat with NTFS $FILE_NAME times and alternate data streams, read, extract, timeline, recover deleted

pytsk3; fls/tsk_recover when installed

Unallocated space

keyword search (UTF-8 and UTF-16LE), block mapping, block reads

NTFS $Bitmap walk; blkls/blkcalc when installed

Windows registry

key/value dumps with last-write times; UserAssist, ShellBags, WordWheelQuery, TypedPaths, USBSTOR, services, timezone and more

regipy

Windows event logs (.evtx)

filter by event ID, time, provider or text; flattened event data

evtx (Rust parser)

Prefetch, LNK and Jump List entries

run counts and times, target paths, volume serials, machine IDs

libscca, liblnk

ESE databases (SRUM, Windows Search, WebCache, ntds.dit)

table listing and row dumps

dissect.esedb

SQLite (browsers, chat apps, Android)

schema, read-only SQL, WAL applied, freelist size

sqlite3

Pictures, documents, PDFs

metadata, hashes, entropy, bytes after the end-of-file marker, OOXML hidden text and tracked changes, YARA

exiftool or Pillow, puremagic, yara-python

Memory remnants on disk (pagefile, hiberfil, swap)

strings and keyword hits with offsets

pure Python

Linux and Android file systems are handled by the same file-system tools; Android app databases go through the SQLite tools.

Related MCP server: Self-Assembling Forensic MCP Server

Quick start

git clone https://github.com/keyuraghao/fea && cd fea
uv sync                                   # or: pip install -e .
uv run fea setup                          # registers the MCP server with Claude Code and installs the /fea skill
uv run fea images add WS1 /cases/x/workstation.001 --label "Workstation 1"

Then ask Claude Code something like "on WS1, who cleared the Security log and what ran in the ten minutes before?" and it will call the FEA tools itself. From the shell the same operations are one command each:

fea evtx WS1 /Windows/System32/winevt/Logs/Security.evtx --ids 1102
fea timeline WS1 --start 2021-02-03T12:24 --end 2021-02-03T12:34 --path Prefetch
fea prefetch WS1 /Windows/Prefetch/UPDATER.EXE-1A2B3C4D.pf

Requirements: Python 3.12+ on Windows, macOS or Linux. Nothing else. The Sleuth Kit and exiftool binaries are optional accelerators and are used automatically when found (fea doctor shows what was detected).

How an investigation flows

  1. Scope: images_list, partitions, tools_status.

  2. Locate: find (names, including deleted), ls, timeline.

  3. Inspect: stat (timestomp indicator from $FILE_NAME), read, extract, file_info.

  4. Parse in place: registry, event logs, prefetch, LNK, ESE, SQLite, EXIF, OOXML, YARA.

  5. Dig: grep_files, grep_file on pagefile/hiberfil, grep_unallocated, recover_deleted, block_read.

  6. Report: every result carries evidence and limitations; times are given in UTC and the image's timezone.

Long scans run as background jobs (job_result(job_id, wait_s=30)), so the agent can keep working.

Showcase

Findings reproduced with FEA on a ten-image training case (a staged government leak):

  • Who cleared the logs. evtx on Security.evtx returned the single surviving record: event 1102, log cleared by a passwordless local account at 12:34:08 local time; timeline on the Prefetch folder showed the implant runs in the preceding minutes; prefetch gave the five run times of the second-stage binary.

  • What the implant talked to. grep_file on the implant found its command-and-control URL stored as UTF-16LE, with the exact file offset.

  • What the user had been told to do. sqlite_query on the Sticky Notes database, with its write-ahead log applied, returned a note instructing the user to install software with the local account, which explained why that account had no password.

  • Hidden appended data. file_info on every picture reported bytes_after_eof: 0, closing a steganography question in one call per file.

Agent integration

fea setup registers the server for Claude Code (user scope) and writes the /fea skill. For any other MCP client, point it at:

uv --directory /path/to/fea run fea mcp          # or: python -m fea mcp

The server speaks stdio by default (--transport sse|streamable-http also available).

Documentation

Host access policy

An agent reading evidence may be fed planted instructions. FEA therefore restricts what the MCP server can touch on the host: images come from the registry or allowed_roots, local_path arguments must be inside the cache or output area, and extract / recover_deleted write only under the output root (~/.fea/out by default). Names taken from image content are sanitised before they reach the host file system. Details in SECURITY.md; tools_status shows the policy in force.

Limits

  • The Sleuth Kit does not parse HPFS or some exotic file systems; use disk_read and strings there.

  • Volume shadow copies, BitLocker and encrypted containers are not opened.

  • Registry transaction logs are not replayed.

  • Without sleuthkit, grep_unallocated on non-NTFS volumes scans allocated blocks too (the result says so).

License

MIT. Third-party libraries keep their own licences: The Sleuth Kit (IBM Public License / CPL), regipy (MIT), evtx (MIT/Apache-2.0), libyal libraries (LGPL), dissect (AGPL-3.0 for dissect.esedb), yara-python (BSD/Apache-2.0). See THIRD_PARTY_NOTICES.md.

Available Tools

35 tools
blkcalcC

Map a blkls stream byte offset (from a sleuthkit-mode grep_unallocated hit) to the real file-system block.

Inputs: image (required), blkls_offset (required), part.

block_readB

Read file-system blocks by number (follow up grep_unallocated hits).

Inputs: block (required), image (required), part, count, +1 more.

disk_readC

Raw bytes at an absolute byte offset in the image (hex dump or text).

Inputs: image (required), offset (required), length, as_text.

esedb_dumpC

Dump rows of an ESE database table (optionally selected columns, filtered by text).

Inputs: ref, part, image, limit, +4 more.

esedb_tablesC

List tables of an ESE database (SRUDB.dat, Windows.edb, WebCacheV01.dat, ntds.dit).

Inputs: ref, part, image, local_path.

evtxB

Query a Windows .evtx log: filter by event IDs, time range (ISO, image timezone), provider, or text; returns flattened event data.

Inputs: end, ref, part, image, +6 more.

exifC

Metadata of a media/document file (exiftool when installed, else Pillow EXIF and OOXML properties).

Inputs: ref, part, image, local_path.

extractB

Copy a file (or ADS) out of the image into out_dir (relative to, or inside, the output root); returns size, SHA1, MD5.

Inputs: ref (required), image (required), name, part, +2 more.

file_infoC

File type, SHA1/MD5/SHA256, entropy, and bytes after the JPEG/PNG/PDF end marker (hidden appended data).

Inputs: ref, part, image, local_path.

findB

Find files by path name (glob with * ? or regex), including deleted names. deleted = any|only|no. Times ISO in image timezone.

Inputs: image (required), pattern (required), part, limit, +6 more.

grep_fileC

Search one file (in-image ref, or local_path to an extracted file such as pagefile.sys) for terms; returns offsets and context.

Inputs: ref, part, image, regex, +6 more.

grep_filesB

Background job: search file CONTENT (UTF-8 and UTF-16LE) of files whose path matches path_regex. Poll job_result.

Inputs: image (required), terms (required), part, regex, +7 more.

grep_unallocatedB

Background job: scan unallocated space for terms; hits carry file-system block numbers (or blkls offsets when sleuthkit is used). Poll job_result.

Inputs: image (required), terms (required), part, regex, +5 more.

images_addA

Register a disk image (raw, split raw .001, E01) under a short name. Allowed only for paths under the configured allowed_roots (or with FEA_UNRESTRICTED=1); otherwise register on the host with fea images add.

Inputs: name (required), path (required), label, timezone.

images_listA

List registered disk images (name, path, label, timezone) and the default timezone.

Inputs: no named parameters.

job_cancelB

Ask a running background job to stop at its next progress checkpoint.

Inputs: job_id (required).

job_resultB

Wait up to wait_s seconds (max 300) for a background job and return its result when done.

Inputs: job_id (required), wait_s.

jobs_listB

List background jobs started in this session.

Inputs: no named parameters.

job_statusC

Status and progress of a background job.

Inputs: job_id (required).

lnkB

Parse a Windows shortcut (.lnk / Jump List entry): target path, volume serial, machine id, target times.

Inputs: ref, part, image, local_path.

lsB

List a directory (path or 'inode:N'): names, inodes, sizes, MAC times, deleted flags, alternate data streams.

Inputs: image (required), part, path, limit, +1 more.

office_partsC

Open an OOXML document (docx/xlsx/pptx): list parts, extract text, comments, properties; flag hidden text and tracked changes.

Inputs: ref, part, image, max_chars, +1 more.

partitionsC

Partition table (mmls-style) with file-system type probing for each partition.

Inputs: image (required).

prefetchB

Parse a Windows Prefetch (.pf) file: executable, run count, last 8 run times, volumes, referenced files.

Inputs: ref, part, image, local_path.

readB

Read up to 4 MiB of a file (or an ADS via stream) as text (auto UTF-16 detection) or hex.

Inputs: ref (required), image (required), part, length, +3 more.

recover_deletedB

Background job: recover deleted/orphaned files into out_dir (inside the output root), optionally only paths matching regex. Poll job_result.

Inputs: image (required), part, out_dir, max_files, +1 more.

registry_keyC

Read a Windows registry hive (SYSTEM, SOFTWARE, SAM, NTUSER.DAT, UsrClass.dat, Amcache.hve): a key's values, last-write time and subkeys to depth (max 4).

Inputs: key, ref, part, depth, +3 more.

registry_pluginsC

Run regipy artefact plugins on a hive (UserAssist, ShellBags, WordWheelQuery, TypedPaths, USBSTOR, services, ComputerName, timezone, ...).

Inputs: ref, part, image, plugins, +1 more.

sqlite_queryC

Run a read-only SELECT against a SQLite database inside the image.

Inputs: ref, sql, part, image, +2 more.

sqlite_tablesC

Tables, row counts, columns and freelist size of a SQLite database (browser history, chat apps, Android apps). WAL applied when present.

Inputs: ref, part, image, local_path.

statB

Full metadata for a file/dir by path or inode ('inode:N' or 'N-128-3'): times, attributes/ADS, NTFS $FILE_NAME times with a timestomp indicator, istat text when sleuthkit is installed.

Inputs: ref (required), image (required), part.

stringsC

Printable strings (ASCII and UTF-16LE) from a file with offsets, optionally filtered by regex.

Inputs: ref, part, image, limit, +4 more.

timelineC

File-system timeline (directory walk) between start/end (ISO, image timezone), optionally filtered by path regex. kinds: m a c b.

Inputs: image (required), end, part, kinds, +4 more.

tools_statusB

Platform, Python version, optional native tools (sleuthkit, exiftool) and the host access policy in force.

Inputs: no named parameters.

yara_scanC

Scan a file with YARA rules (rule text, or a .yar path inside the allowed roots).

Inputs: ref, part, image, rules, +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.9/5.0

    Scored across 35 tools

    Disambiguation4/5

    Most tools have clearly distinct forensic purposes tied to specific artifacts or operations. However, there is some overlap among related tools like `ls` vs `find`, `read` vs `disk_read`/`block_read`, and the `grep_*` family, which could cause occasional hesitation. Descriptions generally clarify the boundaries well.

    Naming Consistency3/5

    The set mixes verb_noun (`images_list`, `grep_files`), noun_verb (`disk_read`, `sqlite_query`), and bare noun (`partitions`, `stat`, `evtx`, `lnk`) conventions. All names use lowercase snake_case, so it remains readable, but the lack of a single predictable pattern reduces consistency.

    Tool Count2/5

    With 35 tools, the set is heavy and exceeds the 25+ threshold for 'too many' in the rubric. While the forensic domain is broad and many tools target distinct artifacts, the count suggests opportunities for consolidation or grouping to reduce cognitive load.

    Completeness4/5

    The surface covers disk images, filesystem metadata, content search, registry, event logs, SQLite, ESE, LNK, prefetch, EXIF, OOXML, and YARA, which is broad for forensic analysis. Minor gaps include image removal/update, hash set import/compare, and dedicated carving or memory analysis, but agents can work around these.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      A high-performance MCP Server for Disk Forensics that enables AI agents to analyze disk images through the Model Context Protocol.
      2
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to perform digital forensics analysis including memory analysis, file metadata inspection, and threat-intelligence lookups.
      8 npm
      ISC
    • F
      license
      A
      quality
      C
      maintenance
      Enables AI agents to perform digital forensics and incident response tasks by dynamically discovering and utilizing host tools for memory analysis, metadata extraction, threat detection, and file dissection.
      5
      1
      -
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to inspect Autopsy forensic cases through read-only MCP tools for case metadata, filesystem and artifact search, timeline and account queries, evidence extraction, and hash-chained audit/seal verification.
      1 npm
      2
      GPL 3.0