ContextRail is an open-source harness framework designed to help AI agents work consistently, verifiably, and across sessions within software repositories. When an agent begins a new session, it coordinates where the project left off, the active task, established decisions, and past explorations without file sprawling or context window bloat across 5 Markdown layers and cross-platform validators.

Project Overview

Problem and Target

Agentic coding tools (Codex, Claude Code, Gemini, Cursor, etc.) are evolving rapidly, but they share a fundamental bottleneck: project memory.

When an agent begins a fresh session:

• Active task state is forgotten.
• Architectural rationales are lost.
• Redundant repo-wide scans waste tokens and latency.
• The human operator is repeatedly forced into tedious context reconstruction.

Common industry workarounds (monolithic rule files, fragmented micro-notes, or complex multi-agent orchestrators) either saturate the context window or induce navigational confusion. ContextRail solves this by organizing project state across 5 distinct lifecycle layers with deterministic mechanical validation.

Architecture Flow & Lifecycle

ContextRail structures project memory into 5 lifecycle-aligned Markdown layers:

• AGENTS.md — Operational guidelines and navigational routing
• SYSTEM.md — Project boundaries, components, and architectural invariants
• BOARD.md — Active tasks and current backlog status
• NOTES.md — Decision rationales, constraints, and permanent architectural memory
• HISTORY.md — Historical ledger of verified tasks and evidence logs

On top of these 5 layers, cross-platform native validator scripts (Bash, PowerShell, GitHub Actions) enforce contract compliance. It requires zero SDKs, runtime dependencies, or external vector stores; it drops cleanly into any existing repository.

Scope and Boundaries

ContextRail does:

• Provide agents with a clear, single entry point at session initialization.
• Decouple active work, decision rationales, and historical evidence into distinct lifecycle tiers.
• Direct agents toward targeted file reading instead of broad repository scanning.
• Anchor tasks and decisions via stable, unique identifiers.
• Govern third-party specifications through a structured handoff adoption workflow.
• Maintain permanent behavior boundaries in code via task-linked code traces.
• Mechanically validate metadata contracts across Linux, macOS, and Windows.
• Integrate into existing project test, build, and lint pipelines.

ContextRail does not:

• Impose a new programming language or framework.
• Introduce heavy runtime SDKs or libraries.
• Replace the project’s native test frameworks.
• Depend on embeddings, semantic search, or graph databases.
• Supplant the agent’s internal planning loop.

Solution Architecture

Lifecycle Separation

Information is organized strictly by lifecycle rather than arbitrary file counts:

• AGENTS.md → Operating rules and navigation map
• SYSTEM.md → Project boundary, core architecture, system invariants
• BOARD.md → Active backlog and task state
• NOTES.md → Permanent rationale and technical constraints
• HISTORY.md → Chronological evidence of completed tasks

The agent reads BOARD.md to discover its active assignment. It follows task-referenced decision IDs to query only relevant subsections of NOTES.md, referencing HISTORY.md only when verifying past implementations.

External Handoff Mechanism

Unprocessed specifications, audits, and design proposals land in handoffs/incoming/. The agent processes them via handoffs/HANDOFF.md: checking existing IDs, transcribing permanent context into Notes, deriving verifiable Board tasks, reporting discrepancies, and archiving or removing the source artifacts only upon successful validation.

Task-Linked Code Traceability

Durable invariants are anchored in code using concise inline comments:

ContextRail: TASK-0042
Invariant: Persistent mutation requires explicit authorization.

The task ID carries the comprehensive context, design rationale, and relational dependencies. The code comment simply references the governing task rather than logging historical diffs, and identical anchors are attached to accompanying regression tests.

Agent Compatibility Layer

Platform-specific instruction files route directly to the canonical guide:

• CLAUDE.md → Claude Code
• GEMINI.md → Gemini
• .github/copilot-instructions.md → GitHub Copilot
• .cursor/rules/00-agents.mdc → Cursor

Each file contains the single directive: “Read and follow AGENTS.md at repository root.”

