Autonomous Multi-Phase Software Architecture Execution with LLM Agents

cara · Healthcare · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.4 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Healthcare platform architecture execution

Cara needed to execute a large healthcare-platform architecture epic with many interdependent tickets while preserving clinical safety, compliance gates, code quality, and architectural intent.

Constraints:

• the architecture spanned 66 tickets across 2 repositories
• healthcare safety required deterministic clinical routing where LLMs propose but code decides
• HIPAA, SOC2, and HITRUST checks were mandatory before commits
• parallel subagents needed combined-diff review to catch cross-agent security issues
• the successful execution depended on weeks of codebase structuring, instruction refinement, and domain-expert planning

Architecture

Cara used Claude Code with Opus 4.6 inside a RePPITS execution harness. The human architect designed a five-layer composable healthcare platform, planned 66 Linear tickets with dependencies and acceptance criteria, refined instruction/memory files, and gave the agent MCP-accessible research documents. Each ticket followed Research, Propose, Plan, Implement, Test, Secure. Agents ran in 19 parallel subagent batches for independent tickets, but every phase required tests, type-check, push, CI, Kubernetes verification, compliance checks, and combined-diff review before progress continued.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  human-domain-architect[Human domain architect] --> linear-ticket-epic[Linear ticket epic]
  human-domain-architect --> research-documents[Research documents]
  linear-ticket-epic --> claude-code-agent[Claude Code agent]
  claude-code-agent --> reppits-process[RePPITS process]
  file-based-memory[File-based memory] --> claude-code-agent
  claude-md-process-rules[CLAUDE.md process rules] --> claude-code-agent
  agents-md-technical-context[AGENTS.md technical context] --> claude-code-agent
  mcp-research-tools[MCP research tools] --> claude-code-agent
  research-documents --> mcp-research-tools
  claude-code-agent --> parallel-subagents[Parallel subagents]
  parallel-subagents --> combined-diff-review[Combined diff review]
  reppits-process --> compliance-and-security-gates[Compliance and security gates]
  combined-diff-review --> compliance-and-security-gates
  compliance-and-security-gates --> ci-and-kubernetes-verification[CI and Kubernetes verification]

Components

Data flow

The human domain expert first structured the codebase, refined instruction files, planned the epic, and created research documents. During execution, the agent reads memory rules, CLAUDE.md process rules, AGENTS.md technical context, Linear tickets, research docs, and MCP-accessible external sources. For each ticket it follows RePPITS, implements and tests, runs compliance/security gates, commits and verifies CI/Kubernetes, then updates trackers. Parallel subagent batches work independent features, after which the combined diff is reviewed before phase gates pass.

Why this architecture

The setup treated the LLM as an execution engine inside a strict harness, not as the architect. Healthcare domain expertise produced the architecture, tickets, and safety decisions; RePPITS enforced process; memory preserved corrections across sessions; and combined-diff review caught issues that parallel subagents could not see individually. Deterministic clinical safety kept LLM proposals from making final routing decisions.

Models used: Claude Code · Opus 4.6 · GPT-5.4 · Gemini 3.1 Ultra

Scale

• The agent executed 66 tickets across 2 repositories.
  “autonomously executed **66 software tickets across 2 repositories”article, stated
• The epic wrote 536 tests.
  “wrote 536 tests”article, stated
• Execution completed in under 4 hours.
  “It’s a story about the execution harness - the system surrounding the model - that turned raw capability into reliable output: 60+ tickets in under 4 hours.”article, stated
• The architecture used 53 scaffolds and 113 injectable files.
  “53 scaffolds. 113 injectable files. A dependency resolver that walks the manifest graph. A policy-driven planner that maps “voice receptionist for pediatrics on Athena” to the right composition.”article, stated
• The run used 19 parallel subagent batches.
  “19 parallel subagent batches. The autonomous execution was not spontaneous. Here is what it actually took: * ∼3 weeks of codebase structuring (4–6 hrs/week): consistent naming, typed package boundaries, strict TypeScript, CI/CD pipeline, Kubernetes manifests.”article, stated
