Workshops/Perception

ADPS Agent Design Pattern Workshop Series

ADPS Design Pattern Workshop · First Perception Workshop

Signal admission, event ingress, the boundary between multi-source and multi-modal input, and context in AI-driven software engineering.

Host Jia Huang
Core workshop guests Dong Zhang, Xianglong Huang, Qingfeng Li, Cheng Huang

On 13 August 2026, ADPS held its first workshop on the perception module. The meeting followed two related tracks. The first tested whether P1–P4 explain signal ingress, context selection, compaction, discovery, and fusion in enterprise systems. The second used coding agents to examine how requirements, architecture, testing, review, and team responsibilities change when AI enters software engineering.

Workshop conclusions

  1. Perception scope should be designed backward from the decision goal. Available data does not automatically belong in the current context.
  2. A practical perception subsystem has four stages: signal ingress, preprocessing, semantic aggregation, and event assessment. The last stage recommends a trigger; it does not perform the business action.
  3. Source and modality require separate fields. Host, network, code, and tickets are sources; text, image, table, and audio are modalities.
  4. Events, polling, and streams are ingress and triggering mechanisms. They do not assign a topology to the complete task.
  5. The main engineering problem in AI coding extends beyond code generation. Context legibility, acceptance, architecture constraints, review capacity, and continuous cleanup determine whether the system can evolve.

1. Which information may influence a decision

The workshop described perception as the entrance to the decision chain. An enterprise system must first obtain signals and then turn them into structures that models and downstream workflows can use. Tools originally designed to display information to people need agent-readable schemas, state, and receipts.

A practical pipeline has four stages. Signal ingress handles protocols, authorization, and failure behavior. Preprocessing cleans, deduplicates, and normalizes. Semantic aggregation connects isolated observations to business entities and history. Event assessment emits classification, severity, confidence, and a trigger recommendation.

This structure separates perception from decision policy. Perception returns facts and labels. Business action remains downstream. Embedding blocking rules, remediation, and business policy directly in the perception layer makes the layer difficult to reuse and calibrate.

2. Events, polling, streams, and multi-source corroboration

In secure development workflows, code commits and tickets may arrive through callbacks, broad compliance scans run on a schedule, and high-volume telemetry uses streaming infrastructure. High-risk threats and fault isolation often require code, host, network, and historical ticket evidence to be corroborated.

The mechanisms can coexist. A code-audit path may begin with a commit event, use a daily scan to check coverage, and aggregate several sources into one risk record.

The workshop did not add Event-Driven as a new topology. Events define when work starts and how a signal is delivered. The six execution topologies still describe control after the task begins.

Perception selects signals from goals and constraints, then emits structured facts and trigger advice rather than business actions.
Perception selects signals from goals and constraints, then emits structured facts and trigger advice rather than business actions.

3. Multi-source is not the same as multi-modal

Yuke Xiong discussed acceptance after algorithm deployment. In addition to boundary tests, the team needs to check map rendering, device behavior in advanced modes, and the final business result. Other tasks, such as image recognition, need checks designed for their outputs and intended use.

Enterprise security systems often fuse several sources that are all text or structured records. Game development exposes a genuine modality choice: an Unreal Engine Blueprint can be inspected visually or transformed into a script-like representation. The appropriate representation depends on the task, available parser, and token cost.

P4 now records source and modality separately. Source drives authorization, freshness, and corroboration. Modality drives parser and representation choice. The pattern keeps the name Multi-Modal Fusion for now; ADPS will revisit the name after more cases are available.

4. Goal and constraints form the context

Xianglong Huang's software context includes Why, What, How, and acceptance material. Why identifies the user and problem; What records scenarios and product behavior; How includes architecture, sequences, APIs, and database design. Acceptance cases are prepared before coding for use during implementation and review.

A coding agent's context includes both goal and constraints. The goal defines the work. Tests, interface contracts, design rules, and business invariants define acceptance. Too little context prevents completion; too much unrelated material disperses attention.

These remarks now appear in the Context Contract in the perception overview and connect to the Action Contract and reflection evidence model.

5. From SDD to AI-driven software engineering

Willem Jiang noted that a large repository can drift from its architecture even when individual pull requests pass review; agents can accelerate that drift. Cheng Huang described using ADRs, tests, and task records to write implementation decisions back into project material for subsequent development. An existing project also needs a review of module responsibilities and dependencies.

The public OpenLogos and RunLogos projects show one specification-oriented path. OpenLogos organizes software context through Why, What, How, and acceptance artifacts. RunLogos places proposal, documentation, planning, vertical slices, implementation, review, verification, deployment, and archival in a workflow engine. Each slice is independently acceptable. Review loops carry explicit iteration, issue-count, evidence, and stop limits.

A large-backend development practice keeps existing product, development, and testing responsibilities while introducing agents into technical design, implementation, and code review. It records adoption, token use, design iterations, and post-delivery code changes to identify steps that need less human intervention.

Greenfield and brownfield work require different adoption paths. A new system can establish specifications, design, and tests from the start. A high-traffic legacy system requires more cautious movement from peripheral modules toward the core, with stronger human and test gates.

Open-source collaboration exposes another constraint. When code generation exceeds maintainer review capacity, the problem moves to coherence. Contributors use different coding agents. AGENTS.md and Skills express some rules, but local changes can still accumulate into architecture debt. Periodic cleanup, refactoring, and architecture stewardship remain necessary.

A game-development practice uses ADR, TDD, and Task artifacts to separate long-lived architecture choices, one change, and current execution. Daily notes and task records support recovery after interruption. Product decisions and implementation findings update each other through forward development and reverse troubleshooting paths.

These materials are synthesized in the separate AI-Driven Software Engineering topic.

6. Three anti-patterns

The workshop identified three observed failures:

The workshop also added an input-security concern. External tools, documents, pages, images, and logs can carry hostile instructions or faulty context. Source, scope, and the boundary between data and instructions need an explicit perception record.

7. Concepts extracted from the workshop

Concept Workshop definition Current status
Perception funnel Signal ingress, preprocessing, semantic aggregation, and event assessment Module-level reference structure
Context Contract Goal, mandatory inputs, deferred handles, freshness, provenance, conflict rules, and missing material Added to the perception overview
Source-modality pair Record where information came from separately from its representation Added to the P4 revision
Acceptable vertical slice An end-to-end unit that can be implemented, run, and accepted independently AI-driven software engineering topic
Architecture legibility Architecture boundaries represented as repository assets an agent can discover, check, and follow Research direction

8. White Paper revisions

  1. A new Perception Module Overview records the four-stage funnel, ingress mechanisms, source and modality, the decision boundary, and input security.
  2. P1 Context Triage adds goal-bounded scope, missing-input records, and input scope.
  3. P2 Semantic Compaction continues to protect errors, rejected approaches, and business values, and now treats architecture decisions as protected coding-agent context.
  4. P3 Progressive Discovery adds local reverse discovery and architecture-constraint lookup in brownfield repositories.
  5. P4 Multi-Modal Fusion separates sources and modalities and adds provenance, freshness, transformation lineage, and corroboration.
  6. AI coding, SDD, acceptance, architecture stewardship, and team evolution move into topic research rather than receiving a P-pattern number.

9. Open questions

Related pages

Based on the 13 August 2026 workshop transcript. Internal project details have been anonymized.

Chronicle

Recorded source
ADPS Design Pattern Workshop · First Perception Workshop; workshop held on
Source date
First published on ADPS

View in the ADPS Chronicle