Cross-Platform Validators

scripts/
  validate-linux.sh
  validate-macos.sh
  validate-windows.ps1

The validator scripts operate independently of application runtimes. They inspect Markdown metadata contracts directly:

• Enforcing mandatory files and system schema completeness.
• Guarding against lifecycle entries erroneously written into SYSTEM.md.
• Detecting duplicate IDs or conflicting titles.
• Validating task statuses and required evidence fields.
• Ensuring bidirectional reference integrity across superseded and related records.
• Verifying code traces against active lifecycle entities.

Two Repositories, Dual Distribution, Single Point of Truth

• minimum-governed-harness: Core development, governance rules, and release artifacts.
• contextrail-template: Clean, user-facing template repository for fresh projects.

New projects initialize directly from the GitHub template, while existing codebases install versioned release ZIP packages accompanied by SHA-256 checksum manifests.

Governance Guidelines

ContextRail formalizes operational discipline for agent workflows:

• External Handoff Adoption: Structured ingestion of external plans preventing duplication and hallucinated scope.
• Task-Linked Code Trace: Invariants explicitly tied to tasks in code and regression suites.
• Root Cause Before Patch: Agents must isolate broken invariants or transitions before attempting fixes.
• Independent Review: Self-evaluating changes against objective acceptance criteria prior to completion.
• Controlled Incidental Findings: Incidental issues discovered during tasks are documented with evidence rather than silently altered.
• Unified Validation Integration: Combining project test suites with ContextRail validators into a single gating check.
• Governed Delegation: Subagents execute scoped, low-risk routines while architectural state remains with the lead agent.

Open Source Distribution

• Core Repository: github.com/muisik/minimum-governed-harness — Public, MIT License
• Template Repository: github.com/muisik/contextrail-template — GitHub Template
• Releases: Downloadable ZIP distributions with checksum verification
• Supported Agents: Codex, Claude Code, Gemini, Cursor, GitHub Copilot

Related Links

Technical Deep Dive: Teach the Agent Where to Look, Not Everything at Once
Core Repository: github.com/muisik/minimum-governed-harness
Template Repository: github.com/muisik/contextrail-template

Last updated: October 2026 | Version: 1.0

Video to Slide is an open-source desktop tool designed to automatically capture lecture slides from YouTube videos, full playlists, or local video files. By filtering out whiteboard marker strokes and isolating the earliest clean frames, it converts lecture recordings into high-resolution PNG images, consolidated PDF documents, and editable PowerPoint (.pptx) presentations. It eliminates the tedious chore of pausing videos to take manual screenshots, providing students and researchers with clean digital study materials.

Project Overview

Motivation and Background

Taking comprehensive notes from video lectures is traditionally a slow, repetitive process. Viewers constantly pause playback, capture screenshots, crop boundaries, and paste images into notes.

Beyond the manual friction lies a common visual problem: instructors frequently annotate slides with digital pens or colored markers immediately after a slide appears. Conventional scene-detection tools typically grab the final state of each scene, resulting in saved images cluttered with scribbles, annotations, and partial occlusions.

Video to Slide was built to resolve this practical challenge:

• Process video links or local files with a single action,
• Automatically detect and capture the initial pristine slide frame before handwriting begins,
• Filter out colored marker strokes during frame comparisons to accurately identify slide transitions,
• Compile results directly into clean PDF documents and editable PowerPoint decks.

Algorithmic Approach

As the engine scans video streams frame by frame, it applies two core computer vision heuristics:

First Clean Frame Detection

When a slide advances during a lecture, the display stabilizes briefly before the instructor begins drawing or gesturing. Once the transition is recognized, the algorithm locks onto the earliest stable frame before motion thresholds are breached. This ensures that subsequent handwritten annotations do not degrade the captured slide.

Whiteboard Marker Filtering

Vibrant marker strokes can distort conventional frame-difference calculations. The comparison pipeline isolates and filters these high-saturation strokes, distinguishing true slide transitions from local handwriting without sacrificing the quality of the underlying original image.

