{"id":78590,"date":"2026-09-16T07:17:58","date_gmt":"2026-09-16T07:17:58","guid":{"rendered":"https:\/\/www.devopsschool.com\/blog\/?p=78590"},"modified":"2026-09-16T07:18:08","modified_gmt":"2026-09-16T07:18:08","slug":"inferencefs-complete-tutorial","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/blog\/inferencefs-complete-tutorial\/","title":{"rendered":"InferenceFS Complete Tutorial"},"content":{"rendered":"\n

What Is InferenceFS, Why Does It Exist, How Does It Work, and What Does It Teach Us About LLMs?<\/h2>\n\n\n\n

Updated: September 2026<\/strong><\/p>\n\n\n\n

InferenceFS may be one of the most entertaining filesystem projects ever created\u2014but underneath the joke is a surprisingly useful lesson about modern AI.<\/p>\n\n\n\n

Its premise is wonderfully absurd:<\/p>\n\n\n\n

\n

Why store the contents of a file when a large language model can simply guess what the file probably contained from its filename?<\/p>\n<\/blockquote>\n\n\n\n

Imagine creating:<\/p>\n\n\n

requirements<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
without putting anything inside it.<\/p>\n\n\n\n
When someone later runs:<\/p>\n\n\n
cat<\/span> requirements<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
InferenceFS asks an LLM something equivalent to:<\/p>\n\n\n
What is the most likely contents of<\/span> a file with<\/span> the name \/requirements.txt?\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
The model might respond:<\/p>\n\n\n
requests==2.32.5\nflask==3.1.2\npytest==8.4.2\n<\/code><\/span><\/pre>\n\n\n
Those generated bytes become the contents returned by the filesystem.<\/p>\n\n\n\n
Nothing resembling the original contents had to be stored.<\/p>\n\n\n\n
Brilliant?<\/p>\n\n\n\n
Terrifying?<\/p>\n\n\n\n
Both.<\/p>\n\n\n\n
InferenceFS is the 2026 successor to Philip Langdale’s earlier \u03c0fs<\/strong>, the famous experimental filesystem that represented file bytes as positions in the hexadecimal digits of \u03c0. The author explicitly describes InferenceFS as an April Fools’ project<\/strong> and warns users not to store anything they care about.<\/p>\n\n\n\n
But the implementation itself is real.<\/p>\n\n\n\n
It:<\/p>\n\n\n\n
    \n
  • mounts through FUSE,<\/li>\n\n\n\n
  • exposes normal-looking files and directories,<\/li>\n\n\n\n
  • supports multiple LLM backends,<\/li>\n\n\n\n
  • lazily generates file contents,<\/li>\n\n\n\n
  • caches generated results,<\/li>\n\n\n\n
  • attempts binary generation,<\/li>\n\n\n\n
  • handles FUSE inode\/file-descriptor lifecycle,<\/li>\n\n\n\n
  • retries API calls after rate limits,<\/li>\n\n\n\n
  • tracks apparent file sizes,<\/li>\n\n\n\n
  • and lets normal programs operate against the mounted filesystem.<\/li>\n<\/ul>\n\n\n\n
    The project is therefore much more than a joke.<\/p>\n\n\n\n
    It is an unusually good laboratory for learning:<\/p>\n\n\n\n
      \n
    • FUSE,<\/li>\n\n\n\n
    • virtual filesystems,<\/li>\n\n\n\n
    • LLM inference,<\/li>\n\n\n\n
    • hallucination,<\/li>\n\n\n\n
    • lossy compression,<\/li>\n\n\n\n
    • caching,<\/li>\n\n\n\n
    • binary generation,<\/li>\n\n\n\n
    • AI reliability,<\/li>\n\n\n\n
    • filesystem semantics,<\/li>\n\n\n\n
    • lazy computation,<\/li>\n\n\n\n
    • metadata,<\/li>\n\n\n\n
    • API-backed infrastructure,<\/li>\n\n\n\n
    • and the difference between plausible data<\/strong> and actual data<\/strong>.<\/li>\n<\/ul>\n\n\n\n
      \n\n\n\n
      1. What Is InferenceFS?<\/h1>\n\n\n\n
      InferenceFS is a FUSE userspace filesystem written in Python<\/strong>.<\/p>\n\n\n\n
      Instead of storing the real contents of ordinary files, it maintains a source directory containing the filesystem structure and then asks an LLM to generate contents when a file is read.<\/p>\n\n\n\n
      Conceptually:<\/p>\n\n\n
      File path\n   \u2193\n\/project\/config.yaml\n   \u2193\nLLM\n   \u2193\n\"What would config.yaml probably contain?\"<\/span>\n   \u2193\nGenerated YAML\n   \u2193\nApplication sees it as<\/span> file contents\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      The official project describes the architecture this way:<\/p>\n\n\n\n
        \n
      1. The source directory supplies filenames and directory structure.<\/li>\n\n\n\n
      2. A read causes an LLM request based on the filename.<\/li>\n\n\n\n
      3. The model’s answer becomes file contents.<\/li>\n\n\n\n
      4. Binary responses may be returned as base64 and decoded.<\/li>\n\n\n\n
      5. Generated contents are cached.<\/li>\n\n\n\n
      6. Writes appear successful but their data is discarded.<\/li>\n<\/ol>\n\n\n\n
        That last point is critically important.<\/p>\n\n\n\n
        InferenceFS is not persistent generative storage<\/strong>.<\/p>\n\n\n\n
        It is closer to:<\/p>\n\n\n
        filesystem interface<\/span>\n        +\nLLM<\/span>-powered<\/span> content<\/span> generator<\/span>\n<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
        than a conventional filesystem.<\/p>\n\n\n\n
        \n\n\n\n
        2. InferenceFS in One Sentence<\/h1>\n\n\n\n
        InferenceFS is:<\/p>\n\n\n\n
        \n
        A FUSE filesystem where filenames act as prompts and LLM responses act as file contents.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
        \n\n\n\n
        3. The Most Important Thing to Understand<\/h1>\n\n\n\n
        Suppose you run:<\/p>\n\n\n
        echo \"My secret database password is abc123\"<\/span> > \/mnt\/i<\/span>nference\/secret.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
        A conventional filesystem stores:<\/p>\n\n\n
        My secret database password is abc123\n<\/code><\/span><\/pre>\n\n\n
        InferenceFS does not<\/strong>.<\/p>\n\n\n\n
        The current implementation’s write()<\/code> method returns:<\/p>\n\n\n
        len(buf)\n<\/code><\/span><\/pre>\n\n\n
        to tell the calling program that the write succeeded.<\/p>\n\n\n\n
        But it does not persist buf<\/code>.<\/p>\n\n\n\n
        Instead, it tracks only the highest written offset so that it can remember an apparent file size.<\/p>\n\n\n\n
        When the file is later read, InferenceFS asks the configured LLM approximately:<\/p>\n\n\n
        What is the most likely contents of<\/span> a file with<\/span> the name \/secret.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
        and returns whatever the model generates.<\/p>\n\n\n\n
        Therefore:<\/p>\n\n\n
        What you write\n      \u2260\nwhat you later read\n<\/code><\/span><\/pre>\n\n\n
        That difference defines InferenceFS.<\/p>\n\n\n\n
        \n\n\n\n
        4. InferenceFS vs \u03c0fs<\/h1>\n\n\n\n
        InferenceFS directly continues the joke started by \u03c0fs.<\/p>\n\n\n\n
        \u03c0fs<\/h2>\n\n\n\n
        \u03c0fs approximately says:<\/p>\n\n\n
        Your data already exists inside \u03c0.\nStore locations into \u03c0.\n<\/code><\/span><\/pre>\n\n\n
        InferenceFS<\/h2>\n\n\n\n
        InferenceFS says:<\/p>\n\n\n
        Your data probably exists somewhere in the model's knowledge.\nJust remember what the file was called.\n<\/code><\/span><\/pre>\n\n\n
        The original project’s comparison is roughly:<\/p>\n\n\n\n
        Property<\/th>\u03c0fs<\/th>InferenceFS<\/th><\/tr><\/thead>
        Source of reconstructed content<\/td>\u03c0<\/td>LLM<\/td><\/tr>
        Metadata<\/td>Byte positions<\/td>Filename\/path<\/td><\/tr>
        Retrieval<\/td>BBP computation<\/td>Model inference<\/td><\/tr>
        Exact reconstruction<\/td>Intended<\/td>No<\/td><\/tr>
        Computational model<\/td>Deterministic mathematics<\/td>Probabilistic generation<\/td><\/tr>
        Main limitation<\/td>Metadata > data<\/td>Generated content \u2260 original<\/td><\/tr>
        FUSE generation<\/td>C\/FUSE 2<\/td>Python\/pyfuse3<\/td><\/tr>
        Main lesson<\/td>Information theory<\/td>AI as extreme lossy compression<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
        InferenceFS’s author describes \u03c0fs as having impractical metadata but theoretically exact reconstruction, while InferenceFS has tiny metadata but an extremely lossy \u201ccodec.\u201d<\/p>\n\n\n\n
        \n\n\n\n
        5. Why Was InferenceFS Created?<\/h1>\n\n\n\n
        On the surface:<\/p>\n\n\n
        because storing files is expensive\n<\/code><\/span><\/pre>\n\n\n
        and:<\/p>\n\n\n
        LLMs already saw the internet\n<\/code><\/span><\/pre>\n\n\n
        so perhaps they can \u201cremember\u201d your files.<\/p>\n\n\n\n
        That is the satire.<\/p>\n\n\n\n
        The deeper idea is much more interesting.<\/p>\n\n\n\n
        InferenceFS asks:<\/p>\n\n\n\n
        \n
        What does it mean when we claim that an LLM \u201cknows\u201d something?<\/p>\n<\/blockquote>\n\n\n\n
        Suppose an LLM has seen thousands of examples of:<\/p>\n\n\n
        Dockerfile\n<\/code><\/span><\/pre>\n\n\n
        Then asking it to generate \/Dockerfile<\/code> may produce something extremely plausible.<\/p>\n\n\n\n
        For example:<\/p>\n\n\n
        FROM python:3.14<\/span>-slim\n\nWORKDIR \/app\n\nCOPY requirements.txt .\nRUN pip install --no-cache-dir -r requirements.txt\n\nCOPY . .\n\nCMD [\"python\"<\/span>, \"app.py\"<\/span>]\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
        The model has not necessarily retrieved your Dockerfile<\/strong>.<\/p>\n\n\n\n
        It has generated:<\/p>\n\n\n
        a statistically plausible Dockerfile\n<\/code><\/span><\/pre>\n\n\n
        InferenceFS turns that distinction into something you can literally mount.<\/p>\n\n\n\n
        \n\n\n\n
        6. Retrieval vs Inference<\/h1>\n\n\n\n
        This distinction is essential.<\/p>\n\n\n\n
        Retrieval<\/h2>\n\n\n\n
        A storage system normally performs:<\/p>\n\n\n
        identifier\n   \u2193\nretrieve stored bytes\n   \u2193\nexact original bytes\n<\/code><\/span><\/pre>\n\n\n
        Example:<\/p>\n\n\n
        \/foo.txt\n   \u2193\ndisk block 12345\n   \u2193\nHello world\n<\/code><\/span><\/pre>\n\n\n
        InferenceFS<\/h2>\n\n\n\n
        InferenceFS performs:<\/p>\n\n\n
        identifier\n   \u2193\nprompt LLM\n   \u2193\ngenerate probable contents\n<\/code><\/span><\/pre>\n\n\n
        Example:<\/p>\n\n\n
        \/foo.txt\n   \u2193\n\"What probably belongs in \/foo.txt?\"<\/span>\n   \u2193\nHello there!\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
        That is generation<\/strong>, not retrieval.<\/p>\n\n\n\n
        \n\n\n\n
        7. The Core Architecture<\/h1>\n\n\n\n
        InferenceFS can be represented as:<\/p>\n\n\n\n
                               Application\n                           |\n                    open\/read\/write\n                           |\n                           v\n                     Linux VFS\n                           |\n                           v\n                       FUSE 3\n                           |\n                           v\n                       pyfuse3\n                           |\n                           v\n                  +----------------+\n                  |  InferenceFS   |\n                  +----------------+\n                    \/      |      \\\n                   \/       |       \\\n                  v        v        v\n             Source     LRU Cache   LLM Backend\n            Directory                  |\n                                        |\n                        +---------------+---------------+\n                        |               |               |\n                        v               v               v\n                      Gemini          Claude       Claude Code\n<\/code><\/pre>\n\n\n\n
        The source directory contains real filesystem metadata.<\/p>\n\n\n\n
        The generated contents live primarily:<\/p>\n\n\n
        inside memory cache\n<\/code><\/span><\/pre>\n\n\n
        after generation.<\/p>\n\n\n\n
        \n\n\n\n
        8. Source Directory vs Mount Directory<\/h1>\n\n\n\n
        InferenceFS needs two important paths:<\/p>\n\n\n
        source\n<\/code><\/span><\/pre>\n\n\n
        and:<\/p>\n\n\n
        mountpoint\n<\/code><\/span><\/pre>\n\n\n
        Example:<\/p>\n\n\n
        mkdir -p \/tmp\/inference-source\nmkdir -p \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
        The source directory might contain:<\/p>\n\n\n
        \/tmp\/inference-source\/\n\u251c\u2500\u2500 hello.py\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 config.yaml\n\u2514\u2500\u2500 docs\/\n    \u2514\u2500\u2500 architecture.md\n<\/code><\/span><\/pre>\n\n\n
        You then mount:<\/p>\n\n\n
        \/tmp\/inference-source\n<\/code><\/span><\/pre>\n\n\n
        through InferenceFS at:<\/p>\n\n\n
        \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
        Applications access:<\/p>\n\n\n
        \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
        \n\n\n\n
        9. What Is Actually Stored?<\/h1>\n\n\n\n
        This deserves careful treatment.<\/p>\n\n\n\n
        InferenceFS does store real filesystem metadata:<\/p>\n\n\n\n
          \n
        • directory names,<\/li>\n\n\n\n
        • file names,<\/li>\n\n\n\n
        • paths,<\/li>\n\n\n\n
        • ownership,<\/li>\n\n\n\n
        • permissions,<\/li>\n\n\n\n
        • timestamps,<\/li>\n\n\n\n
        • directory structure,<\/li>\n\n\n\n
        • symbolic links,<\/li>\n\n\n\n
        • extended attributes where supported.<\/li>\n<\/ul>\n\n\n\n
          The source files can also contain numeric file-size metadata<\/strong> after writes.<\/p>\n\n\n\n
          What it does not<\/strong> store is the written payload.<\/p>\n\n\n\n
          So a file might physically contain:<\/p>\n\n\n
          27\n<\/code><\/span><\/pre>\n\n\n
          in the source directory.<\/p>\n\n\n\n
          That may mean:<\/p>\n\n\n
          \"The virtual file was written up to 27 bytes.\"<\/span>\n<\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
          It does not mean the virtual contents are \"27\"<\/code>.<\/p>\n\n\n\n
          The content comes from the LLM.<\/p>\n\n\n\n
          \n\n\n\n
          10. What Happens When You Create a File?<\/h1>\n\n\n\n
          Suppose:<\/p>\n\n\n
          touch \/mnt\/inference\/hello.py\n<\/code><\/span><\/pre>\n\n\n
          InferenceFS creates the corresponding source-side file.<\/p>\n\n\n\n
          Conceptually:<\/p>\n\n\n
          Mounted filesystem\n\n\/mnt\/inference\/hello.py\n\n            \u2193\n\nSource metadata\n\n\/source\/hello.py\n<\/code><\/span><\/pre>\n\n\n
          The file contents have not yet been generated.<\/p>\n\n\n\n
          This is important.<\/p>\n\n\n\n
          InferenceFS uses lazy generation<\/strong>.<\/p>\n\n\n\n
          The model is not queried merely because a file exists.<\/p>\n\n\n\n
          \n\n\n\n
          11. Lazy Content Generation<\/h1>\n\n\n\n
          The current implementation intentionally waits until:<\/p>\n\n\n
          read()\n<\/code><\/span><\/pre>\n\n\n
          before generating content.<\/p>\n\n\n\n
          It does not generate on:<\/p>\n\n\n
          create()\n<\/code><\/span><\/pre>\n\n\n
          or:<\/p>\n\n\n
          open()\n<\/code><\/span><\/pre>\n\n\n
          This avoids spending API calls on files that are never read.<\/p>\n\n\n\n
          Flow:<\/p>\n\n\n
          touch<\/span> file<\/span>.py<\/span>\n     \u2193\nmetadata<\/span> created<\/span>\n     \u2193\nNO<\/span> model<\/span> call<\/span>\n\nopen<\/span> file<\/span>.py<\/span>\n     \u2193\nNO<\/span> model<\/span> call<\/span>\n\nread<\/span> file<\/span>.py<\/span>\n     \u2193\nmodel<\/span> call<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          This is a solid systems-design choice even though the project itself is intentionally absurd.<\/p>\n\n\n\n
          \n\n\n\n
          12. What Happens During a Read?<\/h1>\n\n\n\n
          Suppose:<\/p>\n\n\n
          cat \/mnt\/inference\/hello.py\n<\/code><\/span><\/pre>\n\n\n
          The flow becomes:<\/p>\n\n\n
          cat\n \u2193\nLinux VFS\n \u2193\nFUSE\n \u2193\npyfuse3\n \u2193\nInferenceFS.read()\n \u2193\n_check cache\n \u2193\ncache miss\n \u2193\n_generate_content(\"\/hello.py\"<\/span>)\n \u2193\nLLM backend\n \u2193\ngenerated bytes\n \u2193\nLRU cache\n \u2193\nread requested slice\n \u2193\ncat\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          The core implementation effectively performs:<\/p>\n\n\n
          content = await<\/span> self._ensure_content(fd)\nreturn<\/span> content[offset:offset + length]\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          and _ensure_content()<\/code> consults the LRU cache before requesting generation.<\/p>\n\n\n\n
          \n\n\n\n
          13. The Prompt<\/h1>\n\n\n\n
          The current source uses the core user prompt:<\/p>\n\n\n
          What is the most likely contents of<\/span> a file with<\/span> the name {filename}\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          The path might therefore transform into:<\/p>\n\n\n
          What is the most likely contents of<\/span> a file with<\/span> the name \/src\/main.py\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          or:<\/p>\n\n\n
          What is the most likely contents of<\/span> a file with<\/span> the name \/kubernetes\/deployment.yaml\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          The filename and directory structure effectively become prompt engineering.<\/p>\n\n\n\n
          \n\n\n\n
          14. Directory Names Matter<\/h1>\n\n\n\n
          This means:<\/p>\n\n\n
          \/app\/config.yaml\n<\/code><\/span><\/pre>\n\n\n
          may generate something different from:<\/p>\n\n\n
          \/kubernetes\/config.yaml\n<\/code><\/span><\/pre>\n\n\n
          or:<\/p>\n\n\n
          \/prometheus\/config.yaml\n<\/code><\/span><\/pre>\n\n\n
          because InferenceFS sends the relative path rather than merely the basename.<\/p>\n\n\n\n
          That gives the model contextual hints.<\/p>\n\n\n\n
          For example:<\/p>\n\n\n
          \/nginx\/nginx.conf\n<\/code><\/span><\/pre>\n\n\n
          is strongly suggestive.<\/p>\n\n\n\n
          So is:<\/p>\n\n\n
          \/terraform\/main.tf\n<\/code><\/span><\/pre>\n\n\n
          or:<\/p>\n\n\n
          \/python\/requirements.txt\n<\/code><\/span><\/pre>\n\n\n
          The directory hierarchy effectively becomes part of your prompt.<\/p>\n\n\n\n
          \n\n\n\n
          15. Filenames Become an API<\/h1>\n\n\n\n
          In a normal filesystem:<\/p>\n\n\n
          filename = identifier\n<\/code><\/span><\/pre>\n\n\n
          With InferenceFS:<\/p>\n\n\n
          filename = identifier + prompt\n<\/code><\/span><\/pre>\n\n\n
          That is a very unusual design property.<\/p>\n\n\n\n
          Naming files becomes equivalent to specifying desired output.<\/p>\n\n\n\n
          Compare:<\/p>\n\n\n
          config<\/span>.yaml<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          with:<\/p>\n\n\n
          kubernetes-production-nginx-config<\/span>.yaml<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          The second provides much more semantic information to the model.<\/p>\n\n\n\n
          \n\n\n\n
          16. Supported LLM Backends<\/h1>\n\n\n\n
          The current implementation has three registered backends:<\/p>\n\n\n
          claude\nclaude-code\ngemini\n<\/code><\/span><\/pre>\n\n\n
          Usage:<\/p>\n\n\n
          inferencefs --backend gemini SOURCE MOUNTPOINT\n<\/code><\/span><\/pre>\n\n\n
          or:<\/p>\n\n\n
          inferencefs --backend claude SOURCE MOUNTPOINT\n<\/code><\/span><\/pre>\n\n\n
          or:<\/p>\n\n\n
          inferencefs --backend claude-code SOURCE MOUNTPOINT\n<\/code><\/span><\/pre>\n\n\n
          \n\n\n\n
          17. Google Gemini Backend<\/h1>\n\n\n\n
          The project README currently recommends the Gemini backend.<\/p>\n\n\n\n
          Example:<\/p>\n\n\n
          export<\/span> API_KEY=\"YOUR_API_KEY\"<\/span>\n\ninferencefs \\\n    --backend gemini \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          The current main branch hard-codes:<\/p>\n\n\n
          gemini-3<\/span>.1-flash-lite-preview<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          inside the implementation at the time of this review.<\/p>\n\n\n\n
          Because model availability and provider pricing change frequently, treat that model identifier as an implementation detail of the current repository rather than a permanent interface.<\/p>\n\n\n\n
          \n\n\n\n
          18. Claude API Backend<\/h1>\n\n\n\n
          Claude can be used directly:<\/p>\n\n\n
          export<\/span> API_KEY=\"YOUR_ANTHROPIC_KEY\"<\/span>\n\ninferencefs \\\n    --backend claude \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          The current source uses:<\/p>\n\n\n
          claude-sonnet-4-20250514\n<\/code><\/span><\/pre>\n\n\n
          for that backend.<\/p>\n\n\n\n
          Again, model IDs are vendor-specific implementation details and may change in future project versions.<\/p>\n\n\n\n
          \n\n\n\n
          19. Claude Code Backend<\/h1>\n\n\n\n
          InferenceFS can also call the locally installed Claude Code CLI:<\/p>\n\n\n
          inferencefs \\\n    --backend claude-code \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
          This backend does not use API_KEY<\/code> through InferenceFS.<\/p>\n\n\n\n
          Instead, it shells out to:<\/p>\n\n\n
          claude\n<\/code><\/span><\/pre>\n\n\n
          and relies on Claude Code’s existing authentication.<\/p>\n\n\n\n
          The implementation calls the CLI in noninteractive mode using JSON output and a one-turn request.<\/p>\n\n\n\n
          You therefore need the claude<\/code> command installed, authenticated and visible in your PATH<\/code>.<\/p>\n\n\n\n
          \n\n\n\n
          20. Backend Interface<\/h1>\n\n\n\n
          Internally, each backend implements:<\/p>\n\n\n
          generate_file_contents(filename<\/span>: str) -> bytes\n<\/code><\/span>Code language:<\/span> HTTP<\/span> (<\/span>http<\/span>)<\/span><\/small><\/pre>\n\n\n
          Conceptually:<\/p>\n\n\n\n
                            ContentGenerator\n                         |\n        +----------------+---------------+\n        |                |               |\n        v                v               v\n     Claude         Claude Code       Gemini\n<\/code><\/pre>\n\n\n\n
          This is clean separation.<\/p>\n\n\n\n
          The FUSE layer does not need to understand the model provider.<\/p>\n\n\n\n
          It simply asks:<\/p>\n\n\n
          generate_file_contents(filename)\n<\/code><\/span><\/pre>\n\n\n
          and expects bytes.<\/p>\n\n\n\n
          \n\n\n\n
          21. Installation Requirements<\/h1>\n\n\n\n
          As of September 2026, the PyPI project declares:<\/p>\n\n\n
          Python >= 3.14\n<\/code><\/span><\/pre>\n\n\n
          and dependencies including:<\/p>\n\n\n
          anthropic >= 0.40.0\ngoogle-genai >= 1.68.0\npyfuse3 >= 3.4.2\ntrio >= 0.33.0\n<\/code><\/span><\/pre>\n\n\n
          Because pyfuse3<\/code> interfaces with native FUSE libraries, Linux development packages are also required.<\/p>\n\n\n\n
          The project’s developer instructions call out:<\/p>\n\n\n
          libfuse3-dev\npkg-config\nbuild-essential\n<\/code><\/span><\/pre>\n\n\n
          \n\n\n\n
          22. Recommended Platform<\/h1>\n\n\n\n
          The easiest environment is:<\/p>\n\n\n
          Linux\n<\/code><\/span><\/pre>\n\n\n
          preferably:<\/p>\n\n\n
          Ubuntu \/ Debian\n<\/code><\/span><\/pre>\n\n\n
          with FUSE 3.<\/p>\n\n\n\n
          InferenceFS uses:<\/p>\n\n\n
          pyfuse3\n<\/code><\/span><\/pre>\n\n\n
          rather than the older FUSE 2 architecture used by \u03c0fs.<\/p>\n\n\n\n
          This is a much more modern foundation.<\/p>\n\n\n\n
          \n\n\n\n
          23. Install FUSE 3 on Ubuntu\/Debian<\/h1>\n\n\n\n
          Install the system prerequisites:<\/p>\n\n\n
          sudo apt update\n\nsudo apt install -y \\\n    fuse3 \\\n    libfuse3-dev \\\n    pkg-config \\\n    build-essential\n<\/code><\/span><\/pre>\n\n\n
          Verify:<\/p>\n\n\n
          fusermount3 --version\n<\/code><\/span><\/pre>\n\n\n
          Check the FUSE device:<\/p>\n\n\n
          ls -l \/dev\/fuse\n<\/code><\/span><\/pre>\n\n\n
          You should normally have:<\/p>\n\n\n
          \/dev\/fuse\n<\/code><\/span><\/pre>\n\n\n
          available.<\/p>\n\n\n\n
          \n\n\n\n
          24. Python 3.14 Requirement<\/h1>\n\n\n\n
          InferenceFS currently requires:<\/p>\n\n\n
          Python >= 3.14\n<\/code><\/span><\/pre>\n\n\n
          This is important because many stable Linux distributions may have an older system Python.<\/p>\n\n\n\n
          Do not replace your operating system Python just to run InferenceFS.<\/p>\n\n\n\n
          A separate virtual environment or Python version manager is safer.<\/p>\n\n\n\n
          Using uv<\/code> is particularly convenient because the project itself uses it.<\/p>\n\n\n\n
          \n\n\n\n
          25. Install From PyPI<\/h1>\n\n\n\n
          The current published release is:<\/p>\n\n\n
          InferenceFS<\/span> 1.0<\/span>.0<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          released:<\/p>\n\n\n
          April 1, 2026\n<\/code><\/span><\/pre>\n\n\n
          With an existing Python 3.14 environment:<\/p>\n\n\n
          python --version\n<\/code><\/span><\/pre>\n\n\n
          Confirm:<\/p>\n\n\n
          Python<\/span> 3.14<\/span>.x<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          Then:<\/p>\n\n\n
          python -m venv .venv\nsource .venv\/bin\/activate\n\npip install --upgrade pip\npip install inferencefs\n<\/code><\/span><\/pre>\n\n\n
          Verify:<\/p>\n\n\n
          inferencefs --help\n<\/code><\/span><\/pre>\n\n\n
          \n\n\n\n
          26. Install Using uv<\/code><\/h1>\n\n\n\n
          A clean setup is:<\/p>\n\n\n
          uv<\/span> python<\/span> install<\/span> 3.14<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          Create a virtual environment:<\/p>\n\n\n
          uv<\/span> venv<\/span> --python<\/span> 3.14<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          Activate it:<\/p>\n\n\n
          source .venv\/bin\/activate\n<\/code><\/span><\/pre>\n\n\n
          Install:<\/p>\n\n\n
          uv pip install inferencefs\n<\/code><\/span><\/pre>\n\n\n
          Then:<\/p>\n\n\n
          inferencefs --help\n<\/code><\/span><\/pre>\n\n\n
          \n\n\n\n
          27. Install From Source<\/h1>\n\n\n\n
          For development or source inspection:<\/p>\n\n\n
          git clone<\/span> https:\/\/github.com\/philipl\/inferencefs.git<\/span>\ncd inferencefs\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
          Then:<\/p>\n\n\n
          uv sync\n<\/code><\/span><\/pre>\n\n\n
          The project itself documents this workflow.<\/p>\n\n\n\n
          Run:<\/p>\n\n\n
          uv run inferencefs --help\n<\/code><\/span><\/pre>\n\n\n
          Run the tests:<\/p>\n\n\n
          uv run pytest\n<\/code><\/span><\/pre>\n\n\n
          Lint:<\/p>\n\n\n
          uv run ruff check src tests\n<\/code><\/span><\/pre>\n\n\n
          The repository documents both test and lint commands.<\/p>\n\n\n\n
          \n\n\n\n
          28. Project Structure<\/h1>\n\n\n\n
          The core repository is simple:<\/p>\n\n\n
          inferencefs\/\n\u251c\u2500\u2500 src\/\n\u2502   \u2514\u2500\u2500 inferencefs\/\n\u2502       \u251c\u2500\u2500 __init__.py\n\u2502       \u251c\u2500\u2500 inferencefs.py\n\u2502       \u251c\u2500\u2500 backends.py\n\u2502       \u2514\u2500\u2500 main.py\n\u2502\n\u251c\u2500\u2500 tests\/\n\u2502   \u251c\u2500\u2500 test_main.py\n\u2502   \u251c\u2500\u2500 test_inferencefs.py\n\u2502   \u2514\u2500\u2500 test_backends.py\n\u2502\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 appendix.md\n\u251c\u2500\u2500 CLAUDE.md\n\u251c\u2500\u2500 pyproject.toml\n\u2514\u2500\u2500 LICENSE\n<\/code><\/span><\/pre>\n\n\n
          \n\n\n\n
          29. Main Components<\/h1>\n\n\n\n
          main.py<\/code><\/h2>\n\n\n\n
          Handles:<\/p>\n\n\n\n
            \n
          • CLI arguments,<\/li>\n\n\n\n
          • backend selection,<\/li>\n\n\n\n
          • API key loading,<\/li>\n\n\n\n
          • FUSE options,<\/li>\n\n\n\n
          • logging,<\/li>\n\n\n\n
          • FUSE initialization,<\/li>\n\n\n\n
          • Trio event loop,<\/li>\n\n\n\n
          • clean unmount.<\/li>\n<\/ul>\n\n\n\n
            inferencefs.py<\/code><\/h2>\n\n\n\n
            Implements:<\/p>\n\n\n\n
              \n
            • FUSE operations,<\/li>\n\n\n\n
            • inode tracking,<\/li>\n\n\n\n
            • path mapping,<\/li>\n\n\n\n
            • reads,<\/li>\n\n\n\n
            • writes,<\/li>\n\n\n\n
            • caching,<\/li>\n\n\n\n
            • directory operations,<\/li>\n\n\n\n
            • persisted size metadata,<\/li>\n\n\n\n
            • rate-limit handling.<\/li>\n<\/ul>\n\n\n\n
              backends.py<\/code><\/h2>\n\n\n\n
              Implements:<\/p>\n\n\n\n
                \n
              • backend abstraction,<\/li>\n\n\n\n
              • Claude API,<\/li>\n\n\n\n
              • Claude Code,<\/li>\n\n\n\n
              • Gemini,<\/li>\n\n\n\n
              • text\/binary response handling,<\/li>\n\n\n\n
              • base64 recovery,<\/li>\n\n\n\n
              • magic-byte detection.<\/li>\n<\/ul>\n\n\n\n
                \n\n\n\n
                30. Your First InferenceFS Filesystem<\/h1>\n\n\n\n
                Create two directories:<\/p>\n\n\n
                mkdir -p \/tmp\/inference-source\nmkdir -p \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                Set your Gemini API key:<\/p>\n\n\n
                export<\/span> API_KEY=\"YOUR_API_KEY\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                Mount:<\/p>\n\n\n
                inferencefs \\\n    --backend gemini \\\n    \/tmp\/inference-source \\\n    \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                If running from source:<\/p>\n\n\n
                uv run inferencefs \\\n    --backend gemini \\\n    \/tmp\/inference-source \\\n    \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                \n\n\n\n
                31. Create Your First File<\/h1>\n\n\n\n
                From another terminal:<\/p>\n\n\n
                touch \/tmp\/inference-mount\/hello.py\n<\/code><\/span><\/pre>\n\n\n
                Now:<\/p>\n\n\n
                ls -l \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                The interesting part happens when you read it:<\/p>\n\n\n
                cat \/tmp\/inference-mount\/hello.py\n<\/code><\/span><\/pre>\n\n\n
                InferenceFS asks the model what \/hello.py<\/code> should probably contain.<\/p>\n\n\n\n
                You might receive something like:<\/p>\n\n\n
                def main():\n    print<\/span>(\"Hello, World!\"<\/span>)\n\n\nif<\/span> __name__ == \"__main__\"<\/span>:\n    main()\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                The exact output is model-dependent.<\/p>\n\n\n\n
                \n\n\n\n
                32. Try Different Filename Semantics<\/h1>\n\n\n\n
                Create:<\/p>\n\n\n
                touch \/tmp\/inference-mount\/requirements.txt\n<\/code><\/span><\/pre>\n\n\n
                Read:<\/p>\n\n\n
                cat \/tmp\/inference-mount\/requirements.txt\n<\/code><\/span><\/pre>\n\n\n
                Then:<\/p>\n\n\n
                touch \/tmp\/inference-mount\/Dockerfile\ncat \/tmp\/inference-mount\/Dockerfile\n<\/code><\/span><\/pre>\n\n\n
                Then:<\/p>\n\n\n
                touch \/tmp\/inference-mount\/docker-compose.yaml\ncat \/tmp\/inference-mount\/docker-compose.yaml\n<\/code><\/span><\/pre>\n\n\n
                Then:<\/p>\n\n\n
                touch \/tmp\/inference-mount\/index.html\ncat \/tmp\/inference-mount\/index.html\n<\/code><\/span><\/pre>\n\n\n
                This is where InferenceFS becomes fascinating.<\/p>\n\n\n\n
                The filesystem effectively exposes the model’s priors about common filenames.<\/p>\n\n\n\n
                \n\n\n\n
                33. Contextual Path Experiment<\/h1>\n\n\n\n
                Try:<\/p>\n\n\n
                mkdir -p \/tmp\/inference-mount\/kubernetes\ntouch \/tmp\/inference-mount\/kubernetes\/deployment.yaml\n<\/code><\/span><\/pre>\n\n\n
                Then:<\/p>\n\n\n
                cat \/tmp\/inference-mount\/kubernetes\/deployment.yaml\n<\/code><\/span><\/pre>\n\n\n
                Compare with:<\/p>\n\n\n
                mkdir -p \/tmp\/inference-mount\/github\ntouch \/tmp\/inference-mount\/github\/deployment.yaml\n\ncat \/tmp\/inference-mount\/github\/deployment.yaml\n<\/code><\/span><\/pre>\n\n\n
                The same basename may generate different content because the relative path provides context.<\/p>\n\n\n\n
                That is a great demonstration of prompt conditioning.<\/p>\n\n\n\n
                \n\n\n\n
                34. Configuration Options<\/h1>\n\n\n\n
                The current CLI accepts approximately:<\/p>\n\n\n
                inferencefs<\/span>\n    [--backend {claude,claude-code,gemini}]<\/span>\n    [--api-key API_KEY]<\/span>\n    [--max-tokens MAX_TOKENS]<\/span>\n    [--cache-size CACHE_SIZE_MIB]<\/span>\n    [-d]<\/span>\n    [-o OPTIONS]<\/span>\n    source<\/span>\n    mountpoint<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                The source currently defaults the backend to:<\/p>\n\n\n
                claude\n<\/code><\/span><\/pre>\n\n\n
                although the README recommends Gemini for its preferred experience.<\/p>\n\n\n\n
                \n\n\n\n
                35. --backend<\/code><\/h1>\n\n\n\n
                Choose the content generator:<\/p>\n\n\n
                --backend gemini\n<\/code><\/span><\/pre>\n\n\n
                or:<\/p>\n\n\n
                --backend claude\n<\/code><\/span><\/pre>\n\n\n
                or:<\/p>\n\n\n
                --backend claude-code\n<\/code><\/span><\/pre>\n\n\n
                \n\n\n\n
                36. --api-key<\/code><\/h1>\n\n\n\n
                Instead of using:<\/p>\n\n\n
                export<\/span> API_KEY=...\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                you may provide:<\/p>\n\n\n
                inferencefs \\\n    --backend gemini \\\n    --api-key \"...\"<\/span> \\\n    SOURCE \\\n    MOUNT\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                For security, environment variables or a secure secrets mechanism are generally preferable to putting secrets directly into command lines, because command arguments may be visible in process listings or shell history.<\/p>\n\n\n\n
                \n\n\n\n
                37. API_KEY<\/code><\/h1>\n\n\n\n
                If --api-key<\/code> is absent, the current CLI checks:<\/p>\n\n\n
                API_KEY\n<\/code><\/span><\/pre>\n\n\n
                from the environment.<\/p>\n\n\n\n
                Example:<\/p>\n\n\n
                export<\/span> API_KEY=\"$(cat ~\/.config\/inferencefs\/gemini-key)\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                Then:<\/p>\n\n\n
                inferencefs --backend gemini source mount\n<\/code><\/span><\/pre>\n\n\n
                \n\n\n\n
                38. --max-tokens<\/code><\/h1>\n\n\n\n
                Control maximum model output:<\/p>\n\n\n
                --max-tokens 2048\n<\/code><\/span><\/pre>\n\n\n
                Example:<\/p>\n\n\n
                inferencefs \\\n    --backend gemini \\\n    --max-tokens 2048 \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                The backend default is currently:<\/p>\n\n\n
                4096\n<\/code><\/span><\/pre>\n\n\n
                tokens.<\/p>\n\n\n\n
                Larger limits can:<\/p>\n\n\n\n
                  \n
                • generate larger files,<\/li>\n\n\n\n
                • increase latency,<\/li>\n\n\n\n
                • increase provider cost,<\/li>\n\n\n\n
                • consume more cache memory.<\/li>\n<\/ul>\n\n\n\n
                  \n\n\n\n
                  39. --cache-size<\/code><\/h1>\n\n\n\n
                  InferenceFS uses an in-memory LRU cache<\/strong>.<\/p>\n\n\n\n
                  Default:<\/p>\n\n\n
                  256 MiB\n<\/code><\/span><\/pre>\n\n\n
                  Override:<\/p>\n\n\n
                  --cache-size 64\n<\/code><\/span><\/pre>\n\n\n
                  for:<\/p>\n\n\n
                  64 MiB\n<\/code><\/span><\/pre>\n\n\n
                  Example:<\/p>\n\n\n
                  inferencefs \\\n    --backend gemini \\\n    --cache-size 64 \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                  \n\n\n\n
                  40. Why the Cache Matters<\/h1>\n\n\n\n
                  Without caching:<\/p>\n\n\n
                  read file\n \u2193\nAPI request\n\nread again\n \u2193\nanother API request\n\nread again\n \u2193\nanother API request\n<\/code><\/span><\/pre>\n\n\n
                  That would be:<\/p>\n\n\n\n
                    \n
                  • slow,<\/li>\n\n\n\n
                  • expensive,<\/li>\n\n\n\n
                  • inconsistent.<\/li>\n<\/ul>\n\n\n\n
                    Instead:<\/p>\n\n\n
                    first read\n \u2193\nLLM request\n \u2193\ncache\n\nsecond read\n \u2193\ncache hit\n<\/code><\/span><\/pre>\n\n\n
                    The LRU policy removes older entries when the memory limit is exceeded.<\/p>\n\n\n\n
                    \n\n\n\n
                    41. Important Cache Consequence<\/h1>\n\n\n\n
                    The cache provides temporary consistency.<\/p>\n\n\n\n
                    Suppose:<\/p>\n\n\n
                    \/config.yaml\n<\/code><\/span><\/pre>\n\n\n
                    generates:<\/p>\n\n\n
                    port<\/span>: 8080\n<\/code><\/span>Code language:<\/span> HTTP<\/span> (<\/span>http<\/span>)<\/span><\/small><\/pre>\n\n\n
                    While that content remains cached, reads generally see the same bytes.<\/p>\n\n\n\n
                    But if:<\/p>\n\n\n\n
                      \n
                    • the process restarts,<\/li>\n\n\n\n
                    • the filesystem is unmounted\/remounted,<\/li>\n\n\n\n
                    • or the cache entry is evicted,<\/li>\n<\/ul>\n\n\n\n
                      InferenceFS may query the model again.<\/p>\n\n\n\n
                      The new result might be:<\/p>\n\n\n
                      port<\/span>: 3000\n<\/code><\/span>Code language:<\/span> HTTP<\/span> (<\/span>http<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Therefore:<\/p>\n\n\n\n
                      \n
                      A filename does not permanently identify a particular byte sequence.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
                      This is radically different from ordinary storage.<\/p>\n\n\n\n
                      \n\n\n\n
                      42. Cache Eviction Means Data Mutation<\/h1>\n\n\n\n
                      Consider:<\/p>\n\n\n
                      read A\n\u2193\ngenerate A1\n\ncache fills\n\nA evicted\n\nread A\n\u2193\ngenerate A2\n<\/code><\/span><\/pre>\n\n\n
                      Potentially:<\/p>\n\n\n
                      A1 != A2\n<\/code><\/span><\/pre>\n\n\n
                      No rename.<\/p>\n\n\n\n
                      No write.<\/p>\n\n\n\n
                      No modification timestamp change required.<\/p>\n\n\n\n
                      The \u201cfile\u201d simply changed because inference was performed again.<\/p>\n\n\n\n
                      That is completely unacceptable for real persistent storage\u2014but fantastic for demonstrating why generative output is not retrieval.<\/p>\n\n\n\n
                      \n\n\n\n
                      43. Debug Mode<\/h1>\n\n\n\n
                      Run:<\/p>\n\n\n
                      inferencefs \\\n    -d \\\n    --backend gemini \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                      The CLI enables debug-level logging and adds the FUSE debug option.<\/p>\n\n\n\n
                      This is recommended while learning the project.<\/p>\n\n\n\n
                      You can observe when content is:<\/p>\n\n\n
                      Generating content for \/something.txt\n<\/code><\/span><\/pre>\n\n\n
                      rather than served from cache.<\/p>\n\n\n\n
                      \n\n\n\n
                      44. Standard FUSE Options<\/h1>\n\n\n\n
                      InferenceFS accepts:<\/p>\n\n\n
                      -o OPTIONS\n<\/code><\/span><\/pre>\n\n\n
                      with comma-separated FUSE options.<\/p>\n\n\n\n
                      Example conceptually:<\/p>\n\n\n
                      -o option1,option2\n<\/code><\/span><\/pre>\n\n\n
                      These are passed through to pyfuse3<\/code>.<\/p>\n\n\n\n
                      The program also sets:<\/p>\n\n\n
                      fsname=inferencefs\n<\/code><\/span><\/pre>\n\n\n
                      on the mount.<\/p>\n\n\n\n
                      \n\n\n\n
                      45. How Writes Actually Work<\/h1>\n\n\n\n
                      This is one of the best parts of the project.<\/p>\n\n\n\n
                      Consider:<\/p>\n\n\n
                      printf \"HELLO\"<\/span> > \/tmp\/i<\/span>nference-mount\/test.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                      The application’s write()<\/code> call sends five bytes:<\/p>\n\n\n
                      H E L L O\n<\/code><\/span><\/pre>\n\n\n
                      InferenceFS receives them.<\/p>\n\n\n\n
                      But its implementation essentially does:<\/p>\n\n\n
                      end = offset + len(buf)\n\nif<\/span> end > previous_size:\n    written_size = end\n\nreturn<\/span> len(buf)\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                      The buf<\/code> itself is discarded.<\/p>\n\n\n\n
                      The program sees a successful write.<\/p>\n\n\n\n
                      The data disappears.<\/p>\n\n\n\n
                      \n\n\n\n
                      46. The Ultimate \/dev\/null<\/code> With Confidence<\/h1>\n\n\n\n
                      You can think of InferenceFS writes approximately as:<\/p>\n\n\n
                      \/dev\/null<\/span>\n+\nfile-size tracking\n+\nfuture hallucination\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                      That is slightly simplified but captures the spirit.<\/p>\n\n\n\n
                      \n\n\n\n
                      47. Written Size Persistence<\/h1>\n\n\n\n
                      Why track the written size?<\/p>\n\n\n\n
                      Suppose an application writes:<\/p>\n\n\n
                      100 bytes\n<\/code><\/span><\/pre>\n\n\n
                      The system may later call:<\/p>\n\n\n
                      stat()\n<\/code><\/span><\/pre>\n\n\n
                      and expect the file size to be:<\/p>\n\n\n
                      100\n<\/code><\/span><\/pre>\n\n\n
                      InferenceFS therefore records the high-water mark.<\/p>\n\n\n\n
                      When the file descriptor is released, the size may be written to the corresponding source file as an ASCII integer.<\/p>\n\n\n\n
                      For example:<\/p>\n\n\n
                      source\/test.txt\n<\/code><\/span><\/pre>\n\n\n
                      might physically contain:<\/p>\n\n\n
                      100\n<\/code><\/span><\/pre>\n\n\n
                      That means:<\/p>\n\n\n
                      virtual apparent size = 100 bytes\n<\/code><\/span><\/pre>\n\n\n
                      not:<\/p>\n\n\n
                      virtual content = \"100\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                      \n\n\n\n
                      48. File Size Priority<\/h1>\n\n\n\n
                      The implementation determines regular-file size approximately in this order:<\/p>\n\n\n
                      1. generated content exists in cache\n       \u2193\n   actual generated content length\n\n2. current written size exists in memory\n       \u2193\n   written high-water mark\n\n3. persisted numeric size exists in source file\n       \u2193\n   persisted size\n\n4. otherwise\n       \u2193\n   fake size\n<\/code><\/span><\/pre>\n\n\n
                      \n\n\n\n
                      49. Why Unread Files Pretend to Be 1 GiB<\/h1>\n\n\n\n
                      This is a clever implementation hack.<\/p>\n\n\n\n
                      An empty source file normally reports:<\/p>\n\n\n
                      size = 0\n<\/code><\/span><\/pre>\n\n\n
                      Some applications might therefore decide there is nothing to read.<\/p>\n\n\n\n
                      InferenceFS instead reports unread regular files as:<\/p>\n\n\n
                      1 GiB\n<\/code><\/span><\/pre>\n\n\n
                      using:<\/p>\n\n\n
                      1 << 30\n<\/code><\/span><\/pre>\n\n\n
                      until content has actually been generated.<\/p>\n\n\n\n
                      That encourages programs to call:<\/p>\n\n\n
                      read()\n<\/code><\/span><\/pre>\n\n\n
                      where the actual content can be generated.<\/p>\n\n\n\n
                      When the generated stream returns EOF, the application discovers the real end.<\/p>\n\n\n\n
                      \n\n\n\n
                      50. A Beautiful Filesystem Hack<\/h1>\n\n\n\n
                      This illustrates a broader systems principle.<\/p>\n\n\n\n
                      Sometimes metadata cannot be known until an expensive operation occurs.<\/p>\n\n\n\n
                      InferenceFS essentially says:<\/p>\n\n\n
                      \"I don't know the real size yet,\nbut please try reading.\"<\/span>\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                      So it supplies a large placeholder.<\/p>\n\n\n\n
                      It is a clever example of lazy metadata resolution.<\/p>\n\n\n\n
                      \n\n\n\n
                      51. Async Architecture<\/h1>\n\n\n\n
                      InferenceFS uses:<\/p>\n\n\n
                      Trio\n<\/code><\/span><\/pre>\n\n\n
                      because pyfuse3<\/code> operates asynchronously.<\/p>\n\n\n\n
                      The problem is that LLM SDK\/API calls may block.<\/p>\n\n\n\n
                      So the implementation runs model generation using:<\/p>\n\n\n
                      trio<\/span>.to_thread<\/span>.run_sync<\/span>(...)\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Architecture:<\/p>\n\n\n
                      FUSE async<\/span> loop\n      |\n      +---- ordinary FS operation\n      |\n      +---- LLM call\n                |\n                v\n         worker thread\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                      This avoids blocking the Trio event loop while waiting for remote inference.<\/p>\n\n\n\n
                      \n\n\n\n
                      52. Rate-Limit Handling<\/h1>\n\n\n\n
                      InferenceFS recognizes rate-limit conditions.<\/p>\n\n\n\n
                      Its generation flow can retry:<\/p>\n\n\n
                      up to 3 retries\n<\/code><\/span><\/pre>\n\n\n
                      after the first request attempt.<\/p>\n\n\n\n
                      For Gemini, it looks for signals such as:<\/p>\n\n\n
                      429\nRESOURCE_EXHAUSTED\nretryDelay\n<\/code><\/span><\/pre>\n\n\n
                      For Anthropic, it recognizes rate-limit exception naming and attempts to derive a retry delay.<\/p>\n\n\n\n
                      This is another example where the joke project contains real engineering.<\/p>\n\n\n\n
                      \n\n\n\n
                      53. Failure Behavior<\/h1>\n\n\n\n
                      If content generation ultimately fails, the FUSE layer raises:<\/p>\n\n\n
                      EIO\n<\/code><\/span><\/pre>\n\n\n
                      or:<\/p>\n\n\n
                      I\/O error\n<\/code><\/span><\/pre>\n\n\n
                      to the calling program.<\/p>\n\n\n\n
                      That makes sense.<\/p>\n\n\n\n
                      From a filesystem consumer’s point of view:<\/p>\n\n\n
                      the storage backend failed\n<\/code><\/span><\/pre>\n\n\n
                      even though the \u201cstorage backend\u201d happens to be an LLM.<\/p>\n\n\n\n
                      \n\n\n\n
                      54. Binary File Support<\/h1>\n\n\n\n
                      InferenceFS does not restrict itself to text.<\/p>\n\n\n\n
                      Its system prompt instructs models:<\/p>\n\n\n
                      text file\n   \u2193\nreturn<\/span> raw text\n\nbinary file\n   \u2193\nreturn<\/span> base64-encoded binary\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                      The client then attempts to detect and decode base64.<\/p>\n\n\n\n
                      This allows experiments such as:<\/p>\n\n\n
                      touch \/tmp\/inference-mount\/image.png\n<\/code><\/span><\/pre>\n\n\n
                      then:<\/p>\n\n\n
                      cp \/tmp\/inference-mount\/image.png \/tmp\/test.png\n<\/code><\/span><\/pre>\n\n\n
                      Whether the result is actually useful is another matter.<\/p>\n\n\n\n
                      \n\n\n\n
                      55. Binary Response Decoder<\/h1>\n\n\n\n
                      The response decoder is more sophisticated than you might expect.<\/p>\n\n\n\n
                      It tries multiple strategies:<\/p>\n\n\n\n
                      Strategy 1<\/h3>\n\n\n\n
                      Strictly decode the entire response as base64.<\/p>\n\n\n\n
                      Strategy 2<\/h3>\n\n\n\n
                      Repair likely missing\/truncated padding.<\/p>\n\n\n\n
                      Strategy 3<\/h3>\n\n\n\n
                      Remove a small number of hallucinated non-base64 characters.<\/p>\n\n\n\n
                      Strategy 4<\/h3>\n\n\n\n
                      Find the longest base64-looking block within mixed text.<\/p>\n\n\n\n
                      Strategy 5<\/h3>\n\n\n\n
                      If no valid binary payload can be established, treat the response as UTF-8 text.<\/p>\n\n\n\n
                      \n\n\n\n
                      56. Binary Magic Bytes<\/h1>\n\n\n\n
                      To avoid interpreting ordinary text as binary, InferenceFS checks decoded content for known magic bytes.<\/p>\n\n\n\n
                      The current table recognizes signatures associated with formats such as:<\/p>\n\n\n\n
                        \n
                      • PNG<\/li>\n\n\n\n
                      • GIF<\/li>\n\n\n\n
                      • JPEG<\/li>\n\n\n\n
                      • ZIP<\/li>\n\n\n\n
                      • PDF<\/li>\n\n\n\n
                      • ELF<\/li>\n\n\n\n
                      • PE\/MZ<\/li>\n\n\n\n
                      • WebAssembly<\/li>\n\n\n\n
                      • Mach-O<\/li>\n\n\n\n
                      • gzip<\/li>\n\n\n\n
                      • bzip2<\/li>\n\n\n\n
                      • xz<\/li>\n\n\n\n
                      • 7-Zip<\/li>\n\n\n\n
                      • RIFF<\/li>\n\n\n\n
                      • ICO<\/li>\n\n\n\n
                      • BMP<\/li>\n\n\n\n
                      • RAR<\/li>\n<\/ul>\n\n\n\n
                        It also checks for non-printable bytes.<\/p>\n\n\n\n
                        \n\n\n\n
                        57. Why Binary Generation Is Fascinating<\/h1>\n\n\n\n
                        Text-generation models are naturally good at formats such as:<\/p>\n\n\n
                        .py<\/span>\n.yaml<\/span>\n.json<\/span>\n.html<\/span>\n.ini<\/span>\n.csv<\/span>\n.md<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                        because these formats are represented directly as textual tokens in massive quantities of training data.<\/p>\n\n\n\n
                        Binary data is different.<\/p>\n\n\n\n
                        To construct:<\/p>\n\n\n
                        PNG\nZIP\ngzip\nSQLite\nFLAC\nELF\n<\/code><\/span><\/pre>\n\n\n
                        the model may need to maintain:<\/p>\n\n\n\n
                          \n
                        • exact bytes,<\/li>\n\n\n\n
                        • checksums,<\/li>\n\n\n\n
                        • offsets,<\/li>\n\n\n\n
                        • compressed streams,<\/li>\n\n\n\n
                        • length fields,<\/li>\n\n\n\n
                        • indexes,<\/li>\n\n\n\n
                        • internal references,<\/li>\n\n\n\n
                        • codec constraints.<\/li>\n<\/ul>\n\n\n\n
                          That is much harder than predicting plausible textual syntax.<\/p>\n\n\n\n
                          \n\n\n\n
                          58. Binary Formats That Work Better<\/h1>\n\n\n\n
                          The author’s testing found relatively strong results for:<\/p>\n\n\n\n
                          Text formats<\/h3>\n\n\n\n
                            \n
                          • Python<\/li>\n\n\n\n
                          • YAML<\/li>\n\n\n\n
                          • HTML<\/li>\n\n\n\n
                          • JSON<\/li>\n\n\n\n
                          • CSV<\/li>\n\n\n\n
                          • LaTeX<\/li>\n\n\n\n
                          • RTF<\/li>\n\n\n\n
                          • INI<\/li>\n<\/ul>\n\n\n\n
                            Simpler\/common binary headers<\/h3>\n\n\n\n
                              \n
                            • PNG<\/li>\n\n\n\n
                            • JPEG<\/li>\n\n\n\n
                            • GIF<\/li>\n\n\n\n
                            • WAV<\/li>\n\n\n\n
                            • MP4<\/li>\n\n\n\n
                            • PDF<\/li>\n\n\n\n
                            • ELF<\/li>\n\n\n\n
                            • PE<\/li>\n\n\n\n
                            • WASM<\/li>\n<\/ul>\n\n\n\n
                              Header-oriented containers<\/h3>\n\n\n\n
                                \n
                              • RIFF<\/li>\n\n\n\n
                              • ISO BMFF<\/li>\n\n\n\n
                              • Ogg<\/li>\n\n\n\n
                              • FLV<\/li>\n<\/ul>\n\n\n\n
                                \u201cWorks\u201d here does not mean arbitrary production-grade files are guaranteed to be valid.<\/p>\n\n\n\n
                                It means models often reproduce enough recognizable format structure to make interesting demonstrations.<\/p>\n\n\n\n
                                \n\n\n\n
                                59. Formats That Work Poorly<\/h1>\n\n\n\n
                                The author’s testing identifies significant problems with:<\/p>\n\n\n\n
                                Compressed internals<\/h3>\n\n\n
                                ZIP\ngzip\nbzip2\n<\/code><\/span><\/pre>\n\n\n
                                Codec-specific formats<\/h3>\n\n\n
                                FLAC\nAAC\nMIDI\n<\/code><\/span><\/pre>\n\n\n
                                Cross-referenced structures<\/h3>\n\n\n
                                ZIP central directory\nSQLite pages\nOLE2\n<\/code><\/span><\/pre>\n\n\n
                                Why?<\/p>\n\n\n\n
                                Because exact binary relationships must be calculated rather than merely approximated.<\/p>\n\n\n\n
                                \n\n\n\n
                                60. Predicting Bytes vs Executing Algorithms<\/h1>\n\n\n\n
                                This is one of InferenceFS’s deepest lessons.<\/p>\n\n\n\n
                                An LLM may know that ZIP files begin with:<\/p>\n\n\n
                                PK\n<\/code><\/span><\/pre>\n\n\n
                                or:<\/p>\n\n\n
                                50 4B 03 04\n<\/code><\/span><\/pre>\n\n\n
                                That is pattern knowledge.<\/p>\n\n\n\n
                                But producing a valid DEFLATE stream requires executing an exact algorithm.<\/p>\n\n\n\n
                                Similarly, the model may know that PNG has recognizable chunks.<\/p>\n\n\n\n
                                But if lengths, CRCs and compressed streams must all align exactly, probability alone is a poor substitute for computation.<\/p>\n\n\n\n
                                The author’s appendix summarizes this distinction as a boundary between learned format patterns and algorithmically constrained structures.<\/p>\n\n\n\n
                                \n\n\n\n
                                61. LLMs as Lossy Compression<\/h1>\n\n\n\n
                                This is the intellectual heart of InferenceFS.<\/p>\n\n\n\n
                                Imagine that a model’s weights are a giant lossy representation of its training distribution.<\/p>\n\n\n\n
                                Then:<\/p>\n\n\n
                                model weights\n      =\nshared decoder\/codebook\n<\/code><\/span><\/pre>\n\n\n
                                and:<\/p>\n\n\n
                                filename\n      =\ntiny index\/query\n<\/code><\/span><\/pre>\n\n\n
                                The model \u201cdecompresses\u201d:<\/p>\n\n\n
                                config<\/span>.yaml<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                into:<\/p>\n\n\n
                                server:\n  port: 8080\ndatabase:\n  host: localhost\n<\/code><\/span><\/pre>\n\n\n
                                The apparent compression ratio is extraordinary.<\/p>\n\n\n\n
                                But there is a catch:<\/p>\n\n\n
                                generated result != original result\n<\/code><\/span><\/pre>\n\n\n
                                The author explicitly frames this as extreme lossy compression<\/strong>: what comes back is plausible rather than faithful.<\/p>\n\n\n\n
                                \n\n\n\n
                                62. A Useful Analogy<\/h1>\n\n\n\n
                                Imagine destroying every recipe in the world but retaining filenames:<\/p>\n\n\n
                                chocolate_cake_recipe<\/span>.txt<\/span>\ncarbonara<\/span>.txt<\/span>\nnaan_recipe<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                Then hiring a chef and saying:<\/p>\n\n\n
                                \"Tell me what this recipe probably contained.\"<\/span>\n<\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
                                The chef may produce an excellent recipe.<\/p>\n\n\n\n
                                But it is not necessarily:<\/p>\n\n\n
                                the recipe you originally stored\n<\/code><\/span><\/pre>\n\n\n
                                InferenceFS does the digital equivalent.<\/p>\n\n\n\n
                                \n\n\n\n
                                63. Another Analogy: Human Memory<\/h1>\n\n\n\n
                                Suppose someone asks:<\/p>\n\n\n\n
                                \n
                                What did your high school classroom look like?<\/p>\n<\/blockquote>\n\n\n\n
                                You may remember:<\/p>\n\n\n\n
                                  \n
                                • desks,<\/li>\n\n\n\n
                                • whiteboard,<\/li>\n\n\n\n
                                • windows,<\/li>\n\n\n\n
                                • teacher’s table.<\/li>\n<\/ul>\n\n\n\n
                                  Your answer may be highly plausible.<\/p>\n\n\n\n
                                  But perhaps the whiteboard was actually green.<\/p>\n\n\n\n
                                  Perhaps there were 28 desks rather than 24.<\/p>\n\n\n\n
                                  Your brain reconstructed a plausible memory.<\/p>\n\n\n\n
                                  InferenceFS intentionally treats an LLM somewhat like that reconstruction engine.<\/p>\n\n\n\n
                                  \n\n\n\n
                                  64. Determinism<\/h1>\n\n\n\n
                                  Normal storage aims for:<\/p>\n\n\n
                                  write X\nread X\n<\/code><\/span><\/pre>\n\n\n
                                  InferenceFS has:<\/p>\n\n\n
                                  name N\ngenerate approximately X\u2081\n\nlater:\n\nname N\ngenerate approximately X\u2082\n<\/code><\/span><\/pre>\n\n\n
                                  where:<\/p>\n\n\n
                                  X\u2081 may not equal X\u2082\n<\/code><\/span><\/pre>\n\n\n
                                  Reasons include:<\/p>\n\n\n\n
                                    \n
                                  • stochastic generation,<\/li>\n\n\n\n
                                  • backend differences,<\/li>\n\n\n\n
                                  • provider model changes,<\/li>\n\n\n\n
                                  • prompt interpretation,<\/li>\n\n\n\n
                                  • model updates,<\/li>\n\n\n\n
                                  • cache eviction,<\/li>\n\n\n\n
                                  • different inference settings.<\/li>\n<\/ul>\n\n\n\n
                                    This means InferenceFS lacks one of the defining properties expected from persistent storage:<\/p>\n\n\n\n
                                    \n
                                    stable byte identity.<\/p>\n<\/blockquote>\n\n\n\n
                                    \n\n\n\n
                                    65. What Happens Across Unmounts?<\/h1>\n\n\n\n
                                    Generated content is cached:<\/p>\n\n\n
                                    in process memory\n<\/code><\/span><\/pre>\n\n\n
                                    not persisted as file payload.<\/p>\n\n\n\n
                                    Unmount:<\/p>\n\n\n
                                    fusermount3 -u \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                                    Then mount again.<\/p>\n\n\n\n
                                    Your file paths remain because the source directory persists.<\/p>\n\n\n\n
                                    But the generated-content cache does not.<\/p>\n\n\n\n
                                    The next read can trigger another model call.<\/p>\n\n\n\n
                                    Potentially:<\/p>\n\n\n
                                    before<\/span> unmount<\/span>:\nfile<\/span>.py<\/span> -<\/span>> version<\/span> A<\/span>\n\nafter<\/span> remount<\/span>:\nfile<\/span>.py<\/span> -<\/span>> version<\/span> B<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    \n\n\n\n
                                    66. Unmounting<\/h1>\n\n\n\n
                                    Use:<\/p>\n\n\n
                                    fusermount3 -u \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                                    The project’s quick start documents fusermount3<\/code>.<\/p>\n\n\n\n
                                    You can verify:<\/p>\n\n\n
                                    findmnt \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                                    \n\n\n\n
                                    67. File Operations Implemented<\/h1>\n\n\n\n
                                    InferenceFS implements a surprisingly broad collection of filesystem operations, including behavior around:<\/p>\n\n\n\n
                                      \n
                                    • lookup,<\/li>\n\n\n\n
                                    • getattr,<\/li>\n\n\n\n
                                    • setattr,<\/li>\n\n\n\n
                                    • create,<\/li>\n\n\n\n
                                    • open,<\/li>\n\n\n\n
                                    • read,<\/li>\n\n\n\n
                                    • write,<\/li>\n\n\n\n
                                    • release,<\/li>\n\n\n\n
                                    • mkdir,<\/li>\n\n\n\n
                                    • readdir,<\/li>\n\n\n\n
                                    • unlink,<\/li>\n\n\n\n
                                    • rmdir,<\/li>\n\n\n\n
                                    • rename,<\/li>\n\n\n\n
                                    • hard links,<\/li>\n\n\n\n
                                    • symbolic links,<\/li>\n\n\n\n
                                    • fsync,<\/li>\n\n\n\n
                                    • extended attributes,<\/li>\n\n\n\n
                                    • access checks,<\/li>\n\n\n\n
                                    • filesystem statistics.<\/li>\n<\/ul>\n\n\n\n
                                      The metadata behavior primarily delegates to the underlying source directory.<\/p>\n\n\n\n
                                      The content generation behavior is the unusual layer on top.<\/p>\n\n\n\n
                                      \n\n\n\n
                                      68. Low-Level FUSE API<\/h1>\n\n\n\n
                                      InferenceFS uses:<\/p>\n\n\n
                                      pyfuse3<\/span>.Operations<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                      and an inode-oriented API rather than a simple path-only abstraction.<\/p>\n\n\n\n
                                      It maintains structures for:<\/p>\n\n\n
                                      inode \u2192 path\n\nfile descriptor \u2192 inode\n\ninode \u2192 file descriptor\n\nlookup counts\n\nopen counts\n\nfile descriptor \u2192 virtual filename\n<\/code><\/span><\/pre>\n\n\n
                                      This is useful source code for developers learning how a real FUSE filesystem manages kernel-facing object lifecycles.<\/p>\n\n\n\n
                                      \n\n\n\n
                                      69. Why Inode Tracking Exists<\/h1>\n\n\n\n
                                      Applications operate on concepts such as:<\/p>\n\n\n
                                      inode\nfile descriptor\ndirectory entry\n<\/code><\/span><\/pre>\n\n\n
                                      not merely strings.<\/p>\n\n\n\n
                                      Suppose:<\/p>\n\n\n
                                      open(\"\/a.txt\"<\/span>)\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                      returns a handle.<\/p>\n\n\n\n
                                      The file might later:<\/p>\n\n\n
                                      rename()\n<\/code><\/span><\/pre>\n\n\n
                                      while that handle still exists.<\/p>\n\n\n\n
                                      Filesystem implementations therefore need bookkeeping that is more sophisticated than:<\/p>\n\n\n
                                      dictionary[path] = content\n<\/code><\/span><\/pre>\n\n\n
                                      InferenceFS gives you a compact example of these issues.<\/p>\n\n\n\n
                                      \n\n\n\n
                                      70. LRU Cache Architecture<\/h1>\n\n\n\n
                                      The cache uses Python’s:<\/p>\n\n\n
                                      OrderedDict\n<\/code><\/span><\/pre>\n\n\n
                                      and stores:<\/p>\n\n\n
                                      filename \u2192 bytes\n<\/code><\/span><\/pre>\n\n\n
                                      It tracks:<\/p>\n\n\n
                                      current_bytes\n<\/code><\/span><\/pre>\n\n\n
                                      and:<\/p>\n\n\n
                                      max_bytes\n<\/code><\/span><\/pre>\n\n\n
                                      When inserting a new file would exceed the limit, least-recently-used entries are evicted until there is enough room.<\/p>\n\n\n\n
                                      Conceptually:<\/p>\n\n\n
                                      Cache:\n\nA  \u2190 oldest\nB\nC\nD  \u2190 newest\n\nNeed space\n\nevict A\n<\/code><\/span><\/pre>\n\n\n
                                      This is a classic LRU implementation.<\/p>\n\n\n\n
                                      \n\n\n\n
                                      71. Why Cache by Filename?<\/h1>\n\n\n\n
                                      The generated content derives from:<\/p>\n\n\n
                                      filename\/path\n<\/code><\/span><\/pre>\n\n\n
                                      so that becomes the natural cache key.<\/p>\n\n\n\n
                                      Conceptually:<\/p>\n\n\n
                                      cache[\"\/src\/main.py\"<\/span>] = generated_bytes\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                      This makes repeated reads cheap.<\/p>\n\n\n\n
                                      But it also exposes a semantic issue:<\/p>\n\n\n
                                      filename is being treated like content identity\n<\/code><\/span><\/pre>\n\n\n
                                      which it obviously is not in real-world storage.<\/p>\n\n\n\n
                                      That tension is part of the joke.<\/p>\n\n\n\n
                                      \n\n\n\n
                                      72. Cost Model<\/h1>\n\n\n\n
                                      Ordinary filesystem read cost:<\/p>\n\n\n
                                      disk\/NVMe latency\n<\/code><\/span><\/pre>\n\n\n
                                      InferenceFS cold read cost:<\/p>\n\n\n
                                      network request\n+\nprovider queue\n+\nLLM inference\n+\ntokens\n+\nAPI billing\n<\/code><\/span><\/pre>\n\n\n
                                      Warm read:<\/p>\n\n\n
                                      RAM cache\n<\/code><\/span><\/pre>\n\n\n
                                      Therefore:<\/p>\n\n\n
                                      first read = expensive\nrepeated read = cheap\n<\/code><\/span><\/pre>\n\n\n
                                      until eviction.<\/p>\n\n\n\n
                                      \n\n\n\n
                                      73. Performance Characteristics<\/h1>\n\n\n\n
                                      Expect latency to depend heavily on:<\/p>\n\n\n\n
                                        \n
                                      • model,<\/li>\n\n\n\n
                                      • provider,<\/li>\n\n\n\n
                                      • prompt,<\/li>\n\n\n\n
                                      • generated file size,<\/li>\n\n\n\n
                                      • API region,<\/li>\n\n\n\n
                                      • rate limiting,<\/li>\n\n\n\n
                                      • network latency,<\/li>\n\n\n\n
                                      • cache state,<\/li>\n\n\n\n
                                      • max output tokens.<\/li>\n<\/ul>\n\n\n\n
                                        A simple text file may appear quickly.<\/p>\n\n\n\n
                                        A cold read requiring a large model output may be dramatically slower than local storage.<\/p>\n\n\n\n
                                        This is another excellent demonstration of how remote AI inference changes system architecture.<\/p>\n\n\n\n
                                        \n\n\n\n
                                        74. API Cost<\/h1>\n\n\n\n
                                        InferenceFS can consume paid inference APIs.<\/p>\n\n\n\n
                                        Operations that seem harmless:<\/p>\n\n\n
                                        cat file\n<\/code><\/span><\/pre>\n\n\n
                                        can potentially trigger billable model requests.<\/p>\n\n\n\n
                                        Commands that scan many files can be worse.<\/p>\n\n\n\n
                                        For example:<\/p>\n\n\n
                                        grep -R something \/mnt\/inference\n<\/code><\/span><\/pre>\n\n\n
                                        could trigger reads across many files.<\/p>\n\n\n\n
                                        Similarly:<\/p>\n\n\n
                                        cp -R \/mnt\/inference \/tmp\/copy\n<\/code><\/span><\/pre>\n\n\n
                                        may require generation for large numbers of files.<\/p>\n\n\n\n
                                        Treat the mount as an API execution surface<\/strong>, not just a filesystem.<\/p>\n\n\n\n
                                        \n\n\n\n
                                        75. A Surprisingly Important Operational Lesson<\/h1>\n\n\n\n
                                        In cloud-backed filesystems:<\/p>\n\n\n
                                        filesystem operation\n<\/code><\/span><\/pre>\n\n\n
                                        can map to:<\/p>\n\n\n
                                        network\/API operation\n<\/code><\/span><\/pre>\n\n\n
                                        InferenceFS exaggerates that relationship in a memorable way.<\/p>\n\n\n\n
                                        Running:<\/p>\n\n\n
                                        cat foo\n<\/code><\/span><\/pre>\n\n\n
                                        looks local.<\/p>\n\n\n\n
                                        But underneath it may invoke:<\/p>\n\n\n
                                        remote LLM API\n<\/code><\/span><\/pre>\n\n\n
                                        which has:<\/p>\n\n\n\n
                                          \n
                                        • authentication,<\/li>\n\n\n\n
                                        • pricing,<\/li>\n\n\n\n
                                        • quotas,<\/li>\n\n\n\n
                                        • rate limits,<\/li>\n\n\n\n
                                        • external dependencies,<\/li>\n\n\n\n
                                        • privacy consequences.<\/li>\n<\/ul>\n\n\n\n
                                          That principle applies to many real systems too.<\/p>\n\n\n\n
                                          \n\n\n\n
                                          76. Privacy Implications<\/h1>\n\n\n\n
                                          The filename\/path is sent to the selected model backend.<\/p>\n\n\n\n
                                          Suppose you create:<\/p>\n\n\n
                                          \/customers\/acme\/merger-plan.txt\n<\/code><\/span><\/pre>\n\n\n
                                          or:<\/p>\n\n\n
                                          \/hr\/alice-salary-review.txt\n<\/code><\/span><\/pre>\n\n\n
                                          or:<\/p>\n\n\n
                                          \/secrets\/production-db-password.txt\n<\/code><\/span><\/pre>\n\n\n
                                          Those names themselves may contain confidential information.<\/p>\n\n\n\n
                                          Therefore:<\/p>\n\n\n\n
                                          \n
                                          Do not mount sensitive directory structures against third-party AI APIs.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
                                          Even if file payloads are discarded, filenames alone can be sensitive metadata.<\/p>\n\n\n\n
                                          \n\n\n\n
                                          77. The Built-In Personal-Data Prompt<\/h1>\n\n\n\n
                                          The current backend system prompt contains special wording for filenames suggesting private or personal data.<\/p>\n\n\n\n
                                          It asks the model to generate generic placeholder content<\/strong> rather than real private information.<\/p>\n\n\n\n
                                          That is sensible for the demonstration.<\/p>\n\n\n\n
                                          It does not transform InferenceFS into a secure storage mechanism.<\/p>\n\n\n\n
                                          \n\n\n\n
                                          78. Security Model<\/h1>\n\n\n\n
                                          InferenceFS does not provide a traditional secure-storage model.<\/p>\n\n\n\n
                                          Risks include:<\/p>\n\n\n\n
                                          API keys<\/h3>\n\n\n\n
                                          Protect:<\/p>\n\n\n
                                          API_KEY\n<\/code><\/span><\/pre>\n\n\n
                                          Filename disclosure<\/h3>\n\n\n\n
                                          Paths can be sent to third parties.<\/p>\n\n\n\n
                                          Generated malicious content<\/h3>\n\n\n\n
                                          An LLM could potentially generate:<\/p>\n\n\n
                                          scripts\nshell commands\nconfiguration\nsource code\n<\/code><\/span><\/pre>\n\n\n
                                          that should not automatically be trusted.<\/p>\n\n\n\n
                                          Supply-chain risk<\/h3>\n\n\n\n
                                          Generated code is not trusted software.<\/p>\n\n\n\n
                                          Nondeterminism<\/h3>\n\n\n\n
                                          Files can change without explicit writes.<\/p>\n\n\n\n
                                          External availability<\/h3>\n\n\n\n
                                          The filesystem depends on remote services.<\/p>\n\n\n\n
                                          API compromise<\/h3>\n\n\n\n
                                          Provider\/API credentials become part of the storage dependency chain.<\/p>\n\n\n\n
                                          \n\n\n\n
                                          79. Never Execute Generated Binaries<\/h1>\n\n\n\n
                                          InferenceFS can ask models to produce binary-looking files.<\/p>\n\n\n\n
                                          Do not interpret:<\/p>\n\n\n
                                          valid ELF header\n<\/code><\/span><\/pre>\n\n\n
                                          as:<\/p>\n\n\n
                                          safe executable\n<\/code><\/span><\/pre>\n\n\n
                                          Never blindly execute:<\/p>\n\n\n
                                          chmod +x generated-file\n.\/generated-file\n<\/code><\/span><\/pre>\n\n\n
                                          The same applies to:<\/p>\n\n\n
                                          shell scripts\nPowerShell\nPython\nJavaScript\ninstallers\nmacros\n<\/code><\/span><\/pre>\n\n\n
                                          Treat all generated contents as untrusted.<\/p>\n\n\n\n
                                          \n\n\n\n
                                          80. Never Use It for Secrets<\/h1>\n\n\n\n
                                          Do not create:<\/p>\n\n\n
                                          id_rsa\n<\/code><\/span><\/pre>\n\n\n
                                          and expect your SSH key back.<\/p>\n\n\n\n
                                          Do not create:<\/p>\n\n\n
                                          production<\/span>.env<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          and expect credentials.<\/p>\n\n\n\n
                                          Do not create:<\/p>\n\n\n
                                          wallet<\/span>.dat<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          and expect cryptocurrency keys.<\/p>\n\n\n\n
                                          Do not create:<\/p>\n\n\n
                                          passwords<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                          and expect your passwords.<\/p>\n\n\n\n
                                          InferenceFS cannot reconstruct arbitrary private information from a filename.<\/p>\n\n\n\n
                                          Any seemingly convincing result is generated content, not your original secret.<\/p>\n\n\n\n
                                          \n\n\n\n
                                          81. Never Use It for Backups<\/h1>\n\n\n\n
                                          A backup must satisfy something like:<\/p>\n\n\n
                                          original bytes\n     \u2193\nstore\n     \u2193\nlater restore\n     \u2193\nsame original bytes\n<\/code><\/span><\/pre>\n\n\n
                                          InferenceFS performs:<\/p>\n\n\n
                                          filename\n     \u2193\ngenerate something plausible\n<\/code><\/span><\/pre>\n\n\n
                                          That is the opposite of backup.<\/p>\n\n\n\n
                                          \n\n\n\n
                                          82. Never Use It for Databases<\/h1>\n\n\n\n
                                          Databases depend on:<\/p>\n\n\n\n
                                            \n
                                          • exact pages,<\/li>\n\n\n\n
                                          • transaction logs,<\/li>\n\n\n\n
                                          • checksums,<\/li>\n\n\n\n
                                          • indexes,<\/li>\n\n\n\n
                                          • transactional ordering,<\/li>\n\n\n\n
                                          • durable writes,<\/li>\n\n\n\n
                                          • crash consistency,<\/li>\n\n\n\n
                                          • stable offsets.<\/li>\n<\/ul>\n\n\n\n
                                            InferenceFS intentionally violates several fundamental assumptions.<\/p>\n\n\n\n
                                            Do not use it for:<\/p>\n\n\n
                                            PostgreSQL\nMySQL\nSQLite\nMongoDB\nRedis persistence\nRocksDB\nLevelDB\n<\/code><\/span><\/pre>\n\n\n
                                            or any real database data.<\/p>\n\n\n\n
                                            \n\n\n\n
                                            83. Never Use It for Kubernetes Persistent Volumes<\/h1>\n\n\n\n
                                            A Kubernetes application expects:<\/p>\n\n\n
                                            write state\n\u2192 restart\n\u2192 state still exists\n<\/code><\/span><\/pre>\n\n\n
                                            InferenceFS gives:<\/p>\n\n\n
                                            write state\n\u2192 bytes disappear\n\u2192 future read is generated\n<\/code><\/span><\/pre>\n\n\n
                                            This would be spectacularly wrong.<\/p>\n\n\n\n
                                            Do not use it as a real PersistentVolume backend.<\/p>\n\n\n\n
                                            \n\n\n\n
                                            84. Real Use Cases<\/h1>\n\n\n\n
                                            InferenceFS does have excellent legitimate uses.<\/p>\n\n\n\n
                                            84.1 Teaching FUSE<\/h2>\n\n\n\n
                                            Study:<\/p>\n\n\n
                                            inode management\nread\/write callbacks\ndirectory operations\nasync<\/span> filesystems\nFUSE lifecycle\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            84.2 Teaching LLM Hallucination<\/h2>\n\n\n\n
                                            Demonstrate the difference between:<\/p>\n\n\n
                                            looks correct\n<\/code><\/span><\/pre>\n\n\n
                                            and:<\/p>\n\n\n
                                            is correct\n<\/code><\/span><\/pre>\n\n\n
                                            84.3 Teaching Generative vs Retrieval Systems<\/h2>\n\n\n\n
                                            It makes the distinction tangible.<\/p>\n\n\n\n
                                            84.4 Studying Model Priors<\/h2>\n\n\n\n
                                            Ask:<\/p>\n\n\n
                                            What<\/span> does<\/span> the<\/span> model<\/span> think<\/span> README<\/span>.md<\/span> contains<\/span>?\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            84.5 File Format Research<\/h2>\n\n\n\n
                                            Explore what models understand about:<\/p>\n\n\n
                                            PNG\nZIP\nELF\nPDF\nWAV\nSQLite\n<\/code><\/span><\/pre>\n\n\n
                                            84.6 LLM Benchmarking<\/h2>\n\n\n\n
                                            Use filenames as standardized prompts across different models.<\/p>\n\n\n\n
                                            84.7 AI Education<\/h2>\n\n\n\n
                                            InferenceFS may be one of the funniest possible demonstrations of why:<\/p>\n\n\n
                                            plausibility != truth\n<\/code><\/span><\/pre>\n\n\n
                                            \n\n\n\n
                                            85. Model-Prior Experiments<\/h1>\n\n\n\n
                                            Create:<\/p>\n\n\n
                                            touch<\/span> README<\/span>.md<\/span>\ntouch<\/span> package<\/span>.json<\/span>\ntouch<\/span> Cargo<\/span>.toml<\/span>\ntouch<\/span> go<\/span>.mod<\/span>\ntouch<\/span> pom<\/span>.xml<\/span>\ntouch<\/span> Makefile<\/span>\ntouch<\/span> Dockerfile<\/span>\ntouch<\/span> Jenkinsfile<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            Read each.<\/p>\n\n\n\n
                                            This reveals conventions learned by the model.<\/p>\n\n\n\n
                                            For example:<\/p>\n\n\n
                                            package<\/span>.json<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            may produce a plausible Node.js project.<\/p>\n\n\n
                                            Cargo<\/span>.toml<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            may produce Rust metadata.<\/p>\n\n\n
                                            go<\/span>.mod<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            may produce Go module information.<\/p>\n\n\n\n
                                            These are not \u201cremembered files.\u201d<\/p>\n\n\n\n
                                            They are samples from learned conventions.<\/p>\n\n\n\n
                                            \n\n\n\n
                                            86. DevOps Experiment<\/h1>\n\n\n\n
                                            Try:<\/p>\n\n\n
                                            Dockerfile\ndocker-compose.yaml\nJenkinsfile\n.github\/workflows\/ci.yml\nterraform\/main.tf\nansible\/playbook.yaml\nkubernetes\/deployment.yaml\nhelm\/Chart.yaml\n<\/code><\/span><\/pre>\n\n\n
                                            Then inspect whether the model generates coherent infrastructure definitions.<\/p>\n\n\n\n
                                            This can reveal what default patterns and conventions a model has absorbed.<\/p>\n\n\n\n
                                            \n\n\n\n
                                            87. Observability Experiment<\/h1>\n\n\n\n
                                            Create:<\/p>\n\n\n
                                            prometheus<\/span>.yml<\/span>\ngrafana-dashboard<\/span>.json<\/span>\ndatadog-agent<\/span>.yaml<\/span>\notel-collector<\/span>.yaml<\/span>\nfluent-bit<\/span>.conf<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                            Read them.<\/p>\n\n\n\n
                                            You can compare:<\/p>\n\n\n\n
                                              \n
                                            • syntax validity,<\/li>\n\n\n\n
                                            • modernity,<\/li>\n\n\n\n
                                            • configuration conventions,<\/li>\n\n\n\n
                                            • security defaults,<\/li>\n\n\n\n
                                            • hallucinated settings.<\/li>\n<\/ul>\n\n\n\n
                                              Again, never treat generated configuration as authoritative.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              88. Programming-Language Experiment<\/h1>\n\n\n\n
                                              Create:<\/p>\n\n\n
                                              hello<\/span>.py<\/span>\nhello<\/span>.go<\/span>\nhello<\/span>.rs<\/span>\nHello<\/span>.java<\/span>\nmain<\/span>.cpp<\/span>\nindex<\/span>.js<\/span>\nmain<\/span>.rb<\/span>\nProgram<\/span>.cs<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              Ask:<\/p>\n\n\n
                                              What style does each backend generate?\n<\/code><\/span><\/pre>\n\n\n
                                              Compare:<\/p>\n\n\n
                                              Claude\nGemini\nClaude Code\n<\/code><\/span><\/pre>\n\n\n
                                              This is an unusual but useful qualitative model benchmark.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              89. Binary Experiment<\/h1>\n\n\n\n
                                              Try:<\/p>\n\n\n
                                              touch<\/span> image<\/span>.png<\/span>\ntouch<\/span> document<\/span>.pdf<\/span>\ntouch<\/span> application<\/span>.exe<\/span>\ntouch<\/span> application<\/span>.elf<\/span>\ntouch<\/span> archive<\/span>.zip<\/span>\ntouch<\/span> database<\/span>.sqlite<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              Then use:<\/p>\n\n\n
                                              file<\/span> image<\/span>.png<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              or:<\/p>\n\n\n
                                              xxd image.png | head\n<\/code><\/span><\/pre>\n\n\n
                                              and format-specific validators.<\/p>\n\n\n\n
                                              You will likely observe an interesting boundary between:<\/p>\n\n\n
                                              recognizable header\n<\/code><\/span><\/pre>\n\n\n
                                              and:<\/p>\n\n\n
                                              fully valid structured file\n<\/code><\/span><\/pre>\n\n\n
                                              That boundary is exactly what the author’s appendix highlights.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              90. Example Binary Validation Lab<\/h1>\n\n\n\n
                                              For PNG:<\/p>\n\n\n
                                              file<\/span> image<\/span>.png<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              Potentially:<\/p>\n\n\n
                                              pngcheck<\/span> image<\/span>.png<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              For ZIP:<\/p>\n\n\n
                                              unzip<\/span> -t<\/span> archive<\/span>.zip<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              For PDF:<\/p>\n\n\n
                                              pdfinfo document<\/span>.pdf\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              For ELF:<\/p>\n\n\n
                                              readelf<\/span> -h<\/span> application<\/span>.elf<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              For SQLite:<\/p>\n\n\n
                                              sqlite3 database.sqlite '.schema'<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              This can produce a fascinating comparison between:<\/p>\n\n\n
                                              superficially correct\n<\/code><\/span><\/pre>\n\n\n
                                              and:<\/p>\n\n\n
                                              semantically valid\n<\/code><\/span><\/pre>\n\n\n
                                              \n\n\n\n
                                              91. Testing Different Backends<\/h1>\n\n\n\n
                                              Create the same source tree.<\/p>\n\n\n\n
                                              Mount with Gemini:<\/p>\n\n\n
                                              inferencefs \\\n    --backend gemini \\\n    source \\\n    mount-gemini\n<\/code><\/span><\/pre>\n\n\n
                                              Mount separately with Claude:<\/p>\n\n\n
                                              inferencefs \\\n    --backend claude \\\n    source2 \\\n    mount-claude\n<\/code><\/span><\/pre>\n\n\n
                                              Then compare:<\/p>\n\n\n
                                              diff \\\n    mount-gemini\/Dockerfile \\\n    mount-claude\/Dockerfile\n<\/code><\/span><\/pre>\n\n\n
                                              This turns InferenceFS into a quirky comparative benchmark.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              92. Testing Reproducibility<\/h1>\n\n\n\n
                                              Mount:<\/p>\n\n\n
                                              inferencefs --backend gemini source mount\n<\/code><\/span><\/pre>\n\n\n
                                              Read:<\/p>\n\n\n
                                              cat mount\/config.yaml > first.txt\n<\/code><\/span><\/pre>\n\n\n
                                              Unmount:<\/p>\n\n\n
                                              fusermount3 -u mount\n<\/code><\/span><\/pre>\n\n\n
                                              Mount again.<\/p>\n\n\n\n
                                              Read:<\/p>\n\n\n
                                              cat mount\/config.yaml > second.txt\n<\/code><\/span><\/pre>\n\n\n
                                              Compare:<\/p>\n\n\n
                                              diff<\/span> -u<\/span> first<\/span>.txt<\/span> second<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              Any difference demonstrates the core issue:<\/p>\n\n\n
                                              filename alone is not a lossless content identifier\n<\/code><\/span><\/pre>\n\n\n
                                              \n\n\n\n
                                              93. Inspect the Source Directory<\/h1>\n\n\n\n
                                              Create:<\/p>\n\n\n
                                              printf 'Hello world'<\/span> > \/tmp\/i<\/span>nference-mount\/test.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              Unmount if necessary, then inspect:<\/p>\n\n\n
                                              cat \/tmp\/inference-source\/test.txt\n<\/code><\/span><\/pre>\n\n\n
                                              You may see a decimal size value representing the virtual written size rather than:<\/p>\n\n\n
                                              Hello world\n<\/code><\/span><\/pre>\n\n\n
                                              That is one of the simplest demonstrations of how InferenceFS discards actual write payloads.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              94. Troubleshooting: pyfuse3<\/code> Build Failure<\/h1>\n\n\n\n
                                              If installation complains about FUSE headers or pkg-config<\/code>, install:<\/p>\n\n\n
                                              sudo apt install -y \\\n    fuse3 \\\n    libfuse3-dev \\\n    pkg-config \\\n    build-essential\n<\/code><\/span><\/pre>\n\n\n
                                              Then retry your Python installation.<\/p>\n\n\n\n
                                              The project’s own developer documentation identifies these system dependencies.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              95. Troubleshooting: Python Version<\/h1>\n\n\n\n
                                              If you see something resembling:<\/p>\n\n\n
                                              requires Python >=3.14\n<\/code><\/span><\/pre>\n\n\n
                                              check:<\/p>\n\n\n
                                              python --version\n<\/code><\/span><\/pre>\n\n\n
                                              InferenceFS 1.0.0 declares Python 3.14 or newer.<\/p>\n\n\n\n
                                              Use a separate Python 3.14 environment.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              96. Troubleshooting: Missing \/dev\/fuse<\/code><\/h1>\n\n\n\n
                                              Check:<\/p>\n\n\n
                                              ls -l \/dev\/fuse\n<\/code><\/span><\/pre>\n\n\n
                                              If unavailable on a normal Linux host:<\/p>\n\n\n
                                              sudo modprobe fuse\n<\/code><\/span><\/pre>\n\n\n
                                              Containers may require explicit FUSE device access.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              97. Troubleshooting: No API Key<\/h1>\n\n\n\n
                                              The CLI requires an API key for backends whose class declares:<\/p>\n\n\n
                                              requires_api_key = True<\/span>\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              If none is available, it exits with an error telling you to use:<\/p>\n\n\n
                                              --api-key\n<\/code><\/span><\/pre>\n\n\n
                                              or:<\/p>\n\n\n
                                              API_KEY\n<\/code><\/span><\/pre>\n\n\n
                                              Check:<\/p>\n\n\n
                                              echo<\/span> \"${API_KEY:+API_KEY is set}\"<\/span>\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                              Do not print secrets to shared terminal logs.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              98. Troubleshooting: claude<\/code> Not Found<\/h1>\n\n\n\n
                                              For:<\/p>\n\n\n
                                              --backend claude-code\n<\/code><\/span><\/pre>\n\n\n
                                              InferenceFS expects the executable:<\/p>\n\n\n
                                              claude\n<\/code><\/span><\/pre>\n\n\n
                                              to exist in PATH<\/code>.<\/p>\n\n\n\n
                                              Check:<\/p>\n\n\n
                                              command -v claude\n<\/code><\/span><\/pre>\n\n\n
                                              and make sure Claude Code is already authenticated.<\/p>\n\n\n\n
                                              The backend invokes the CLI through Python subprocess.run()<\/code>.<\/p>\n\n\n\n
                                              \n\n\n\n
                                              99. Troubleshooting: I\/O Error<\/h1>\n\n\n\n
                                              A read returning:<\/p>\n\n\n
                                              Input\/output error\n<\/code><\/span><\/pre>\n\n\n
                                              may indicate that generation failed.<\/p>\n\n\n\n
                                              Potential causes:<\/p>\n\n\n\n
                                                \n
                                              • bad API key,<\/li>\n\n\n\n
                                              • network failure,<\/li>\n\n\n\n
                                              • model unavailable,<\/li>\n\n\n\n
                                              • provider error,<\/li>\n\n\n\n
                                              • rate limiting,<\/li>\n\n\n\n
                                              • malformed provider response,<\/li>\n\n\n\n
                                              • CLI backend failure.<\/li>\n<\/ul>\n\n\n\n
                                                Run debug mode:<\/p>\n\n\n
                                                inferencefs -d ...\n<\/code><\/span><\/pre>\n\n\n
                                                to inspect logs.<\/p>\n\n\n\n
                                                \n\n\n\n
                                                100. Troubleshooting: File Suddenly Changed<\/h1>\n\n\n\n
                                                That is expected behavior if generated content was no longer cached.<\/p>\n\n\n\n
                                                Possible causes:<\/p>\n\n\n
                                                process restart\nmount restart\ncache eviction\ndifferent backend\nprovider model update\nnondeterministic generation\n<\/code><\/span><\/pre>\n\n\n
                                                InferenceFS provides no content-addressed persistence for generated bytes.<\/p>\n\n\n\n
                                                \n\n\n\n
                                                101. Troubleshooting: Binary File Is Corrupt<\/h1>\n\n\n\n
                                                Also expected.<\/p>\n\n\n\n
                                                An LLM can often imitate:<\/p>\n\n\n
                                                format structure\n<\/code><\/span><\/pre>\n\n\n
                                                but may fail to calculate:<\/p>\n\n\n\n
                                                  \n
                                                • checksums,<\/li>\n\n\n\n
                                                • compressed streams,<\/li>\n\n\n\n
                                                • indexes,<\/li>\n\n\n\n
                                                • internal offsets,<\/li>\n\n\n\n
                                                • codec state.<\/li>\n<\/ul>\n\n\n\n
                                                  The project’s own documented limitations explicitly call this out.<\/p>\n\n\n\n
                                                  \n\n\n\n
                                                  102. Containers<\/h1>\n\n\n\n
                                                  FUSE in containers is more complicated because the container needs:<\/p>\n\n\n
                                                  \/dev\/fuse\n<\/code><\/span><\/pre>\n\n\n
                                                  and sufficient capabilities.<\/p>\n\n\n\n
                                                  A typical experiment may require access resembling:<\/p>\n\n\n
                                                  --device \/dev\/fuse\n<\/code><\/span><\/pre>\n\n\n
                                                  and additional security permissions depending on the runtime.<\/p>\n\n\n\n
                                                  Do not jump directly to:<\/p>\n\n\n
                                                  --privileged\n<\/code><\/span><\/pre>\n\n\n
                                                  for production environments simply to make FUSE work.<\/p>\n\n\n\n
                                                  For learning InferenceFS:<\/p>\n\n\n
                                                  Linux VM\n<\/code><\/span><\/pre>\n\n\n
                                                  is generally simpler.<\/p>\n\n\n\n
                                                  \n\n\n\n
                                                  103. macOS<\/h1>\n\n\n\n
                                                  InferenceFS specifically depends on:<\/p>\n\n\n
                                                  pyfuse3\n<\/code><\/span><\/pre>\n\n\n
                                                  which targets Linux FUSE behavior.<\/p>\n\n\n\n
                                                  For macOS users, the least-friction route is generally:<\/p>\n\n\n
                                                  macOS\n  \u2193\nLinux VM\n  \u2193\nInferenceFS\n<\/code><\/span><\/pre>\n\n\n
                                                  rather than attempting to port the filesystem to macFUSE.<\/p>\n\n\n\n
                                                  \n\n\n\n
                                                  104. Windows<\/h1>\n\n\n\n
                                                  Similarly, the project is fundamentally designed around Linux\/FUSE 3.<\/p>\n\n\n\n
                                                  A Linux virtual machine is the cleanest environment for experimentation.<\/p>\n\n\n\n
                                                  \n\n\n\n
                                                  105. Testing<\/h1>\n\n\n\n
                                                  The repository includes dedicated tests for:<\/p>\n\n\n
                                                  filesystem operations\nInferenceFS generation behavior\ncache behavior\nsize tracking\nbackends\nresponse decoding\n<\/code><\/span><\/pre>\n\n\n
                                                  The project documentation uses:<\/p>\n\n\n
                                                  uv run pytest\n<\/code><\/span><\/pre>\n\n\n
                                                  or:<\/p>\n\n\n
                                                  uv run pytest -v\n<\/code><\/span><\/pre>\n\n\n
                                                  This is another reason the repository is worth studying beyond the joke itself.<\/p>\n\n\n\n
                                                  \n\n\n\n
                                                  106. Development Workflow<\/h1>\n\n\n\n
                                                  Clone:<\/p>\n\n\n
                                                  git clone<\/span> https:\/\/github.com\/philipl\/inferencefs.git<\/span>\ncd inferencefs\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                  Install dependencies:<\/p>\n\n\n
                                                  uv sync\n<\/code><\/span><\/pre>\n\n\n
                                                  Run tests:<\/p>\n\n\n
                                                  uv run pytest\n<\/code><\/span><\/pre>\n\n\n
                                                  Run lint:<\/p>\n\n\n
                                                  uv run ruff check src tests\n<\/code><\/span><\/pre>\n\n\n
                                                  Build package:<\/p>\n\n\n
                                                  uv build\n<\/code><\/span><\/pre>\n\n\n
                                                  Mount development version:<\/p>\n\n\n
                                                  uv run inferencefs \\\n    --backend gemini \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                                                  \n\n\n\n
                                                  107. Package Technology<\/h1>\n\n\n\n
                                                  The project currently uses:<\/p>\n\n\n
                                                  hatchling\nhatch-vcs\n<\/code><\/span><\/pre>\n\n\n
                                                  for its Python build system.<\/p>\n\n\n\n
                                                  The console command:<\/p>\n\n\n
                                                  inferencefs\n<\/code><\/span><\/pre>\n\n\n
                                                  maps to:<\/p>\n\n\n
                                                  inferencefs<\/span>.main<\/span>:main<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                  That is defined directly in pyproject.toml<\/code>.<\/p>\n\n\n\n
                                                  \n\n\n\n
                                                  108. License<\/h1>\n\n\n\n
                                                  InferenceFS declares:<\/p>\n\n\n
                                                  AGPL-3<\/span>.0-or-later<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                  Anyone modifying or deploying the project in contexts where licensing matters should review the AGPL obligations rather than assuming conventional permissive open-source terms.<\/p>\n\n\n\n
                                                  \n\n\n\n
                                                  109. Production Readiness<\/h1>\n\n\n\n
                                                  InferenceFS should not be treated as production persistent storage.<\/p>\n\n\n\n
                                                  The author explicitly says:<\/p>\n\n\n\n
                                                  \n
                                                  Do not use it to store anything you care about.<\/p>\n<\/blockquote>\n\n\n\n
                                                  It lacks the semantic contract required for persistent data because it intentionally does not preserve writes.<\/p>\n\n\n\n
                                                  \n\n\n\n
                                                  110. Do Not Use InferenceFS For<\/h1>\n\n\n\n
                                                  Do not use it for:<\/p>\n\n\n\n
                                                    \n
                                                  • backups,<\/li>\n\n\n\n
                                                  • databases,<\/li>\n\n\n\n
                                                  • home directories,<\/li>\n\n\n\n
                                                  • source-of-truth repositories,<\/li>\n\n\n\n
                                                  • secrets,<\/li>\n\n\n\n
                                                  • SSH keys,<\/li>\n\n\n\n
                                                  • cryptocurrency wallets,<\/li>\n\n\n\n
                                                  • legal documents,<\/li>\n\n\n\n
                                                  • financial records,<\/li>\n\n\n\n
                                                  • Kubernetes persistent storage,<\/li>\n\n\n\n
                                                  • Docker volumes containing state,<\/li>\n\n\n\n
                                                  • VM disks,<\/li>\n\n\n\n
                                                  • configuration-of-record,<\/li>\n\n\n\n
                                                  • user uploads,<\/li>\n\n\n\n
                                                  • medical records,<\/li>\n\n\n\n
                                                  • build artifacts requiring reproducibility,<\/li>\n\n\n\n
                                                  • package repositories,<\/li>\n\n\n\n
                                                  • container registries,<\/li>\n\n\n\n
                                                  • logs requiring audit integrity,<\/li>\n\n\n\n
                                                  • compliance records.<\/li>\n<\/ul>\n\n\n\n
                                                    If exact bytes matter, InferenceFS is fundamentally the wrong abstraction.<\/p>\n\n\n\n
                                                    \n\n\n\n
                                                    111. Excellent Uses For InferenceFS<\/h1>\n\n\n\n
                                                    Use it for:<\/p>\n\n\n\n
                                                      \n
                                                    • computer-science demonstrations,<\/li>\n\n\n\n
                                                    • FUSE education,<\/li>\n\n\n\n
                                                    • LLM education,<\/li>\n\n\n\n
                                                    • hallucination demonstrations,<\/li>\n\n\n\n
                                                    • inference-vs-retrieval teaching,<\/li>\n\n\n\n
                                                    • model comparisons,<\/li>\n\n\n\n
                                                    • file-format experiments,<\/li>\n\n\n\n
                                                    • caching demonstrations,<\/li>\n\n\n\n
                                                    • API-backed filesystem study,<\/li>\n\n\n\n
                                                    • prompt engineering experiments,<\/li>\n\n\n\n
                                                    • AI reliability workshops,<\/li>\n\n\n\n
                                                    • information-theory discussions.<\/li>\n<\/ul>\n\n\n\n
                                                      \n\n\n\n
                                                      112. InferenceFS vs Conventional Filesystem<\/h1>\n\n\n\n
                                                      Property<\/th>ext4\/XFS<\/th>InferenceFS<\/th><\/tr><\/thead>
                                                      Writes preserved<\/td>Yes<\/td>No<\/td><\/tr>
                                                      Reads exact<\/td>Yes<\/td>No<\/td><\/tr>
                                                      Persistent content<\/td>Yes<\/td>No<\/td><\/tr>
                                                      Content source<\/td>Stored blocks<\/td>LLM<\/td><\/tr>
                                                      Metadata<\/td>Filesystem metadata<\/td>Source tree<\/td><\/tr>
                                                      Remote inference<\/td>No<\/td>Yes<\/td><\/tr>
                                                      API dependency<\/td>No<\/td>Usually<\/td><\/tr>
                                                      Cache<\/td>OS caches<\/td>Explicit generated-content LRU<\/td><\/tr>
                                                      Deterministic<\/td>Essentially<\/td>Not guaranteed<\/td><\/tr>
                                                      Production storage<\/td>Yes<\/td>No<\/td><\/tr>
                                                      Educational novelty<\/td>Moderate<\/td>Extremely high<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                                                      \n\n\n\n
                                                      113. InferenceFS vs Object Storage<\/h1>\n\n\n\n
                                                      Property<\/th>S3\/Object Storage<\/th>InferenceFS<\/th><\/tr><\/thead>
                                                      Upload object<\/td>Stored<\/td>Discarded<\/td><\/tr>
                                                      Get object<\/td>Exact stored bytes<\/td>Generated bytes<\/td><\/tr>
                                                      Object identity<\/td>Key + version\/data<\/td>Filename prompt<\/td><\/tr>
                                                      Durability<\/td>Engineered<\/td>Not applicable<\/td><\/tr>
                                                      Versioning<\/td>Often<\/td>No generated-content versioning<\/td><\/tr>
                                                      Integrity<\/td>Checksums<\/td>No equivalent content guarantee<\/td><\/tr>
                                                      Cost basis<\/td>Storage + requests<\/td>LLM inference + cache<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                                                      \n\n\n\n
                                                      114. InferenceFS vs RAG<\/h1>\n\n\n\n
                                                      InferenceFS is not RAG.<\/p>\n\n\n\n
                                                      RAG<\/h2>\n\n\n
                                                      query\n \u2193\nretrieve relevant documents\n \u2193\nmodel sees real evidence\n \u2193\nanswer grounded in retrieved data\n<\/code><\/span><\/pre>\n\n\n
                                                      InferenceFS<\/h2>\n\n\n
                                                      filename\n \u2193\nmodel\n \u2193\ngenerate probable file contents\n<\/code><\/span><\/pre>\n\n\n
                                                      There is no retrieval database containing your original file contents.<\/p>\n\n\n\n
                                                      This distinction is extremely important.<\/p>\n\n\n\n
                                                      \n\n\n\n
                                                      115. InferenceFS vs Generative AI<\/h1>\n\n\n\n
                                                      InferenceFS is essentially a filesystem-shaped wrapper around generative AI.<\/p>\n\n\n\n
                                                      Normally:<\/p>\n\n\n
                                                      prompt \u2192 generated response\n<\/code><\/span><\/pre>\n\n\n
                                                      InferenceFS maps that into:<\/p>\n\n\n
                                                      filename \u2192 generated file\n<\/code><\/span><\/pre>\n\n\n
                                                      The operating system abstraction makes generation look like storage.<\/p>\n\n\n\n
                                                      That inversion is what makes the project so clever.<\/p>\n\n\n\n
                                                      \n\n\n\n
                                                      116. InferenceFS vs \/dev\/null<\/code><\/h1>\n\n\n\n
                                                      Writes are philosophically close to:<\/p>\n\n\n
                                                      \/dev\/null<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      because bytes disappear.<\/p>\n\n\n\n
                                                      But unlike \/dev\/null<\/code>, InferenceFS preserves the existence of the filename and apparent write size.<\/p>\n\n\n\n
                                                      Then, on read, it generates replacement content.<\/p>\n\n\n\n
                                                      So approximately:<\/p>\n\n\n
                                                      InferenceFS =\n\/dev\/<\/span>null<\/span>\n+\nmetadata\n+\nLLM\n+\nFUSE\n+\nconfidence\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      \n\n\n\n
                                                      117. InferenceFS vs \/dev\/urandom<\/code><\/h1>\n\n\n\n
                                                      \/dev\/urandom<\/code> generates bytes rather than storing them.<\/p>\n\n\n\n
                                                      InferenceFS also generates bytes.<\/p>\n\n\n\n
                                                      But \/dev\/urandom<\/code> makes no claim that its bytes correspond to what you wanted.<\/p>\n\n\n\n
                                                      InferenceFS generates semantically plausible data conditioned by the filename.<\/p>\n\n\n\n
                                                      So:<\/p>\n\n\n
                                                      \/dev\/urandom:\nrandom-looking bytes\n\nInferenceFS:\ncontextually plausible bytes\n<\/code><\/span><\/pre>\n\n\n
                                                      \n\n\n\n
                                                      118. InferenceFS vs Templates<\/h1>\n\n\n\n
                                                      It also resembles an extremely sophisticated templating engine.<\/p>\n\n\n\n
                                                      Traditional template:<\/p>\n\n\n
                                                      Dockerfile.tpl\n+\nvariables\n=\nDockerfile\n<\/code><\/span><\/pre>\n\n\n
                                                      InferenceFS:<\/p>\n\n\n
                                                      filename \"Dockerfile\"<\/span>\n+\nLLM prior\n=\nDockerfile\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      The \u201ctemplate\u201d lives inside the model weights.<\/p>\n\n\n\n
                                                      \n\n\n\n
                                                      119. InferenceFS vs Content-Addressed Storage<\/h1>\n\n\n\n
                                                      A system like Git says:<\/p>\n\n\n
                                                      content\n \u2193\ncryptographic hash\n \u2193\nstable content identity\n<\/code><\/span><\/pre>\n\n\n
                                                      InferenceFS effectively says:<\/p>\n\n\n
                                                      filename\n \u2193\nsemantic prompt\n \u2193\nprobable content\n<\/code><\/span><\/pre>\n\n\n
                                                      These are almost opposites.<\/p>\n\n\n\n
                                                      A hash exists specifically to bind identity to exact bytes.<\/p>\n\n\n\n
                                                      A filename contains insufficient information to do that.<\/p>\n\n\n\n
                                                      \n\n\n\n
                                                      120. InferenceFS vs Deduplication<\/h1>\n\n\n\n
                                                      Traditional deduplication:<\/p>\n\n\n
                                                      same content\n \u2193\nsame stored block\n<\/code><\/span><\/pre>\n\n\n
                                                      InferenceFS’s joke version is closer to:<\/p>\n\n\n
                                                      same semantic filename\n \u2193\ngenerate something likely\n<\/code><\/span><\/pre>\n\n\n
                                                      The README jokes that files with the same name are aggressively \u201cdeduplicated,\u201d but this is satire, not storage deduplication.<\/p>\n\n\n\n
                                                      \n\n\n\n
                                                      121. Why This Project Matters<\/h1>\n\n\n\n
                                                      InferenceFS exposes a problem that is easy to forget when chatting with AI:<\/p>\n\n\n\n
                                                      \n
                                                      A highly plausible answer can feel like retrieval even when nothing was retrieved.<\/p>\n<\/blockquote>\n\n\n\n
                                                      Suppose you ask an LLM:<\/p>\n\n\n
                                                      What normally goes in \/etc\/nginx\/nginx.conf?\n<\/code><\/span><\/pre>\n\n\n
                                                      and it returns an excellent configuration.<\/p>\n\n\n\n
                                                      Your brain may think:<\/p>\n\n\n
                                                      \"It knows nginx.conf.\"<\/span>\n<\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      But what happened may really be:<\/p>\n\n\n
                                                      learned probability distribution\n+\nprompt\n+\ngeneration\n<\/code><\/span><\/pre>\n\n\n
                                                      InferenceFS makes that distinction impossible to ignore because the generated answer appears as a literal \u201cfile.\u201d<\/p>\n\n\n\n
                                                      \n\n\n\n
                                                      122. Plausibility Is Not Truth<\/h1>\n\n\n\n
                                                      InferenceFS teaches:<\/p>\n\n\n
                                                      syntactically correct\n\u2260\nfactually correct\n<\/code><\/span><\/pre>\n\n\n
                                                      and:<\/p>\n\n\n
                                                      looks like original\n\u2260\nis original\n<\/code><\/span><\/pre>\n\n\n
                                                      and:<\/p>\n\n\n
                                                      model confidence\n\u2260\nstorage integrity\n<\/code><\/span><\/pre>\n\n\n
                                                      and:<\/p>\n\n\n
                                                      generation\n\u2260\nretrieval\n<\/code><\/span><\/pre>\n\n\n
                                                      These distinctions are central to responsible AI engineering.<\/p>\n\n\n\n
                                                      \n\n\n\n
                                                      123. The Filename as Compressed Semantic Information<\/h1>\n\n\n\n
                                                      A filename like:<\/p>\n\n\n
                                                      nginx<\/span>.conf<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      contains very little byte-level information.<\/p>\n\n\n\n
                                                      But semantically it contains a lot.<\/p>\n\n\n\n
                                                      It implies:<\/p>\n\n\n\n
                                                        \n
                                                      • probably text,<\/li>\n\n\n\n
                                                      • probably NGINX syntax,<\/li>\n\n\n\n
                                                      • probably directives,<\/li>\n\n\n\n
                                                      • probably server<\/code>,<\/li>\n\n\n\n
                                                      • perhaps port 80,<\/li>\n\n\n\n
                                                      • perhaps location \/<\/code>,<\/li>\n\n\n\n
                                                      • perhaps log paths.<\/li>\n<\/ul>\n\n\n\n
                                                        An LLM can expand that semantic hint into hundreds of plausible bytes.<\/p>\n\n\n\n
                                                        That is why the project feels like compression.<\/p>\n\n\n\n
                                                        But the reconstructed details are largely invented.<\/p>\n\n\n\n
                                                        \n\n\n\n
                                                        124. Semantic Compression vs Lossless Compression<\/h1>\n\n\n\n
                                                        Consider:<\/p>\n\n\n
                                                        wedding_photo<\/span>.jpg<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                        The filename tells us:<\/p>\n\n\n
                                                        photo\nwedding\nJPEG\n<\/code><\/span><\/pre>\n\n\n
                                                        But not:<\/p>\n\n\n\n
                                                          \n
                                                        • who was present,<\/li>\n\n\n\n
                                                        • what anyone looked like,<\/li>\n\n\n\n
                                                        • where they stood,<\/li>\n\n\n\n
                                                        • exact pixels,<\/li>\n\n\n\n
                                                        • camera settings,<\/li>\n\n\n\n
                                                        • colors,<\/li>\n\n\n\n
                                                        • timestamp.<\/li>\n<\/ul>\n\n\n\n
                                                          An LLM or generative image model could create a convincing wedding image.<\/p>\n\n\n\n
                                                          But nearly all information from the original photograph has been lost.<\/p>\n\n\n\n
                                                          That is semantic reconstruction<\/strong>, not lossless decompression.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          125. Information-Theoretic Perspective<\/h1>\n\n\n\n
                                                          Suppose your original file contains:<\/p>\n\n\n
                                                          N bits\n<\/code><\/span><\/pre>\n\n\n
                                                          A filename may contain only:<\/p>\n\n\n
                                                          M bits\n<\/code><\/span><\/pre>\n\n\n
                                                          where:<\/p>\n\n\n
                                                          M << N\n<\/code><\/span><\/pre>\n\n\n
                                                          There is no way for those M bits to uniquely distinguish all possible N-bit files.<\/p>\n\n\n\n
                                                          The missing information must come from somewhere.<\/p>\n\n\n\n
                                                          InferenceFS supplies it from:<\/p>\n\n\n
                                                          model priors\n<\/code><\/span><\/pre>\n\n\n
                                                          rather than from the original file.<\/p>\n\n\n\n
                                                          That is why the output can be plausible but cannot generally be exact.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          126. A Simple Proof<\/h1>\n\n\n\n
                                                          Suppose the filename is:<\/p>\n\n\n
                                                          a<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Could the original content be:<\/p>\n\n\n
                                                          Hello\n<\/code><\/span><\/pre>\n\n\n
                                                          Yes.<\/p>\n\n\n\n
                                                          Could it also be:<\/p>\n\n\n
                                                          Goodbye\n<\/code><\/span><\/pre>\n\n\n
                                                          Yes.<\/p>\n\n\n\n
                                                          Could it contain an entire novel?<\/p>\n\n\n\n
                                                          Yes.<\/p>\n\n\n\n
                                                          Could it contain random bytes?<\/p>\n\n\n\n
                                                          Yes.<\/p>\n\n\n\n
                                                          The same filename corresponds to effectively unbounded possible contents.<\/p>\n\n\n\n
                                                          Therefore:<\/p>\n\n\n
                                                          filename alone\n<\/code><\/span><\/pre>\n\n\n
                                                          cannot uniquely identify the original content.<\/p>\n\n\n\n
                                                          No model intelligence can change that fundamental information deficit.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          127. LLM Weights Are Not a Filesystem<\/h1>\n\n\n\n
                                                          A model’s parameters encode statistical structure learned during training.<\/p>\n\n\n\n
                                                          They are not generally a dictionary like:<\/p>\n\n\n
                                                          \/path\/file1 \u2192 exact bytes\n\/path\/file2 \u2192 exact bytes\n\/path\/file3 \u2192 exact bytes\n<\/code><\/span><\/pre>\n\n\n
                                                          Even when models reproduce remembered passages, treating model parameters as a deterministic data archive is the wrong abstraction.<\/p>\n\n\n\n
                                                          InferenceFS deliberately exaggerates that mistaken assumption.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          128. A Gold-Standard Learning Lab<\/h1>\n\n\n\n
                                                          Install dependencies:<\/p>\n\n\n
                                                          sudo apt update\n\nsudo apt install -y \\\n    fuse3 \\\n    libfuse3-dev \\\n    pkg-config \\\n    build-essential\n<\/code><\/span><\/pre>\n\n\n
                                                          Clone:<\/p>\n\n\n
                                                          git clone<\/span> https:\/\/github.com\/philipl\/inferencefs.git<\/span>\ncd inferencefs\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Prepare Python environment:<\/p>\n\n\n
                                                          uv sync\n<\/code><\/span><\/pre>\n\n\n
                                                          Create directories:<\/p>\n\n\n
                                                          mkdir -p \/tmp\/inference-source\nmkdir -p \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                                                          Configure API:<\/p>\n\n\n
                                                          export<\/span> API_KEY=\"YOUR_API_KEY\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Mount:<\/p>\n\n\n
                                                          uv run inferencefs \\\n    -d \\\n    --backend gemini \\\n    \/tmp\/inference-source \\\n    \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                                                          \n\n\n\n
                                                          129. Lab 1 \u2014 Text Generation<\/h1>\n\n\n\n
                                                          Another terminal:<\/p>\n\n\n
                                                          touch \/tmp\/inference-mount\/hello.py\n<\/code><\/span><\/pre>\n\n\n
                                                          Read:<\/p>\n\n\n
                                                          cat \/tmp\/inference-mount\/hello.py\n<\/code><\/span><\/pre>\n\n\n
                                                          Observe the original terminal logs.<\/p>\n\n\n\n
                                                          Read again:<\/p>\n\n\n
                                                          cat \/tmp\/inference-mount\/hello.py\n<\/code><\/span><\/pre>\n\n\n
                                                          The second read should normally be served from the cache rather than generate content again.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          130. Lab 2 \u2014 Filename Semantics<\/h1>\n\n\n\n
                                                          Create:<\/p>\n\n\n
                                                          touch \/tmp\/inference-mount\/README.md\ntouch \/tmp\/inference-mount\/Dockerfile\ntouch \/tmp\/inference-mount\/package.json\ntouch \/tmp\/inference-mount\/requirements.txt\n<\/code><\/span><\/pre>\n\n\n
                                                          Read each:<\/p>\n\n\n
                                                          for<\/span> f in README.md Dockerfile package.json requirements.txt; do<\/span>\n    echo<\/span> \"===== $f =====\"<\/span>\n    cat \"\/tmp\/inference-mount\/$f\"<\/span>\ndone\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Observe what conventions the model associates with each filename.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          131. Lab 3 \u2014 Write Discard<\/h1>\n\n\n\n
                                                          Run:<\/p>\n\n\n
                                                          printf 'THIS IS MY EXACT CONTENT'<\/span> \\\n    > \/tmp\/i<\/span>nference-mount\/exact.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Then read:<\/p>\n\n\n
                                                          cat \/tmp\/inference-mount\/exact.txt\n<\/code><\/span><\/pre>\n\n\n
                                                          Do not expect:<\/p>\n\n\n
                                                          THIS IS MY EXACT CONTENT\n<\/code><\/span><\/pre>\n\n\n
                                                          Then inspect:<\/p>\n\n\n
                                                          cat \/tmp\/inference-source\/exact.txt\n<\/code><\/span><\/pre>\n\n\n
                                                          This demonstrates payload discard and size persistence.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          132. Lab 4 \u2014 Cache<\/h1>\n\n\n\n
                                                          Run:<\/p>\n\n\n
                                                          cat \/tmp\/inference-mount\/config.yaml > \/tmp\/<\/span>read1\ncat \/tmp\/inference-mount\/config.yaml > \/tmp\/<\/span>read2\n\ncmp \/tmp\/read1 \/tmp\/read2\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          While cached, they should normally match.<\/p>\n\n\n\n
                                                          Then restart the filesystem and compare again.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          133. Lab 5 \u2014 Nondeterminism<\/h1>\n\n\n\n
                                                          Save one run:<\/p>\n\n\n
                                                          cat \/tmp\/inference-mount\/config.yaml > \/tmp\/<\/span>version1\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Unmount:<\/p>\n\n\n
                                                          fusermount3 -u \/tmp\/inference-mount\n<\/code><\/span><\/pre>\n\n\n
                                                          Start again.<\/p>\n\n\n\n
                                                          Save:<\/p>\n\n\n
                                                          cat \/tmp\/inference-mount\/config.yaml > \/tmp\/<\/span>version2\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Compare:<\/p>\n\n\n
                                                          diff -u \/tmp\/version1 \/tmp\/version2\n<\/code><\/span><\/pre>\n\n\n
                                                          This is an excellent demonstration of generative persistence failure.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          134. Lab 6 \u2014 Binary Formats<\/h1>\n\n\n\n
                                                          Create:<\/p>\n\n\n
                                                          touch \/tmp\/inference-mount\/photo.png\ntouch \/tmp\/inference-mount\/report.pdf\ntouch \/tmp\/inference-mount\/app.elf\ntouch \/tmp\/inference-mount\/archive.zip\n<\/code><\/span><\/pre>\n\n\n
                                                          Copy generated bytes:<\/p>\n\n\n
                                                          cp \/tmp\/inference-mount\/photo.png \/tmp\/photo.png\ncp \/tmp\/inference-mount\/report.pdf \/tmp\/report.pdf\ncp \/tmp\/inference-mount\/app.elf \/tmp\/app.elf\ncp \/tmp\/inference-mount\/archive.zip \/tmp\/archive.zip\n<\/code><\/span><\/pre>\n\n\n
                                                          Inspect:<\/p>\n\n\n
                                                          file \/tmp\/photo.png\nfile \/tmp\/report.pdf\nfile \/tmp\/app.elf\nfile \/tmp\/archive.zip\n<\/code><\/span><\/pre>\n\n\n
                                                          Then validate internals.<\/p>\n\n\n\n
                                                          For ZIP:<\/p>\n\n\n
                                                          unzip -t \/tmp\/archive.zip\n<\/code><\/span><\/pre>\n\n\n
                                                          This often highlights the difference between a recognizable header and a truly valid format.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          135. Lab 7 \u2014 Compare Models<\/h1>\n\n\n\n
                                                          Generate the same filename using:<\/p>\n\n\n
                                                          Gemini\nClaude\nClaude Code\n<\/code><\/span><\/pre>\n\n\n
                                                          Compare:<\/p>\n\n\n
                                                          correctness\nsyntax\nlength\nstyle\nbinary validity\nlatency\n<\/code><\/span><\/pre>\n\n\n
                                                          This turns InferenceFS into an entertaining qualitative model benchmark.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          136. Lab 8 \u2014 Path Context<\/h1>\n\n\n\n
                                                          Create:<\/p>\n\n\n
                                                          mkdir -p \/tmp\/inference-mount\/aws\nmkdir -p \/tmp\/inference-mount\/kubernetes\nmkdir -p \/tmp\/inference-mount\/docker\n<\/code><\/span><\/pre>\n\n\n
                                                          Then:<\/p>\n\n\n
                                                          touch \/tmp\/inference-mount\/aws\/config.yaml\ntouch \/tmp\/inference-mount\/kubernetes\/config.yaml\ntouch \/tmp\/inference-mount\/docker\/config.yaml\n<\/code><\/span><\/pre>\n\n\n
                                                          Read them.<\/p>\n\n\n\n
                                                          The directory context should influence model interpretation.<\/p>\n\n\n\n
                                                          \n\n\n\n
                                                          137. Lab 9 \u2014 DevOps Model Knowledge<\/h1>\n\n\n\n
                                                          Create:<\/p>\n\n\n
                                                          terraform\/main.tf\nkubernetes\/deployment.yaml\nhelm\/values.yaml\nansible\/playbook.yaml\n.github\/workflows\/ci.yaml\nprometheus\/prometheus.yml\notel\/collector.yaml\n<\/code><\/span><\/pre>\n\n\n
                                                          Examine:<\/p>\n\n\n\n
                                                            \n
                                                          • version freshness,<\/li>\n\n\n\n
                                                          • deprecated APIs,<\/li>\n\n\n\n
                                                          • security defaults,<\/li>\n\n\n\n
                                                          • syntax validity,<\/li>\n\n\n\n
                                                          • assumptions,<\/li>\n\n\n\n
                                                          • hallucinated properties.<\/li>\n<\/ul>\n\n\n\n
                                                            This is particularly useful for AI-assisted DevOps education.<\/p>\n\n\n\n
                                                            \n\n\n\n
                                                            138. Lab 10 \u2014 What Models Don’t Know<\/h1>\n\n\n\n
                                                            Create obscure or invented filenames:<\/p>\n\n\n
                                                            xyzzy-q91<\/span>.conf<\/span>\nfoo<\/span>.bar<\/span>.baz<\/span>\ncompany-secret-format<\/span>.dat<\/span>\ncustomprotocol<\/span>.v99<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                            Observe how the model fills information gaps.<\/p>\n\n\n\n
                                                            You will likely see stronger hallucination as semantic hints decrease.<\/p>\n\n\n\n
                                                            This demonstrates how generation quality depends heavily on prior probability.<\/p>\n\n\n\n
                                                            \n\n\n\n
                                                            139. Best Practices for Safe Experimentation<\/h1>\n\n\n\n
                                                            For an InferenceFS lab:<\/p>\n\n\n\n
                                                              \n
                                                            1. Use disposable directories.<\/li>\n\n\n\n
                                                            2. Use no personal data.<\/li>\n\n\n\n
                                                            3. Use no secrets.<\/li>\n\n\n\n
                                                            4. Use no real production filenames if sensitive.<\/li>\n\n\n\n
                                                            5. Monitor API spend.<\/li>\n\n\n\n
                                                            6. Keep cache sizes reasonable.<\/li>\n\n\n\n
                                                            7. Enable debug mode while learning.<\/li>\n\n\n\n
                                                            8. Validate binary output before opening it.<\/li>\n\n\n\n
                                                            9. Never execute generated binaries.<\/li>\n\n\n\n
                                                            10. Assume all generated content is untrusted.<\/li>\n\n\n\n
                                                            11. Never interpret output as recovered original data.<\/li>\n\n\n\n
                                                            12. Unmount when finished.<\/li>\n<\/ol>\n\n\n\n
                                                              \n\n\n\n
                                                              140. Architecture Summary<\/h1>\n\n\n\n
                                                                                       User Program\n                              |\n                              | POSIX operations\n                              v\n                         Linux Kernel\n                              |\n                              | FUSE\n                              v\n                          pyfuse3\n                              |\n                              v\n                       InferenceFS\n                   +----------+----------+\n                   |                     |\n                   v                     v\n            Source metadata         Content request\n            directory                    |\n                                         v\n                                   LRU cache lookup\n                                    \/           \\\n                                 hit             miss\n                                  |               |\n                                  v               v\n                               bytes         LLM backend\n                                                  |\n                              +-------------------+-------------------+\n                              |                   |                   |\n                              v                   v                   v\n                           Gemini              Claude            Claude Code\n                              |                   |                   |\n                              +-------------------+-------------------+\n                                                  |\n                                                  v\n                                       text \/ base64 response\n                                                  |\n                                                  v\n                                      response decoder\n                                                  |\n                                                  v\n                                          generated bytes\n                                                  |\n                                                  v\n                                             LRU cache\n                                                  |\n                                                  v\n                                             application\n<\/code><\/pre>\n\n\n\n
                                                              \n\n\n\n
                                                              141. Read Workflow<\/h1>\n\n\n
                                                              cat foo.py\n   |\n   v\nopen(foo.py)\n   |\n   v\nread(foo.py)\n   |\n   v\ncache?\n   |\n   +---- yes ---> return<\/span> cached bytes\n   |\n   +---- no\n          |\n          v\n      prompt LLM\n          |\n          v\n     receive output\n          |\n          v\n   decode if<\/span> binary\n          |\n          v\n      cache bytes\n          |\n          v\n     return<\/span> slice\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                              \n\n\n\n
                                                              142. Write Workflow<\/h1>\n\n\n
                                                              echo<\/span> hello > foo.txt\n       |\n       v\n     create\n       |\n       v\n     write\n       |\n       +---- input bytes discarded\n       |\n       v\ntrack max written offset\n       |\n       v\n     release\n       |\n       v\npersist numeric file size\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                              Later:<\/p>\n\n\n
                                                              cat foo.txt\n    |\n    v\nLLM generates \"foo.txt\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                              Not:<\/p>\n\n\n
                                                              return<\/span> \"hello\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                              \n\n\n\n
                                                              143. What InferenceFS Gets Surprisingly Right<\/h1>\n\n\n\n
                                                              From an engineering perspective, several design decisions are sensible:<\/p>\n\n\n\n
                                                                \n
                                                              • lazy generation,<\/li>\n\n\n\n
                                                              • backend abstraction,<\/li>\n\n\n\n
                                                              • bounded LRU cache,<\/li>\n\n\n\n
                                                              • asynchronous FUSE integration,<\/li>\n\n\n\n
                                                              • rate-limit handling,<\/li>\n\n\n\n
                                                              • binary response recovery,<\/li>\n\n\n\n
                                                              • API-key validation,<\/li>\n\n\n\n
                                                              • persistent apparent sizes,<\/li>\n\n\n\n
                                                              • inode lifecycle management,<\/li>\n\n\n\n
                                                              • extensive automated testing,<\/li>\n\n\n\n
                                                              • clean packaging.<\/li>\n<\/ul>\n\n\n\n
                                                                That combination is why studying the repository is worthwhile even though its storage model is deliberately ridiculous.<\/p>\n\n\n\n
                                                                \n\n\n\n
                                                                144. What InferenceFS Deliberately Gets Wrong<\/h1>\n\n\n\n
                                                                The central storage semantics are intentionally broken:<\/p>\n\n\n
                                                                writes do<\/span> not preserve content\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                and:<\/p>\n\n\n
                                                                reads generate guesses\n<\/code><\/span><\/pre>\n\n\n
                                                                Consequently it cannot guarantee:<\/p>\n\n\n\n
                                                                  \n
                                                                • durability,<\/li>\n\n\n\n
                                                                • fidelity,<\/li>\n\n\n\n
                                                                • consistency,<\/li>\n\n\n\n
                                                                • reproducibility,<\/li>\n\n\n\n
                                                                • exact recovery,<\/li>\n\n\n\n
                                                                • data integrity,<\/li>\n\n\n\n
                                                                • stable content identity.<\/li>\n<\/ul>\n\n\n\n
                                                                  That is the point.<\/p>\n\n\n\n
                                                                  \n\n\n\n
                                                                  145. The Real Lesson About Generative AI<\/h1>\n\n\n\n
                                                                  InferenceFS illustrates one of the most important rules of modern AI:<\/p>\n\n\n\n
                                                                  \n
                                                                  A generative model should not be treated as a database merely because it can produce answers that resemble stored information.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
                                                                  If exact source truth matters, use:<\/p>\n\n\n
                                                                  database\nsearch\nRAG\nobject storage\ndocument<\/span> store\nsource repository\nAPI\nverified external source\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                  and then use the model to reason over that evidence.<\/p>\n\n\n\n
                                                                  Do not ask probability to masquerade as persistence.<\/p>\n\n\n\n
                                                                  \n\n\n\n
                                                                  146. The Real Lesson About RAG<\/h1>\n\n\n\n
                                                                  InferenceFS also explains why RAG exists.<\/p>\n\n\n\n
                                                                  Without retrieval:<\/p>\n\n\n
                                                                  question\n \u2193\nmodel prior\n \u2193\nplausible answer\n<\/code><\/span><\/pre>\n\n\n
                                                                  With retrieval:<\/p>\n\n\n
                                                                  question\n \u2193\nsearch real source\n \u2193\nrelevant evidence\n \u2193\nmodel reasoning\n \u2193\ngrounded answer\n<\/code><\/span><\/pre>\n\n\n
                                                                  The difference is similar to:<\/p>\n\n\n
                                                                  InferenceFS\n<\/code><\/span><\/pre>\n\n\n
                                                                  versus:<\/p>\n\n\n
                                                                  an actual filesystem\n<\/code><\/span><\/pre>\n\n\n
                                                                  That is a memorable mental model.<\/p>\n\n\n\n
                                                                  \n\n\n\n
                                                                  147. The Real Lesson About AI Coding<\/h1>\n\n\n\n
                                                                  Suppose you ask:<\/p>\n\n\n
                                                                  Generate my company's existing deployment.yaml.\n<\/code><\/span><\/pre>\n\n\n
                                                                  Without access to your repository, an LLM might produce an excellent Kubernetes manifest.<\/p>\n\n\n\n
                                                                  But that is:<\/p>\n\n\n
                                                                  a<\/span> deployment<\/span>.yaml<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                  not necessarily:<\/p>\n\n\n
                                                                  your<\/span> deployment<\/span>.yaml<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                  InferenceFS makes exactly this error intentionally.<\/p>\n\n\n\n
                                                                  The same principle applies to AI coding assistants:<\/p>\n\n\n\n
                                                                  \n
                                                                  Give the model the real codebase when exact project context matters.<\/p>\n<\/blockquote>\n\n\n\n
                                                                  \n\n\n\n
                                                                  148. The Real Lesson About \u201cMemory\u201d<\/h1>\n\n\n\n
                                                                  If an AI model can generate a plausible:<\/p>\n\n\n
                                                                  README<\/span>.md<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                  that does not establish that it retrieved a specific README from training.<\/p>\n\n\n\n
                                                                  Generation can arise from learned structure and probabilities.<\/p>\n\n\n\n
                                                                  InferenceFS helps separate:<\/p>\n\n\n
                                                                  memorization\n<\/code><\/span><\/pre>\n\n\n
                                                                  from:<\/p>\n\n\n
                                                                  generalization\n<\/code><\/span><\/pre>\n\n\n
                                                                  and from:<\/p>\n\n\n
                                                                  retrieval\n<\/code><\/span><\/pre>\n\n\n
                                                                  Even when outputs look familiar, determining which mechanism produced them can be nontrivial.<\/p>\n\n\n\n
                                                                  \n\n\n\n
                                                                  149. Suggested Learning Path<\/h1>\n\n\n\n
                                                                  Beginner<\/h2>\n\n\n\n
                                                                  Understand:<\/p>\n\n\n\n
                                                                    \n
                                                                  • FUSE,<\/li>\n\n\n\n
                                                                  • filesystem mounts,<\/li>\n\n\n\n
                                                                  • filenames vs contents,<\/li>\n\n\n\n
                                                                  • LLM generation.<\/li>\n<\/ul>\n\n\n\n
                                                                    Intermediate<\/h2>\n\n\n\n
                                                                    Run InferenceFS and experiment with:<\/p>\n\n\n\n
                                                                      \n
                                                                    • text files,<\/li>\n\n\n\n
                                                                    • path context,<\/li>\n\n\n\n
                                                                    • cache behavior,<\/li>\n\n\n\n
                                                                    • writes,<\/li>\n\n\n\n
                                                                    • remounts.<\/li>\n<\/ul>\n\n\n\n
                                                                      Advanced<\/h2>\n\n\n\n
                                                                      Study:<\/p>\n\n\n\n
                                                                        \n
                                                                      • pyfuse3<\/code>,<\/li>\n\n\n\n
                                                                      • Trio,<\/li>\n\n\n\n
                                                                      • inode lifecycle,<\/li>\n\n\n\n
                                                                      • LRU caching,<\/li>\n\n\n\n
                                                                      • API backends,<\/li>\n\n\n\n
                                                                      • base64 decoder,<\/li>\n\n\n\n
                                                                      • rate-limit behavior.<\/li>\n<\/ul>\n\n\n\n
                                                                        Expert<\/h2>\n\n\n\n
                                                                        Use the project to study:<\/p>\n\n\n\n
                                                                          \n
                                                                        • information theory,<\/li>\n\n\n\n
                                                                        • LLM memorization,<\/li>\n\n\n\n
                                                                        • semantic compression,<\/li>\n\n\n\n
                                                                        • model priors,<\/li>\n\n\n\n
                                                                        • hallucination,<\/li>\n\n\n\n
                                                                        • reproducibility,<\/li>\n\n\n\n
                                                                        • binary format generation,<\/li>\n\n\n\n
                                                                        • retrieval vs generative knowledge.<\/li>\n<\/ul>\n\n\n\n
                                                                          \n\n\n\n
                                                                          150. Command Cheat Sheet<\/h1>\n\n\n\n
                                                                          Install system dependencies:<\/p>\n\n\n
                                                                          sudo apt install \\\n    fuse3 \\\n    libfuse3-dev \\\n    pkg-config \\\n    build-essential\n<\/code><\/span><\/pre>\n\n\n
                                                                          Clone:<\/p>\n\n\n
                                                                          git clone<\/span> https:\/\/github.com\/philipl\/inferencefs.git<\/span>\ncd inferencefs\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                          Install:<\/p>\n\n\n
                                                                          uv sync\n<\/code><\/span><\/pre>\n\n\n
                                                                          Prepare:<\/p>\n\n\n
                                                                          mkdir -p \/tmp\/source \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                                                                          Gemini:<\/p>\n\n\n
                                                                          export<\/span> API_KEY=\"...\"<\/span>\nuv run inferencefs \\\n    --backend gemini \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                          Claude:<\/p>\n\n\n
                                                                          export<\/span> API_KEY=\"...\"<\/span>\nuv run inferencefs \\\n    --backend claude \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                          Claude Code:<\/p>\n\n\n
                                                                          uv run inferencefs \\\n    --backend claude-code \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                                                                          Debug:<\/p>\n\n\n
                                                                          uv run inferencefs \\\n    -d \\\n    --backend gemini \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                                                                          64 MiB cache:<\/p>\n\n\n
                                                                          uv run inferencefs \\\n    --backend gemini \\\n    --cache-size 64 \\\n    \/tmp\/source \\\n    \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                                                                          Create:<\/p>\n\n\n
                                                                          touch \/tmp\/mount\/hello.py\n<\/code><\/span><\/pre>\n\n\n
                                                                          Read:<\/p>\n\n\n
                                                                          cat \/tmp\/mount\/hello.py\n<\/code><\/span><\/pre>\n\n\n
                                                                          Unmount:<\/p>\n\n\n
                                                                          fusermount3 -u \/tmp\/mount\n<\/code><\/span><\/pre>\n\n\n
                                                                          Tests:<\/p>\n\n\n
                                                                          uv run pytest\n<\/code><\/span><\/pre>\n\n\n
                                                                          Lint:<\/p>\n\n\n
                                                                          uv run ruff check src tests\n<\/code><\/span><\/pre>\n\n\n
                                                                          \n\n\n\n
                                                                          151. Frequently Asked Questions<\/h1>\n\n\n\n
                                                                          Is InferenceFS a real filesystem?<\/h2>\n\n\n\n
                                                                          It is a real FUSE filesystem implementation.<\/p>\n\n\n\n
                                                                          Its persistence semantics are intentionally not those of normal storage.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Does it actually store my file contents?<\/h2>\n\n\n\n
                                                                          No.<\/p>\n\n\n\n
                                                                          Written bytes are discarded by the current implementation.<\/p>\n\n\n\n
                                                                          Only metadata such as paths and apparent written sizes is retained.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Can it recover my original file?<\/h2>\n\n\n\n
                                                                          Generally, no.<\/p>\n\n\n\n
                                                                          It asks an LLM to produce what that filename probably contains.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          What happens if I write data and read it back?<\/h2>\n\n\n\n
                                                                          You should not expect the written bytes.<\/p>\n\n\n\n
                                                                          The read result is generated by the model.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Why does write()<\/code> report success?<\/h2>\n\n\n\n
                                                                          Because the filesystem deliberately accepts writes while discarding payloads.<\/p>\n\n\n\n
                                                                          It reports the number of bytes as successfully written and records apparent size.<\/p>\n\n\n\n
                                                                          That behavior is part of the project’s design.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Is generated content cached?<\/h2>\n\n\n\n
                                                                          Yes.<\/p>\n\n\n\n
                                                                          InferenceFS uses a configurable in-memory LRU cache.<\/p>\n\n\n\n
                                                                          The default is approximately:<\/p>\n\n\n
                                                                          256 MiB\n<\/code><\/span><\/pre>\n\n\n
                                                                          \n\n\n\n
                                                                          Does the cache survive restart?<\/h2>\n\n\n\n
                                                                          No.<\/p>\n\n\n\n
                                                                          The generated content cache is process memory.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Will the same filename always produce the same content?<\/h2>\n\n\n\n
                                                                          No guarantee.<\/p>\n\n\n\n
                                                                          Outputs may change after regeneration.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Does InferenceFS support binary files?<\/h2>\n\n\n\n
                                                                          It attempts to.<\/p>\n\n\n\n
                                                                          The model is asked for base64 representations, which the application decodes.<\/p>\n\n\n\n
                                                                          Common format headers can work surprisingly well, but complex compressed\/cross-referenced structures may be invalid.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Is InferenceFS safe for production?<\/h2>\n\n\n\n
                                                                          No.<\/p>\n\n\n\n
                                                                          The author explicitly labels it an April Fools’ project and warns against storing anything important with it.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          What Python version does it require?<\/h2>\n\n\n\n
                                                                          Current packaging requires:<\/p>\n\n\n
                                                                          Python<\/span> 3.14<\/span>+\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                          \n\n\n\n
                                                                          What is the latest published version?<\/h2>\n\n\n\n
                                                                          As of September 2026, PyPI lists:<\/p>\n\n\n
                                                                          1.0<\/span>.0<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                          released:<\/p>\n\n\n
                                                                          April 1, 2026\n<\/code><\/span><\/pre>\n\n\n
                                                                          \n\n\n\n
                                                                          Which backend should I start with?<\/h2>\n\n\n\n
                                                                          The project’s current README recommends Gemini for the preferred out-of-the-box demonstration.<\/p>\n\n\n\n
                                                                          Provider capabilities, prices and model availability can change, so check the provider before running large experiments.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Does Claude Code require an API key?<\/h2>\n\n\n\n
                                                                          InferenceFS itself does not request one for the claude-code<\/code> backend.<\/p>\n\n\n\n
                                                                          It relies on the locally installed Claude CLI’s authentication.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Can InferenceFS replace S3?<\/h2>\n\n\n\n
                                                                          Absolutely not.<\/p>\n\n\n\n
                                                                          S3 stores bytes.<\/p>\n\n\n\n
                                                                          InferenceFS guesses bytes.<\/p>\n\n\n\n
                                                                          That distinction is rather important.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Can it replace Git?<\/h2>\n\n\n\n
                                                                          No.<\/p>\n\n\n\n
                                                                          Git’s design is built around exact content identity.<\/p>\n\n\n\n
                                                                          InferenceFS intentionally provides no such guarantee.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          Can it be used for generating boilerplate?<\/h2>\n\n\n\n
                                                                          Technically, the underlying concept can inspire useful tools.<\/p>\n\n\n\n
                                                                          A system where:<\/p>\n\n\n
                                                                          filename\/path\n\u2192 generate scaffold\n<\/code><\/span><\/pre>\n\n\n
                                                                          could be useful.<\/p>\n\n\n\n
                                                                          But that is better implemented explicitly as a code generator, template engine or AI scaffolding tool\u2014not disguised as persistent storage.<\/p>\n\n\n\n
                                                                          \n\n\n\n
                                                                          152. From Joke to Useful Design Pattern<\/h1>\n\n\n\n
                                                                          Interestingly, a safer version of the concept could be genuinely useful.<\/p>\n\n\n\n
                                                                          Imagine a GenerativeFS<\/strong> where files marked as virtual are intentionally generated:<\/p>\n\n\n
                                                                          \/generated\/\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 architecture.md\n\u251c\u2500\u2500 api-examples.md\n\u2514\u2500\u2500 test-data.json\n<\/code><\/span><\/pre>\n\n\n
                                                                          But unlike InferenceFS, the system would clearly distinguish:<\/p>\n\n\n
                                                                          generated virtual artifacts\n<\/code><\/span><\/pre>\n\n\n
                                                                          from:<\/p>\n\n\n
                                                                          persistent files\n<\/code><\/span><\/pre>\n\n\n
                                                                          It could:<\/p>\n\n\n\n
                                                                            \n
                                                                          • persist generations,<\/li>\n\n\n\n
                                                                          • record model\/version,<\/li>\n\n\n\n
                                                                          • record prompts,<\/li>\n\n\n\n
                                                                          • store hashes,<\/li>\n\n\n\n
                                                                          • track provenance,<\/li>\n\n\n\n
                                                                          • regenerate explicitly,<\/li>\n\n\n\n
                                                                          • show generated status.<\/li>\n<\/ul>\n\n\n\n
                                                                            That becomes a legitimate AI-powered virtual filesystem.<\/p>\n\n\n\n
                                                                            InferenceFS helps expose what safeguards such a real system would need.<\/p>\n\n\n\n
                                                                            \n\n\n\n
                                                                            153. What a Production Generative Filesystem Would Need<\/h1>\n\n\n\n
                                                                            At minimum:<\/p>\n\n\n
                                                                            content persistence\ncontent hashing\ngeneration provenance\nmodel identifier\nprompt version\ntimestamps\nexplicit regeneration\nversion history\ndeterministic mode where possible\naudit logs\nAPI cost controls\nsecrets management\nprivacy boundaries\nvalidation\ncontent safety\nchecksums\nuser-visible generated status\n<\/code><\/span><\/pre>\n\n\n
                                                                            Without those, generative content should never masquerade as durable storage.<\/p>\n\n\n\n
                                                                            \n\n\n\n
                                                                            154. \u03c0fs vs InferenceFS: The Bigger Lesson<\/h1>\n\n\n\n
                                                                            \u03c0fs asks:<\/p>\n\n\n\n
                                                                            \n
                                                                            Can deterministic mathematics replace storage?<\/p>\n<\/blockquote>\n\n\n\n
                                                                            Answer:<\/p>\n\n\n
                                                                            Not without retaining enough information to identify the original data.\n<\/code><\/span><\/pre>\n\n\n
                                                                            InferenceFS asks:<\/p>\n\n\n\n
                                                                            \n
                                                                            Can model knowledge replace storage?<\/p>\n<\/blockquote>\n\n\n\n
                                                                            Answer:<\/p>\n\n\n
                                                                            Only if<\/span> you are willing to replace exact information with<\/span> plausible reconstruction.\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                            Together, they make a wonderful pair.<\/p>\n\n\n\n
                                                                            \u03c0fs<\/h3>\n\n\n
                                                                            exact-ish reconstruction\n+\ntoo much metadata\n<\/code><\/span><\/pre>\n\n\n
                                                                            InferenceFS<\/h3>\n\n\n
                                                                            almost no metadata\n+\nalmost no guarantee of exact reconstruction\n<\/code><\/span><\/pre>\n\n\n
                                                                            One preserves information and pays for it.<\/p>\n\n\n\n
                                                                            The other discards information and asks probability to fill the gaps.<\/p>\n\n\n\n
                                                                            \n\n\n\n
                                                                            155. Final Takeaway<\/h1>\n\n\n\n
                                                                            InferenceFS begins with a wonderfully ridiculous proposition:<\/p>\n\n\n\n
                                                                            \n
                                                                            Why store files when an LLM can simply remember what files with those names usually look like?<\/p>\n<\/blockquote>\n\n\n\n
                                                                            The implementation then takes that idea seriously enough to expose its consequences.<\/p>\n\n\n\n
                                                                            A filename such as:<\/p>\n\n\n
                                                                            Dockerfile\n<\/code><\/span><\/pre>\n\n\n
                                                                            really can expand into a convincing Dockerfile.<\/p>\n\n\n\n
                                                                            A filename such as:<\/p>\n\n\n
                                                                            config<\/span>.yaml<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                            really can expand into plausible configuration.<\/p>\n\n\n\n
                                                                            A filename such as:<\/p>\n\n\n
                                                                            image<\/span>.png<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                                            may even cause a model to emit enough base64-encoded structure to resemble an actual PNG.<\/p>\n\n\n\n
                                                                            And that’s precisely why InferenceFS is valuable.<\/p>\n\n\n\n
                                                                            Because it demonstrates how easy it is to confuse:<\/p>\n\n\n
                                                                            plausibility\n<\/code><\/span><\/pre>\n\n\n
                                                                            with:<\/p>\n\n\n
                                                                            truth\n<\/code><\/span><\/pre>\n\n\n
                                                                            and:<\/p>\n\n\n
                                                                            generation\n<\/code><\/span><\/pre>\n\n\n
                                                                            with:<\/p>\n\n\n
                                                                            retrieval\n<\/code><\/span><\/pre>\n\n\n
                                                                            and:<\/p>\n\n\n
                                                                            semantic familiarity\n<\/code><\/span><\/pre>\n\n\n
                                                                            with:<\/p>\n\n\n
                                                                            exact memory\n<\/code><\/span><\/pre>\n\n\n
                                                                            and:<\/p>\n\n\n
                                                                            AI output\n<\/code><\/span><\/pre>\n\n\n
                                                                            with:<\/p>\n\n\n
                                                                            stored evidence\n<\/code><\/span><\/pre>\n\n\n
                                                                            A traditional filesystem promises:<\/p>\n\n\n\n
                                                                            \n
                                                                            Give me bytes and I will return the same bytes later.<\/p>\n<\/blockquote>\n\n\n\n
                                                                            InferenceFS promises something closer to:<\/p>\n\n\n\n
                                                                            \n
                                                                            Give me a filename and I’ll ask a model what probably belonged there.<\/p>\n<\/blockquote>\n\n\n\n
                                                                            Those are fundamentally different contracts.<\/p>\n\n\n\n
                                                                            InferenceFS deliberately chooses the second contract and wraps it inside an interface normally associated with the first.<\/p>\n\n\n\n
                                                                            That mismatch is the joke.<\/p>\n\n\n\n
                                                                            It is also the lesson.<\/p>\n\n\n\n
                                                                            And that makes InferenceFS a surprisingly powerful teaching tool for understanding not only filesystems, but the fundamental nature\u2014and limits\u2014of generative AI.<\/p>\n\n\n\n
                                                                            \n\n\n\n
                                                                            References<\/h1>\n\n\n\n
                                                                            The primary source is the official philipl\/inferencefs<\/strong> repository. The repository describes InferenceFS as the successor to \u03c0fs, documents its FUSE interface, backends, cache and quick-start workflow.<\/p>\n\n\n\n
                                                                            The project’s CLAUDE.md<\/strong> documents its internal architecture, lazy generation, pyfuse3 design, cache behavior, asynchronous execution, backend structure, testing and known limitations.<\/p>\n\n\n\n
                                                                            The current inferencefs.py<\/code> implementation<\/strong> shows the actual read\/write semantics, inode bookkeeping, LRU cache, retry handling, fake 1 GiB size, persisted written-size metadata and FUSE operations.<\/p>\n\n\n\n
                                                                            The current backends.py<\/code> implementation<\/strong> documents the LLM prompts, Claude\/Claude Code\/Gemini integrations, binary base64 processing and magic-byte detection.<\/p>\n\n\n\n
                                                                            The project’s technical appendix<\/strong> explains the intended lesson around LLMs as lossy compression and records experimental limitations with compressed, codec-specific and cross-referenced binary formats.<\/p>\n\n\n\n
                                                                            PyPI currently lists InferenceFS 1.0.0<\/strong>, released April 1, 2026, requiring Python 3.14+, under the AGPL-3.0-or-later license.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                                                            What Is InferenceFS, Why Does It Exist, How Does It Work, and What Does It Teach Us About LLMs? Updated: September 2026 InferenceFS may be one of… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_joinchat":[],"footnotes":""},"categories":[11138],"tags":[],"class_list":["post-78590","post","type-post","status-publish","format-standard","hentry","category-best-tools"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/78590","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/comments?post=78590"}],"version-history":[{"count":1,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/78590\/revisions"}],"predecessor-version":[{"id":78591,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/78590\/revisions\/78591"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media?parent=78590"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/categories?post=78590"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/tags?post=78590"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}