Polsia

Today, Polsia agents operate in siloed autonomy. When a planning agent completes a product spec and hands off to a coding agent, critical context evaporates at the boundary. Decisions, assumptions, and partial artifacts live only in the completing agent's memory, forcing downstream agents to reconstruct logic or make conflicting choices. This fragmentation causes micro-SaaS operators to lose 17% of autonomous runtime to rework and error correction (source: Polsia agent audit logs, n=12k handoffs, Jan 2025).

Business case:
1.2M handoffs/year × 17% error rate × $14.50 avg recovery cost = $2.95M/year recoverable value
(source: handoff volume from Polsia telemetry; error rate from audit logs; recovery cost = 9.7 min avg × $90/hr blended eng/ops rate per Regional Cost Benchmarks)
If adoption is 40% of estimate: $1.18M/year

This feature is a machine-readable handoff protocol with enforced schema validation for task continuity. It is not a human-facing UI, a general messaging system, or a replacement for agent memory.

Execution risk: If schema validation fails >5% of handoffs, agents revert to legacy behavior, eroding trust. Inaction risk: Without this by Q3, Linear’s upcoming agent ecosystem (per leaked roadmap) will capture solo founders needing multi-agent coherence. Given recoverable value outweighs build cost ($310K) even at 40% adoption, this warrants Q2 investment.

Competitive responses:

• Notion AI: Uses human-readable comment threads for handoffs, requiring manual triage.
• Linear: Agents pass raw task titles + descriptions, losing nested decisions.
• Jira: Relies on ticket transitions with unstructured text fields.

Our wedge is enforced schema validation because solo founders prioritize zero-touch continuity over collaboration features.

WHO / JTBD: When a solo founder running a micro-SaaS on Polsia deploys a planning agent to create a product spec, they need the coding agent to execute it without rework or logic conflicts — so their company operates 24/7 without manual re-briefing.

BEFORE: Maya (founder, Typely SaaS) triggers her planning agent to design a font-rendering feature. The agent decides to use OpenType but hits token limits before documenting why. The coding agent defaults to TrueType, causing layout bugs. Maya spends 3.7 hours diagnosing the mismatch (source: Typely incident log #4872).

COST:

AFTER: The planning agent packages decisions, open questions, and artifacts into a validated handoff packet. The coding agent executes against structured context with zero ambiguity.

JTBD: "When my agent completes a task, I want the next agent to inherit its context and decisions exactly — so my company runs uninterrupted."

Protocol Schema (YAML):

handoff_id: "plan→code_<timestamp>"  
source_agent: "planning_v3"  
target_agent: "coding_v2"  
decisions:  
  - key: "font_format"  
    value: "OpenType"  
    rationale: "Supports variable axes"  
assumptions:  
  - "User OS ≥ Windows 10"  
open_questions:  
  - "Fallback for legacy browsers?"  
artifacts:  
  - type: "spec"  
    uri: "s3://polsia/artifacts/spec_123.md"  
    hash: "sha256:abc..."  
next_actions: ["implement_renderer"]  

Key flows:

1. On task completion, source agent generates packet, validates against JSON schema.
2. Protocol appends packet to task payload; Polsia core enforces schema before routing.
3. Target agent ingests packet via dedicated context.handoff object in execution environment.
4. Validation failure triggers fallback: packet archived, agent proceeds with task title only.

Scope boundary: No UI surfaces. Packet visible only in agent debug logs. Backward compatibility: Legacy tasks omit handoff object.

Phase 1 — MVP (6 weeks)
US#1 — Handoff packet generation

• Given planning agent completes a spec task
• When packet generation triggered
• Then packet created with ≥5 required fields (decisions, artifacts, next_actions)
• Validated by QA against 50 real task outputs
• If fails: Agents skip handoff, revert to legacy mode (P0 risk)

US#2 — Schema enforcement

• Given new task routed to target agent
• When packet attached
• Then Polsia core validates schema pre-execution
• Then invalid packets trigger fallback 100% of time
• If fails: Corrupted packets crash agents (P0)

Out of Scope (Phase 1):

Phase 1.1 (3 weeks post-MVP):

• Packet encryption at rest
• Schema evolution (backward-compatible fields)

Primary Metrics:

Guardrail Metrics:

What We Are NOT Measuring:

• "Packets generated" (measures output, not outcome)
• "Schema adoption rate" (enforced at system level)
• "Agent satisfaction scores" (vanity metric; track errors instead)

D90 revenue impact: 40% adoption × $2.95M = $1.18M annualized

RISK 1 — Schema validation bottlenecks agent throughput

• Probability: Medium | Impact: High
• Mitigation: Rodrigo (Perf Eng) implements streaming validation by week 3; fallback to async queue if p95 latency >300ms
• If unresolved: Throttle validation to 50% of traffic

RISK 2 — Agents ignore packets due to schema drift

• Probability: High | Impact: Medium
• Mitigation: Lena (Agent PM) tests packet usage in 3 agent versions by week 4; enforce semantic versioning
• If unresolved: Auto-generate shim adapters for top 5 agent types

RISK 3 — Packet storage violates GDPR Art. 5

• Probability: Low | Impact: Critical
• Mitigation: Legal (Chen) confirms artifact encryption meets "data minimization" by week 2
• If blocked: Scrub user data from artifacts pre-storage

Kill Criteria (within 90 days):

1. Handoff error rate reduction <30% from baseline
2. Founder intervention rate >12% at D60
3. Validation failures cause >3% agent crashes

1. Packet retention period

   • Decision: 30 days (matches agent log policy)
   • Rationale: Debugging needs vs storage cost

2. Handoff recursion depth

   • Decision: Max 3 nested handoffs
   • Rationale: Prevents infinite loops; covers 99% of workflows (source: agent graph analysis)

3. Artifact size limits

   • Decision: 5MB max, S3 only
   • Rationale: 95% of specs under 2MB; avoids bloating Redis

Before/After Narrative:
Before: Maya’s planning agent specs a font-rendering feature but crashes before logging the "use OpenType" decision. The coding agent implements TrueType, causing layout bugs in production. Maya spends 3.7 hours rolling back deployments and re-briefing agents.

After: The planning agent packages the "use OpenType" decision and spec artifact into a handoff packet. The coding agent reads the packet, implements OpenType, and ships without errors. Maya reviews the automated deployment report over coffee.

Pre-Mortem:
It is 6 months from now and this feature has failed. The 3 most likely reasons are:

1. We enforced schema validation but didn’t update Polsia’s top 5 agent templates to emit required fields, causing 28% validation failures and abandonment.
2. Linear shipped "Agent Context Threads" (per VC leaks) with superior human-in-loop debugging 3 weeks before us, capturing solo founders who value transparency over autonomy.
3. Packet encryption added 390ms p99 latency to agent startups, triggering rollback for high-traffic customers.

Success looks like: Founders share screenshots of week-long autonomous runs with zero handoff interventions. Support tickets for "agent misalignment" drop 70%. The CEO cites handoff coherence in the Q3 board deck as the enabler for 24/7 operation.