Some checks failed
validation / verify (push) Failing after 10s
A new Deliverable in the packaging Phase, produced by a delivery planner after validation. - The planner writes the plan as data: work packages that name the Elements they deliver, and activities with days, what each follows, and whether the team or the customer owns it. - Code checks the plan against the design: every Element belongs to a work package, and the activities can be scheduled. - Code computes the schedule, with no more of the team's activities at once than the team has people, and the critical path. - Code writes the WBS dictionary (a work package is done when the Checks on its Elements pass), the activity sequence and a timeline on a relative axis from Day 0. - The plan is checked against the delivery window from the agreed scope; over it, the Deliverable says by how much and names the critical path. - With a start date it also gives calendar dates and a Mermaid Gantt chart. - The timeline is added to the solution guide, and the plan's length is in execution.json and the packaging Approval. Not run with real models. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
134 lines
8.6 KiB
Markdown
134 lines
8.6 KiB
Markdown
# Cloud Solution Architecture
|
|
|
|
Turns a request for a cloud workload into a reviewed solution architecture: requirements, a target design with diagram and infrastructure-as-code, validation results, and a packaged guide. Google Cloud is the first Cloud provider.
|
|
|
|
## Language
|
|
|
|
### Running the workflow
|
|
|
|
**Workflow request**:
|
|
The free-text description of the workload a caller wants architected; the opening input to an Execution.
|
|
_Avoid_: prompt, query, request summary
|
|
|
|
**Execution**:
|
|
One solution-architecture engagement for a single Workflow request. It lasts from the first request to an approved Solution guide, and may span many user turns. An Execution starts clean, unless it is a Change request.
|
|
_Avoid_: run, job, workflow execution
|
|
|
|
**Session**:
|
|
A caller-supplied grouping of Executions. A Session never feeds earlier outputs into a later Execution.
|
|
_Avoid_: conversation, context
|
|
|
|
**Customer case**:
|
|
A caller-supplied grouping of the Executions run for one customer engagement, identified by a short slug. An engagement and a Customer case are the same thing: a reference such as `ENG-2026-UK-084` names the case `eng-2026-uk-084`. Every Execution belongs to one; an Execution started without one belongs to `unassigned`. A Customer case ties each request to the Deliverables generated for it. It feeds one Execution's outputs into another only when the caller starts a Change request and names the Baseline.
|
|
_Avoid_: project, account, tenant
|
|
|
|
**Intent**:
|
|
What the customer wants from a Customer case, in their own words and at a high level. Each Workflow request made in the case is a statement of it, and the statements are kept in order as its history. The Intent is the customer's; requirements are what the agents derive from it.
|
|
_Avoid_: brief, ask, requirements (which are the derived Deliverable)
|
|
|
|
**Scope spec**:
|
|
The structured statement of what the customer wants and the facts a design depends on, as a file. It may arrive complete or partly filled. It sits beside the Intent, which stays in the customer's words, and a value it states is the customer's decision.
|
|
_Avoid_: brief, questionnaire, requirements (which are derived from it)
|
|
|
|
**Scoping**:
|
|
Completing the scope spec, from what was supplied, what the customer answers and what the agent is left to decide, and having the customer approve it before requirements begin.
|
|
_Avoid_: discovery (which reads a cloud environment), intake (which reads a message)
|
|
|
|
**Change request**:
|
|
An Execution started to say how the customer's Intent has changed. It begins from a Baseline and delivers the full updated Deliverables with an account of what changed and why.
|
|
_Avoid_: amendment, update run, iteration, re-run
|
|
|
|
**Baseline**:
|
|
The completed Execution, in the same Customer case, that a Change request starts from. A Baseline is never modified.
|
|
_Avoid_: parent, previous run, source Execution
|
|
|
|
**Phase**:
|
|
A named grouping of Deliverables: scoping, requirements discovery, solution architecture (the design, ending with the Target architecture), solution implementation, solution validation, or packaging. A Phase is complete when all its Deliverables are submitted and the user has granted the Phase's Approval.
|
|
_Avoid_: step, node, stage, pipeline
|
|
|
|
**Approval**:
|
|
A user's explicit acceptance of a Phase's Deliverables, required before work that depends on them may start. An Execution is interactive by default. A **pre-approved** Execution treats its Approvals as already granted.
|
|
_Avoid_: sign-off, confirmation, gate (in prose)
|
|
|
|
**Revision**:
|
|
Reopening a Deliverable because validation found a problem or the user asked for a change. It returns that Deliverable and everything that depends on it to draft, and withdraws any Approval that covered them. Revisions per Deliverable are limited, and past the limit the user decides.
|
|
_Avoid_: review round, retry, loop iteration
|
|
|
|
### Agents
|
|
|
|
**Orchestrator**:
|
|
The top-level agent of an Execution, and the only agent that talks to the user. It routes: it works out which Deliverables are ready to produce, delegates them to Specialists, and asks the user for Approvals. It produces no Deliverable itself.
|
|
_Avoid_: supervisor, manager, root agent, router
|
|
|
|
**Specialist**:
|
|
An agent responsible for producing one kind of Deliverable, such as the product selector or the target architect. A Specialist may delegate independent parts of its work to further Specialists.
|
|
_Avoid_: sub-agent, worker, phase agent, node
|
|
|
|
### Portability
|
|
|
|
**Skill**:
|
|
A self-contained package of domain guidance: instructions plus optional references, assets and scripts, in the Agent Skills format. It is the portable unit of the agent's behaviour and is loaded on demand.
|
|
_Avoid_: prompt template, instructions, playbook
|
|
|
|
**Cloud provider**:
|
|
The hyperscaler a solution architecture targets, such as Google Cloud. Each Cloud provider brings its own Skills, plus the MCP servers it hosts for discovering a user's current environment and grounding recommendations in its documentation.
|
|
_Avoid_: hyperscaler, cloud, platform, target
|
|
|
|
**Lesson candidate**:
|
|
Something an Execution got wrong or was corrected on, recorded as it happened: a Revision and its reason, a tool refusal, a user's request for changes. It is raw material and changes nothing by itself.
|
|
_Avoid_: learning, memory, feedback record
|
|
|
|
**Lesson**:
|
|
A rule distilled from Lesson candidates across Executions, approved by a person and shown by evaluation to help, then published in a Skill. It carries no client detail.
|
|
_Avoid_: memory, fine-tuning, learned behaviour
|
|
|
|
**Overlay Skill**:
|
|
A Skill that adds an organisation's standards or one engagement's constraints to what the Cloud provider's Skills say. It is named when an Execution starts and comes only from a place the deployment has configured.
|
|
_Avoid_: custom prompt, override, plugin
|
|
|
|
### Outputs
|
|
|
|
**Deliverable**:
|
|
A document an Execution produces: the scope, requirements, technical decomposition, product selection, design recommendations, the Target architecture, architecture description, deployment guidance, validation results, the Work breakdown structure, or the Solution guide. Each Deliverable depends on others being approved first.
|
|
_Avoid_: artifact, output file
|
|
|
|
**Dependency**:
|
|
The relationship between two Deliverables in which one can only be produced once the other has been accepted, for example an architecture diagram depending on the product selection. Within a Phase, a submitted Deliverable counts as accepted. Across Phases, only the earlier Phase's Approval does.
|
|
_Avoid_: prerequisite, edge, upstream
|
|
|
|
**Target architecture**:
|
|
The solution to be built, as one explicit graph of Elements, the Relationships between them, and the Checks each must meet. It is established before any infrastructure code is written, and every later Deliverable is derived from it and checked against it.
|
|
_Avoid_: build plan, blueprint, design doc, to-be state
|
|
|
|
**Element**:
|
|
One component of the Target architecture and the cloud resource that realises it, with the product selected for it.
|
|
_Avoid_: node, resource (alone), box
|
|
|
|
**Relationship**:
|
|
A connection between two Elements, such as calls, publishes to, reads from, or is granted access to.
|
|
_Avoid_: edge, link, dependency (which is between Deliverables)
|
|
|
|
**Check**:
|
|
A numbered, verifiable condition that an Element or Relationship must meet, traced to the requirement or design recommendation it comes from. Validation gives each Check a verdict.
|
|
_Avoid_: finding, rule, control, test
|
|
|
|
**Requirements chain**:
|
|
The unbroken trace from each requirement, through the components that serve it and the Elements and Checks that realise it, to the code that implements them and the validation verdict on each Check.
|
|
_Avoid_: traceability matrix, lineage
|
|
|
|
**Customer question**:
|
|
Something the architecture depends on that the customer's Intent does not say, recorded with the question to put to them. It marks missing information, not a fault in the design, and its answer may change a recommendation.
|
|
_Avoid_: gap, failure, open issue, assumption (which is a default the agents chose)
|
|
|
|
**Work breakdown structure**:
|
|
The Deliverable that divides building the Target architecture into Work packages and the activities within them, with a timeline on a relative axis of working days. Its schedule is computed from the activities' durations and dependencies, never written.
|
|
_Avoid_: project plan, roadmap, schedule (which is one view of it)
|
|
|
|
**Work package**:
|
|
A unit of the build that delivers named Elements, and is done when the Checks on those Elements pass.
|
|
_Avoid_: task, epic, phase (which groups Deliverables), workstream
|
|
|
|
**Solution guide**:
|
|
The packaged Deliverable that assembles every other Deliverable into the Cloud provider's solution architecture template.
|
|
_Avoid_: final report, package
|