Announcing Sprawl.software: The Workstation Containment Shield for AI Engineering

created by: YouKnowV.com

Today, I am launching my new venture: Sprawl.software.

Sprawl is a workstation containment and telemetry platform designed to make autonomous AI software engineering safe, predictable, and auditable.

This venture was not born in an academic research lab or a VC brainstorming session. It was forged on the front-lines of enterprise engineering and team training. This post explains why Sprawl exists, what we do, and our goal for the future of development.

The 60-Developer Oversight Problem

Recently, I was brought in by a client to train a large team of software developers in AI-assisted engineering workflows. The developers were eager to move fast using tools like Cursor, Intelij, Ryder, PHPStorm and command-line agents. However, the client's executive leadership and security team hit a hard barrier: a total lack of visibility.

While standard AI tools offer "Enterprise Tier Dashboards," these portals are structurally blind. They show high-level seat assignments and general token volume counts, but they completely hide the operational reality. They cannot tell you:

• What sensitive files or credentials the agent is reading locally.
• Which directories are generating context bloat and running up bills.
• Whether the generated code complies with your security guidelines.

AI agents operate inside a black box. If an agent hits a build blocker, it will recursively traverse local workstation paths, reading .env database passwords or private SSH keys, and streaming them to external model APIs as text payloads.

Faced with this threat, security teams resort to blunt firewall blocks that stop data leaks but grind developer velocity to a halt. Sprawl.software exists to bridge this gap. We believe the solution is not to ban AI agents, but to wrap them in local workstation containment.

What Sprawl Does: Three Pillars of Workstation Control

We do not intercept your network traffic or route your prompts through heavy cloud middleware. Instead, Sprawl shifts governance directly to the workstation layer, ensuring that your code, credentials, and telemetry stay on your machine.

Sprawl does three things:

1. We let developers manage agent instructions: We give you a unified, local-first runtime to declare, bind, and synchronize skills, rules, and personas natively across your workspace. You write your rules once in Git, and Sprawl ensures they are actively synced back into your IDE profiles.
2. We fence file system access: We restrict what paths the agent is allowed to read and write. Using a local Model Context Protocol (MCP) server running over standard input/output, we validate path requests in-memory. If an agent tries to traverse paths outside the allowed repository bounds, Sprawl blocks the access before the operating system can execute it.
3. We track telemetry locally: We collect session logs and tool calls out-of-band on a local background thread. Sprawl reconstructs the timeline of the coding session, giving you visibility into context execution without routing your prompts or codebase to a third-party server.

Clamping the Token Tax

The economic cost of AI engineering is driven by context waste. Modern AI models have massive context windows, leading to an anti-pattern where developers feed entire repository folders, including build artifacts, caches, and dependency lockfiles, into the agent's prompt.

This causes two severe failures:

• The Token Bleed: Ingesting thousands of redundant lines of code on every iteration inflates API token consumption, running up massive, unmonitored bills.
• Lost-in-the-Middle Attention Decay: Research proves that when an LLM is overwhelmed with high-volume context noise, its retrieval accuracy drops significantly. It begins to miss critical architectural constraints simply because they are buried in the middle of a massive payload.

Sprawl stops this leak. By analyzing exactly which codebase files were actively referenced or modified in a session versus which ones were ignored, Sprawl provides context coverage diagnostics. Developers can identify the directories causing context bloat and prune them. In our early tests, eliminating this context noise has cut prompt payloads and token consumption by up to forty percent, while significantly reducing API latency and preventing recursive model execution loops.

The Package Manager Realization

When working across multiple clients, I had a library of different agent rules, personas, and instructions for specific languages and tasks. I had a Communication rule, a Python skill, a Code-Review persona, but I would never use all of them in a single project.

Copying and pasting these prompt files manually into each repository was tedious and error-prone. I realized very quickly that we were managing agent rules all wrong. Rules and skills cannot be global, floating prompt files. They need to be managed like code dependencies in a package manager, designed as agnostic, atomic, and modular components, so you can dynamically plug rules in and out based on the active repository boundary.

What started as a collection of personal shell scripts to automate this rule-binding quickly evolved into a local CLI as I watched client organizations struggle with the exact same isolation and governance failures.

The Birth of Markdown Project Management (MDPM)

I am an offline-first person. I believe in keeping systems simple (KISS).

For years, I worked with heavy corporate tools like Jira and Confluence, but they introduced too much interface friction and context noise for autonomous agent integration. To coordinate agents effectively, I wanted a plaintext system that I could edit inside Obsidian but manage directly in my IDE.

I realized that markdown files with YAML frontmatter are nothing more than tickets with properties and types.

By defining new ideas, active epics, milestones, and tasks as structured markdown notes directly in the repository Git, Markdown Project Management (MDPM), a plain text coordination framework, was born. This plain text structure naturally enforces boundaries: instead of dumping a chaotic codebase into the agent's window, the agent is confined to reading a single, focused task file. The context footprint stays tiny, the agent remains focused on the ticket, and it is forced to stay within the guardrails of the active workspace rules.

We battle-tested and fine-tuned this MDPM system during the development of the Sprawl CLI itself.

Our Goal: Secure, Autonomous Enterprise AI

Our goal is to make autonomous AI development enterprise-ready.

Just as containers made raw cloud servers manageable and secure, workstation containment makes autonomous agents safe to deploy at scale. We are moving the industry away from "magic black box" models and transitioning into deterministic, auditable execution environments.

We are starting small. The core CLI is built strictly with Python’s standard library to keep it fast, lightweight, and easy to audit. Looking ahead on our active R&D roadmap, we are prototyping process-level sandboxing to run agent terminals in isolated containers, completely virtualizing home directories to protect local keys.

Your code, your credentials, and your telemetry belong on your workstation.

Stay local. Tame the sprawl.

If you want to protect your codebase, contain your token burn, and establish predictability in your AI engineering workflows, explore the Sprawl ecosystem at sprawl.software:

YOUNES_BAGHOR