file-ipc-patterns

Implement filesystem-based interprocess communication with JSONL logs and atomic state files.

10|11|Updated Feb 22, 2026
One-click install
npx skills add https://github.com/microsoft/amplifier-bundle-skills --skill file-ipc-patterns
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: file-ipc-patterns
Source: https://github.com/microsoft/amplifier-bundle-skills/tree/main/skills/file-ipc-patterns
Command: npx skills add https://github.com/microsoft/amplifier-bundle-skills --skill file-ipc-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves cross-process communication when separate services, workers, or host and container processes need to exchange requests, state, and live events without introducing a message broker.

Core Features & Use Cases

  • File-based event streaming: Use JSONL append-only logs for replayable event history and tail-friendly live updates.
  • Atomic state snapshots: Maintain a current state.json that is always complete and safe to read.
  • Async request/response via files: Create request files, resolve them with matching response payloads, and bridge the result back to running async code.
  • SSE and monitoring patterns: Mirror filesystem events to subscribers for streaming dashboards, session monitoring, and long-running task visibility.

Quick Start

Ask the skill to design or implement a file-backed event bus with JSONL logs, atomic state updates, and request/response files for your multi-process application.

Frequently Asked Questions about file-ipc-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I handle interprocess communication between Python services without a message broker?

File-based interprocess communication enables separate Python services to exchange requests, state, and live events using the filesystem. It leverages JSONL append-only logging and atomic file replacement to safely sync processes without introducing a message broker.

How does atomic file replacement work for maintaining safe state snapshots?

Atomic state snapshots maintain a current state.json file that remains complete and safe to read during updates. This technique uses atomic file replacement to ensure concurrent processes never encounter partially written state data.

Can I stream live filesystem events to SSE subscribers for dashboard monitoring?

Yes, filesystem events can be mirrored to SSE subscribers for streaming dashboards and session monitoring. This pattern bridges JSONL append-only logs and state updates into live event streams for long-running task visibility.

What is the best way to implement async request-response coordination via files?

Async request-response via files involves creating request files and resolving them with matching response payloads. It bridges the result back to running asyncio code using safe request-id validation and thread-safe Future resolution.

Does this filesystem IPC approach work for host and container workflows?

Yes, filesystem interprocess communication applies directly to host-and-container workflows. By exchanging JSONL logs and atomic state files across shared volumes, separate processes can coordinate requests and events without network dependencies.

Why use JSONL append-only logging for file-based event streaming?

JSONL append-only logging provides a replayable event history and supports tail-friendly live updates. This format allows multiple processes to safely append events to a shared file for interprocess communication without locking conflicts.