• Preparation took roughly 20-25 hours.
  “Roughly 20–25 hours of preparation enabling the autonomous execution. Every ticket followed RePPITS: Research the codebase and external sources, Propose two approaches, Plan concrete tasks, Implement, Test, then run healthcare compliance checks (HIPAA, SOC2, HITRUST) before committing.”article, stated
• The run added about 20,000 lines.
  “66 tickets. 7 phases. 536 tests.∼20,000 lines. 19 parallel subagent batches. The autonomous execution was not spontaneous.”article, stated

Alternatives considered (roads not taken)

Single-pass AI app generation

Rejected because: Enterprise healthcare apps need multi-phase discovery, architecture planning, gates, integrations, and compliance.

LLM decides clinical routing directly

Rejected because: Clinical routing decisions needed deterministic safety logic; LLMs can propose but code decides.

Parallel subagent self-review only

Rejected because: A prior SSRF vulnerability was invisible to one agent but caught only when the combined diff was reviewed.

Reactive coding without complete architecture first

Rejected because: The architecture, tickets, dependencies, and acceptance criteria were complete before implementation, avoiding mid-execution redesign.

Patterns

durable-execution (agentic)

File-based memory carries corrections across sessions and makes later sessions inherit prior lessons.

multi-agent-orchestration (agentic)

Independent tickets are executed by 2-5 parallel subagents, then integrated through combined review.

guardrails-io-filtering (safety)

RePPITS gates enforce healthcare compliance, security review, and stop-fix-reverify behavior.

tool-use-orchestration (agentic)

The agent uses MCP tools, Linear tickets, S3 whitepapers, AWS architecture docs, EHR API docs, CI, and Kubernetes verification.

human-in-the-loop-gate (governance)

Human domain expertise designed the architecture and remained responsible for clinical and architectural decisions.

Tradeoffs

Use LLMs for execution, not architecture ownership

Chose human-designed architecture with agent execution over agent-led architecture discovery during implementation.

Rationale: Healthcare and compliance decisions required domain expertise close to the problem.

Run parallel subagents only with combined review

Chose 2-5 subagents plus holistic diff review over serial execution only or independent subagent self-review.

Rationale: Parallelism accelerates independent tickets, but integrated review catches vulnerabilities that local subagent reviews miss.

Separate workflow rules from technical context

Chose CLAUDE.md for process rules and AGENTS.md for technical context over one mutable instruction file for both process and project details.

Rationale: Updating scaffold technical context should not accidentally alter process enforcement.

Gotchas (what bit them)

LLMs should not make final clinical routing decisions.

Root cause: Clinical safety requires deterministic boundaries and failsafe urgency logic.

Resolution: Cara implemented a deterministic clinical safety engine where the LLM proposes but code decides.

Parallel agents can introduce integration-level vulnerabilities.

Root cause: A vulnerability introduced by one agent can be invisible from that agent's local review.

Resolution: The harness requires combined-diff review after parallel work.

Tests can miss safety-critical boundary math.

Root cause: A max-risk boundary defaulted to the lowest urgency despite all tests passing.

Resolution: Structured review caught the math issue and fixed it immediately.

Autonomous execution was preparation-bound.

Root cause: The agent could execute quickly only after weeks of codebase structuring, instruction refinement, epic planning, and research preparation.

Resolution: The human prepared consistent boundaries, instructions, tickets, and research documents before the run.

Evaluation

The run was evaluated through test counts, phase gates, CI/Kubernetes verification, security audits, bug counts, deferred-item count, production incidents, and preparation metrics.

Metrics: 66 tickets across 2 repositories · 536 tests · under 4 hours autonomous execution · 2 full security audits · 2 safety-critical bugs and 8 other issues fixed immediately · zero deferred items · 0 CI failures · 1 production incident fixed in under 5 minutes

Outcomes

• The agents shipped a composable five-layer healthcare app-platform architecture.
• All identified security and safety issues were fixed immediately with zero deferred.
• The run produced 536 tests and roughly 20,000 lines.
• The methodology is planned to become Cara Ultra Mode for user-generated enterprise healthcare apps.

The source reports 66 tickets, 7 phases, 19 subagent batches, under 4 hours of execution, and about 20-25 hours of preparation.