The Pvragon AI Workspace

An operating system for agentic development

How we turn AI models into reliable, persistent collaborators — with plain files, clear boundaries, and structured memory.

AI Agents Are Powerful, But Fragile

Large language models are remarkably capable. But on their own, they have serious limitations that compound over time:

No memory — they forget everything between sessions
No consistency — they may do the same task differently each time
No identity — no persistent context about your business or preferences
Compounding errors — without guardrails, small mistakes snowball fast

At 90% accuracy per step, a 5-step task only succeeds 59% of the time. Structure fixes this.

The Core Pattern: DOE

Every task is separated into three concerns. Each layer has one job.

Directives

What to do

Orchestration

Who decides

Execution

How it gets done

Reliability comes from pushing repeatable steps into deterministic scripts — while keeping human intent readable and the AI focused on reasoning.

Four Layers, Clear Boundaries

The workspace is organized by function, not by project or person. Dependencies flow downward only.

Layer 0 — Personal

Your secrets, notes, and local overrides. Never versioned, never shared. The private second brain.

Layer 1 — Team Library

The shared operating system. Canonical skills, directives, executions, and context. Changes require a PR.

Layer 2 — My Library

Your personal extensions. Experiment freely, push while working. Mature tools graduate to the team library.

Layer 3 — Projects

The workbench. Each project is its own repo with standardized docs, specs, and source code.

The Workspace On Disk

This is what the workspace actually looks like. Every directory has a purpose.

agents/
└── rowan-anicca/
    ├── identity.md
    ├── memory/
    │   ├── MEMORY.md
    │   └── *.md
    └── adapters/

personal/  layer 0
├── notes/
├── preferences/
├── scratch/
└── secrets/

team-lib/  layer 1
├── context/
│   ├── global/
│   └── indexed/
├── directives/
├── executions/
├── harnesses/
├── integrations/
├── personas/
├── registry/
│   ├── workspace.yaml
│   ├── skills.yaml
│   ├── executions.yaml
│   └── ...manifests
└── skills/

my-lib/  layer 2
├── archive/
├── backlog/
├── context/
│   ├── global/
│   └── indexed/
├── directives/
├── executions/
├── harnesses/
├── integrations/
├── personas/
├── registry/
│   ├── skills.yaml
│   ├── executions.yaml
│   └── ...manifests
├── runtime/
└── skills/

projects/  layer 3
├── my-app/
│   ├── docs/
│   │   ├── specs/
│   │   ├── adrs/
│   │   └── context/
│   └── src/
│
└── another-app/
    ├── docs/
    └── src/

The Functional Stack

Each directory type in the workspace has a distinct role in the agentic workflow:

Directives

What to do — intent and constraints

Context

What to know — persistent knowledge

Personas

Who to be — identity and behavior

Skills

How to do it — reusable capabilities

Executions

Do the work — deterministic scripts

Integrations

Connect outside — CLIs, MCPs, APIs

Harnesses

Run sessions — the agent's main()

Specs

Definition of done — acceptance criteria

Four Tiers of Memory

The workspace solves context amnesia with a layered memory system. Each tier has a different lifetime and loading strategy.

Long-term Versioned context files, brand guidelines, identity — loaded on-demand via registry index

Mid-term Agent memory topics, lessons learned — curated across sessions, pruned by distillation

Near-term Working files, project plans, current state — cleared when the initiative completes

Session Active context window contents — volatile, subject to auto-compaction

Vendor-Independent Agent Identity

The agent's identity, memory, and behavioral context live in a git-backed repository — not inside any vendor's directory.

Git-backed. Every memory change is version-controlled with full audit trail and rollback.

Symlink adapters. Vendor tooling accesses agent data via symlinks. Switch vendors without restructuring memory.

One agent, one memory pool. All project directories symlink to the same memory, keeping context consolidated.

Persistent identity. Name, pronouns, communication style, and behavioral defaults survive across every session.

Registry-Driven Discovery

Agents don't guess file paths or scan directories heuristically. Every skill, directive, execution, and context file is registered in a YAML manifest.

Team Registry

Personal Overrides

Project Docs

Load order is deterministic: shared first, then personal overrides, then project-specific context. No ambiguity.

Connecting to the Outside World

Integrations bridge the workspace to external services. Each one has its own authentication, documentation, and invocation interface.

CLIs

Local binaries making API calls

gws, Restish

MCPs

Server processes with tool protocol

Playwright, Baserow

Remote Execution

Your code on external infrastructure

Apps Script, n8n

Location-Based Behavior

The agent automatically adjusts its behavior based on where it's working. Each directory has a constitution file that sets the rules.

STOP

Workspace root — route to the right layer

Automation

Libraries — DOE automator, focus on reliability

Engineering

Projects — builder mode, read specs, write code

Governance That Scales

Different layers have different rules — strict where it matters, loose where velocity matters.

Team Library — strict. All changes via PR. No personal scoping. Required frontmatter, docstrings, and tests.

Personal Library — loose. Maximize velocity. Experiment freely. Just don't commit secrets or large binaries.

Projects — repo-specific. Each project follows its own style guide, enforced by its own CI/CD pipeline.

The workspace prevents entropy by making the right thing easy and the wrong thing hard — without slowing anyone down.

Plain Files. Clear Boundaries. Reliable Agents.

DOE Pattern

+

Four Layers

+

Tiered Memory

=

Deterministic AI

No vendor lock-in. No magic. Just files and folders that work across VS Code, Obsidian, Git, and any AI agent.

Full reference: workspace-reference.md • Editor setup: editor-setup-guide.md • Project docs: project-docs-standard.md