Three claims. The receipts are below.
Before the diagrams and the code: here is what DocPro actually does, in one line each. Skip to any section for the implementation behind it.
Trace any statement on the platform page to real architecture, real code, and real production data. Nothing here is conceptual.
Before the diagrams and the code: here is what DocPro actually does, in one line each. Skip to any section for the implementation behind it.
Each team member keeps a per-account memory store that is appended every session and recalled at the next one — timestamped and source-tagged, so knowledge carries forward instead of resetting.
Code Review writes findings and anchors back to a persistent ledger. Repeat passes against a hardened tree return fewer findings, not the same list — the record is what makes that measurable.
Build Mode dispatches a milestone as an isolated subagent, runs it against your real files, and chains to the next on completion — or calls your phone when it hits a blocker.
Redacted samples of the review ledger, remediation pass, memory compression, and security claim map are available in the DocPro Proof Packet.
Every session produces knowledge. The pipeline extracts it, stores it, enforces it, compresses it, and recalls it — across every future session.
Voice callbacks with dynamic context generation. The team calls your phone with session-aware openers — not scripts.
Autonomous multi-milestone project execution. Subagent-per-milestone dispatch with fresh context windows.
Professional output generation — SOWs, SOPs, user manuals, frameworks. Template-driven with brand injection.
Not cherry-picked examples. Actual patterns from the running system that make persistent memory work.
# Every session appends to persistent memory
# with timestamped source tracking
timestamp = datetime.now(timezone.utc)
separator = f"\n\n--- {source} ({timestamp}) ---\n"
if memory:
existing = memory.content.strip()
memory.content = existing + separator + new_content
memory.updated_at = datetime.now(timezone.utc)
else:
memory = PersonaMemory(
user_id=user_id,
persona_key=persona_key,
content=new_content,
)# Call context adapts to WHY the call is happening
def get_trigger_context(trigger_type, call_topic=None):
if trigger_type == "manual":
if call_topic:
return (
f'The user asked you to call about '
f'a SPECIFIC topic: "{call_topic}". '
'Lead with the topic.'
)
elif trigger_type == "team_blocked":
return "The team is working on a milestone..."# Compression preserves critical preferences
# MUST-ENFORCE count validated before and after
before_count = content.count("MUST-ENFORCE")
compressed = await compress_with_ai(content)
after_count = compressed.count("MUST-ENFORCE")
if after_count < before_count:
logger.warning("Compression dropped preferences — aborting")
return None # Never lose client preferences
# Optimistic lock prevents concurrent corruption
if memory.updated_at != lock_timestamp:
return None # Someone wrote while we compressed# Each milestone runs as an isolated subagent
# with a fresh 1M context window
async def advance_milestone(project, action, status):
if action == "complete":
sign_off_milestone(current)
next_ms = kick_off_milestone(project)
context = build_milestone_context(next_ms)
return {"action": "continue", "context": context}
elif action == "blocked":
project.build_mode_paused = True
initiate_call(persona="carl")
return {"action": "paused"}Not aspirational projections. Real numbers from the running system, verifiable against the codebase.
Last verified: June 2026 · Sources: git history, pytest suite, production memory store, release ledger.
From your VS Code sidebar to the team and back — the real path every session, review, and call travels.
For the three big claims: what we assert, where to confirm it, and where the line sits. We'd rather hand you the limit than have you find it yourself.
persona_memory_service.py.
MUST-ENFORCE preference is dropped before it commits a smaller memory — pattern shown above.
project_service.py.
Every pattern mentioned on this page has a real implementation. Here's where to look.
When a 4,000-line module splits into six, every consumer keeps working. The facade re-exports the public API. Zero breaking changes across 11 import sites.
call_pipeline/__init__.py → 6 submodulesAI-driven compression with preference count validation. If a single MUST-ENFORCE preference is lost during compression, the operation aborts and the original is preserved.
persona_memory_service.py → compress_persona_memory()Each milestone runs as an isolated subagent with a fresh context window. The orchestrator chains completion calls — when one finishes, the next begins automatically.
ide.py → advance_milestone endpointAfter any component extraction, every JSX identifier is grep-verified against the import list. Three extraction bugs taught this rule. It's now enforced on every split.
Enforced across all frontend decompositionsThe architecture is real. The numbers are real. The team that built it remembers every decision that led here.
Meet the Team →