Key Capabilities and Formats

• Multi-Source Ingestion: Ingests individual YouTube URLs, complete playlists, local .mp4, .mkv, .mov, .webm files, or entire directories of recordings in batch mode.
• Versatile Output Formats:
• High-resolution individual PNG slide images,
• Merged PDF lecture notes,
• Editable PowerPoint (.pptx) presentations with slides arranged sequentially.
• Bilingual Interface: Instant one-click toggle between English and Turkish.
• Parameter Controls: Allows straightforward adjustment of motion thresholds, cropping margins, and compression quality through the desktop UI.

Cross-Platform Distribution

Video to Slide is packaged to run independently without requiring Python installations or complex environment setup:

• Available as standalone, portable executables for Windows, Linux, and macOS.
• Built with a clean, fast desktop interface.
• Executes entirely on the local processor without hosted APIs or remote cloud dependencies.

Project Status and Availability

Video to Slide is developed openly under the MIT license. Full source code, documentation, and pre-built binaries are maintained on GitHub.

Related Links

LinkedIn Post: Video to Slide: Open-Source Lecture Slide Extractor
GitHub Repository: github.com/muisik/video-to-slide
Related Project: Tender Tracker: Local Public Procurement Monitoring Tool
Related Project: ContextRail: Minimum Governed Project Memory

Last updated: September 2026 | Version: 1.0

Tender Tracker is an open-source desktop application designed to collect public tender announcements from multiple portals, filter out duplicate records, classify opportunities using rule-based criteria, and deliver updates via a local dashboard, email, or Telegram. Operating entirely on the user’s workstation without requiring external server infrastructure or recurring subscriptions, it eliminates manual searching workflows for technical sales, presales, and business development teams.

Project Overview

Motivation and Background

Tracking public procurement notices across various state portals is traditionally a manual, repetitive chore. Every morning, sales and capture teams navigate multiple portals, filter out irrelevant listings, and manually log matching opportunities into tracking sheets. This workflow consumes valuable engineering hours and frequently results in missed deadlines.

Tender Tracker was created to automate this repetitive operational overhead within a private, local environment:

• Centralize multiple tender portals into a unified pipeline,
• Automatically drop generic categories such as catering or cleaning services,
• Route relevant technical tenders to specific sector queues using keyword rules,
• Notify users through a local browser dashboard, email digests, or Telegram alerts,
• Keep all tender history and configuration data entirely on the user’s computer.

Architecture and Pipeline

The application functions through an isolated, deterministic pipeline without relying on hosted cloud backends. A core design decision is placing rule-based filters first, ensuring fast, transparent, and cost-free execution.

Processing Stages

1. Ingestion: Dedicated adapters fetch listings from public endpoints and normalize them into a uniform schema.
2. Deduplication: Listings published across multiple portals or recurring over multiple days are deduplicated.
3. Exclusions: Global negative keywords weed out non-target industries immediately.
4. Classification: Surviving announcements are mapped to defined sectors based on positive keyword heuristics. Optional language model filters can be enabled for secondary semantic evaluation.
5. Storage and Alerting: Matched records are stored in a local SQLite database, displayed in the dashboard, and dispatched through configured notification channels.

Key Capabilities

Supported Sources

Tender Tracker ingests public records across four primary outlets:

• EKAPv2: Initial scans and incremental synchronization of public tender notices.
• DMO: Active procurement and catalog listings from the State Supply Office.
• ilan.gov.tr: Paginated JSON querying of official public announcements.
• Yatırımlar Dergisi: Structured parsing of sector investment and tender reports.

Note: The tool strictly consumes public announcements and does not bypass credentials, e-signatures, or closed sessions.

Local Management Dashboard and CLI

The application offers two distinct operating modes:

• Local Web Interface: Powered by FastAPI, providing an intuitive local dashboard for managing listings, sector keywords, and notification rules.
• Command-Line Interface (CLI): Features --once mode for one-shot scanning and --daemon mode for continuous background polling. This allows simple scheduling via Windows Task Scheduler at daily shift startup.

Portable, Serverless Deployment

Tender Tracker is built as a self-contained desktop tool rather than a managed SaaS platform:

• Distributed as a portable Windows executable compiled with PyInstaller.
• Local SQLite database stored as a single file, making backups as simple as copying a directory.
• Direct outbound SMTP and Telegram API calls executed locally from the host machine.

Project Status and Availability

Tender Tracker is developed openly under the permissive MIT license. Source code, release binaries, and setup documentation are maintained on GitHub.

Related Links

GitHub Repository: github.com/muisik/tender-tracker
Related Architecture: ContextRail: Minimum Effective Project Memory
Systems Governance: The Rule of Dancing with LLMs: Governing the System

Last updated: July 2026 | Version: 1.0

A standard C99-based middleware designed on the ANSYS SCADE Display platform, enabling HMI screens to communicate with field-level HIMA HiMatrix F35 safety PLCs via Modbus TCP/IP.

Scope: An integration application operating on the zero-copy principle, developed to establish data exchange between SCADE’s closed-loop structure and the control layer.

Project Portfolio

Current Situation and Problem

Context: The necessity to migrate the interlocking simulation system (4 tracks, 6 signals, 1 switch) at the ITU Railway Systems Laboratory to a SCADE Display-supported HMI architecture compliant with industrial and certifiable standards. Critical Issues: The absence of a native Modbus interface within SCADE Display and the platform’s closed-network design. The inability of the HMI interface to communicate directly with actual HIMA HiMatrix F35 safety controllers, and the lack of dynamic field configuration for IP/port maps.

Solution Architecture and Execution

Architectural Approach

Architectural Constraint Assessment: The generated SCADE application used in this setup provided no native Modbus interface. An external C middleware layer was therefore developed to exchange data with the HIMA controller while keeping the HMI logic separate from the communication layer. This is consistent with EN 50128 practice for separating application logic from communication.

A C99 middleware wrapper layer was designed between SCADE’s generated code and the libmodbus library:

Communication Flow

Applied Methodology

• Zero-Copy Integration: Copy overhead was eliminated by hooking directly into the SCADE main loop.
• Dynamic Configuration: A 3-region INI file was used to prevent recompilation requirements during field deployment.

Fallback behaviour: If the configuration file is missing or invalid, the PoC writes a local default configuration for laboratory use. A production implementation should fail safely or require explicit operator confirmation.

• Auto-Reconnection: Connection drops in industrial environments are inevitable; an autonomous auto-reconnect cycle was activated.
• Change Detection: A batch read and selective write strategy was implemented to optimize network traffic.

Architectural Decision: Since HMI hardware’s capability for simultaneous physical command processing is limited, outputs are evaluated in a sequential loop. This structural preference prevents unnecessary fieldbus network congestion.

• Thread-Safe Logging: Every event in critical systems must be logged securely.

Interlocking Scope

Example route: RT01: SN01E → TC01 → TC04 → TC02 → SN02E (Switch: Normal)

Safety Rule: Based on critical design principles, all signals not explicitly demanded by the system are configured to default to a restrictive state (red).

Results and Operational Takeaways

Quantitative Gain: (Potential values obtained during laboratory PoC tests)

Project Visuals

Related Links

 Source Code: Github/ansys-scade-modbus-integration-middleware 
Download TOK 2025 Paper: SCADE Modbus Conference Paper

Authors: Dora Demir¹, İbrahim Can Kolotoğlu², Muhammet Işık², Serhat Boynukalın³, Mehmet Turan Söylemez²
¹ ITU Electronics and Communication Eng. | ² ITU Control and Automation Eng. | ³ ITU Graduate School

This work was conducted at the ITU EEF Railway Systems Laboratory and published at the Turkish Automatic Control 2025 (TOK 2025) conference.

Last update: March 2026 | Version: 1.0

Last updated: March 2026 | Version: 1.0