Intent — ARB & Tech Radar

Technology adoption roadmap, architectural blueprint, and atomized delivery phases

Technology Radar

Adoption lifecycle and assessment status

Detailed Breakdown

ADOPT

Claude API (Claude 3.5 Sonnet)

Adopt

Core LLM backbone. Production inference, batch processing, extended context (200k tokens). Stable, proven reliability.

Git + GitHub

Adopt

Spec versioning, audit trail, collaborative workflow. Mission-critical for Intent as versioned contracts.

Markdown

Adopt

Specification language. Human-readable, version-controllable, LLM-native. Standard for Intent specs.

HTML5 / CSS3 / JavaScript

Adopt

Web delivery layer. Static site generation, client-side interactivity. Browser-native platform.

Node.js / npm

Adopt

Build tooling, CLI infrastructure. Well-integrated with GitHub workflows, GitHub Actions support.

Docker

Adopt

Container runtime. Reproducibility for offline processing, consistent deployment across environments.

TRIAL

GraphQL

Trial

Query layer for signal index. Under evaluation for efficient spec traversal and dependency graph queries.

WebSockets

Trial

Real-time signal stream delivery. Evaluating for collaborative and live dashboard features.

SQLite (embedded)

Trial

Local signal storage, indexing. Testing as lightweight alternative to server-side persistence.

Temporal (workflow engine)

Trial

Durable execution for autonomous agents. Under evaluation for long-running Intent execution chains.

OpenTelemetry

Trial

Observability instrumentation. Piloting for spec execution tracing and signal causality graphs.

ASSESS

Rust (async runtime)

Assess

High-performance signal processing. Evaluating tokio/axum for time-critical paths (agent dispatch, spec compilation).

WASM (WebAssembly)

Assess

Spec compilation in browser. Exploring for client-side spec parsing and validation without server roundtrip.

Zephyr (multi-modal LLM)

Assess

Lightweight inference alternative. Evaluating for on-device Intent execution and offline mode support.

Anthropic Workbench

Assess

Prompt engineering toolkit. Under exploration for spec refinement workflows and intent authoring.

Prisma ORM

Assess

Schema-driven data layer. Evaluating for signal database abstraction and migration safety.

HOLD

Kubernetes (full orchestration)

Hold

Over-engineered for Intent's current scope. Revisit only when scaling beyond Docker Compose and needing multi-region deployment.

Kafka

Hold

High-throughput event streaming. Unnecessary until signal volume requires distributed pubsub beyond WebSockets.

GraphQL Federation

Hold

Multi-service federation layer. Premature; defer until multi-team API composition becomes a blocker.

Machine Learning (custom models)

Hold

Custom training pipelines. Stay leveraged on Claude API; custom models create ops burden and moat erosion risk.

Blockchain / Smart Contracts

Hold

No cryptographic requirement; adds complexity without clarity. Git + signatures sufficient for Intent audit trail.

Architectural Stack

Layered technology blueprint for Intent platform

Layer 1: Signal Ingestion

Signal API

Stateless ingestion endpoint. Validates signal shape, enriches with metadata (timestamp, source, causality), persists to signal store.

Stable

Node.js + Express OpenAPI spec

Layer 1: Signal Ingestion

Signal Store

Immutable append-only log of signals. Local SQLite for MVP, PostgreSQL for multi-tenant. Index by source, causality chain, timestamp.

Stable

SQLite / PostgreSQL JSONB columns

Layer 2: Spec Authoring

Spec Editor

Web IDE for writing, validating, and versioning Intent specs. Live preview, inline signal binding, markdown-native editing.

Beta

React + Monaco Editor GitHub integration

Layer 2: Spec Authoring

Spec Compiler

Validates spec syntax, resolves signal references, compiles to execution plan. Produces deterministic DAG of tasks and decision points.

Stable

Custom parser Markdown AST

Layer 3: Execution

Agent Runtime

Executes compiled specs against signal context. Manages tool invocation, LLM calls, state transitions. Observability instrumented.

Beta

Claude API Tool use

Layer 3: Execution

Execution Plan Store

Tracks execution state, outcomes, and decision history. Enables replay, audit, and post-mortem analysis of spec runs.

Beta

PostgreSQL Event sourcing

Layer 4: Delivery

Result Store

Immutable record of spec outcomes: text, artifacts, side effects, errors. Queryable by execution ID, date, or signal origin.

Beta

PostgreSQL JSONB S3-backed artifacts

Layer 4: Delivery

Dashboard

Real-time visualization of signal flow, spec execution, and system health. Signal digest, execution timeline, decision panel.

Beta

React + D3.js WebSockets

Layer 5: Observability

Tracing & Logging

Structured logging, distributed tracing, and causality graphs. Every signal and execution step tagged with unique IDs.

Experimental

OpenTelemetry Jaeger / Tempo

Layer 5: Observability

Metrics

Quantitative health: signal volume, spec success rate, execution latency, LLM token usage, error distribution.

Experimental

Prometheus Grafana

ARB Panel

Architectural Review Board: governance, decision log, and design rationale

Core Principles

1. Spec-Driven Execution

All intent execution must be declarative (spec-based), not imperative (hardcoded). Specs are versioned, auditable contracts that bridge human intent and agent execution.

2. Signal-First Architecture

Signals are the unit of observation. Every spec is triggered by, and responds to, signals in the platform. Causality is traced from signal to outcome.

3. Autonomy via Trust

Agents gain autonomy through explicit trust delegation (L0-L4 levels). Each level requires validated execution history and explicit human approval.

4. Offline-First, Always-On

Local processing (laptop) is primary. Always-on cloud processing is secondary. Architecture supports graceful degradation when offline.

Decision Log (Key ARB Decisions)

D1: Markdown for Specs

Decision: Use Markdown as spec language (not YAML, JSON, or DSL). Rationale: Human-readable, LLM-native, version-control friendly, low learning curve.

D2: Git as Source of Truth

Decision: Git repos are authoritative for specs, signals, and execution plans. Rationale: Proven audit trail, distributed ownership, integration with GitHub Actions and CI/CD.

D3: Claude API as Inference Layer

Decision: Stable on Claude (3.5 Sonnet). Defer custom models. Rationale: Proven reliability, 200k context, tool use, batch API. Custom models = ops burden.

D4: SQL over NoSQL

Decision: Use relational DB (SQLite local, PostgreSQL hosted). Defer document stores. Rationale: Spec and signal data are highly structured; ACID guarantees required for audit trail.

D5: Static Site for Dashboard

Decision: Dashboard is static HTML + JavaScript. Optional backend for real-time. Rationale: Simplifies deployment, no server-side rendering, browser-native interactivity.

D6: Deferred Features (Hold List)

Kubernetes, Kafka, ML custom training, blockchain. Rationale: Premature optimization. Revisit when scaling becomes a measurable blocker, not speculative.

Implementation Constraints

Single Source of Truth

Git is authoritative. All state changes recorded as commits. No out-of-band mutations.

Immutable Signal Log

Signals are append-only. Never deleted or mutated. Causality chains are traceable from signal ingestion to execution outcome.

Deterministic Spec Compilation

Same spec + same signals → same execution plan. Reproducibility requirement for replay and post-mortem analysis.

Auditability by Design

Every execution step logged with metadata. Audit trail is queryable and immutable. No "black box" agent decisions.

Risk Mitigations

Hallucination / Drift

Mitigation: Spec-based execution with signal binding. LLM output constrained by spec contract, not free-form reasoning.

Cascading Failures

Mitigation: Execution plans are DAG-structured. Failures are scoped. Graceful degradation when dependencies unavailable.

Spec Corruption / Drift

Mitigation: Git versioning + code review workflow. Breaking changes require explicit human approval and test execution.

Data Privacy & Leakage

Mitigation: Offline-first architecture. Signals and specs stay local by default. Explicit consent for cloud processing.

Atomized Roadmap

Spec-driven delivery phases. Deliverable = working spec + integration tests + documentation.

Phase 0 (Complete)

Jan - Feb 2026

Signal Ingestion API

Stateless signal endpoint, validation, metadata enrichment. Local SQLite store. OpenAPI spec.

Done

Spec Compiler

Markdown parser, syntax validation, signal binding resolution. Produces DAG execution plan.

Done

Agent Runtime (MVP)

Execute compiled specs, invoke tools, manage state. Single-threaded, local mode only.

Done

Result Store & Basic Dashboard

Record execution outcomes. Static HTML dashboard with execution timeline and signal digest.

Done

Git Integration & Versioning

Store specs in Git. Automatic versioning on changes. Integration tests for spec mutations.

Done

Documentation & Site

Spec authoring guide, API docs, architecture overview. Live site at theparlor.github.io/intent/.

Done

Phase 1 (In Progress)

Mar - Apr 2026

Web-Based Spec Editor

Monaco-based IDE with live preview, signal binding, validation errors, markdown syntax highlighting.

In Progress

Multi-Signal Binding

Specs can reference multiple signals. Condition logic on signal combinations. Edge case testing.

In Progress

Execution Plan Store (PostgreSQL)

Persist execution plans and outcomes. Queryable history. Replay capability for debugging.

In Progress

Autonomy Levels (L0-L2)

Implement trust framework. L0 = human approval only. L1 = agent with human review. L2 = agent with guardrails.

In Progress

Test & Observability Scaffolding

Integration test framework for spec validation. OpenTelemetry instrumentation. Structured logging.

In Progress

Phase 2 (Planned)

May - Jun 2026

Advanced Dashboard

Real-time signal feed, execution timeline visualization, decision panel, metrics rollup.

Planned

Autonomy Levels (L3-L4)

L3 = full autonomy with audit trail. L4 = multi-agent coordination. Trust scoring, enrichment pipeline.

Planned

Spec Composition & Templates

Reusable spec fragments, inheritance, parameter passing. Template library for common patterns.

Planned

Signal History & Trend Analysis

Query historical signals, aggregate by source/type, detect anomalies, trend visualization.

Planned

Multi-Agent Coordination

Specs can spawn sub-agents, coordinate via shared signal channel. Dependency resolution and deadlock prevention.

Planned

Phase 3 (Future)

Jul 2026+

Temporal Integration

Durable workflow execution for long-running specs. Failure recovery, heartbeat, timeout management.

Future

WASM Spec Compilation

Browser-native spec parsing and validation. Offline spec authoring without server roundtrip.

Future

Distributed Execution

Specs can span multiple hosts/agents. Deterministic ordering, eventual consistency model for distributed signals.

Future

Custom Inference Optimization

Profile high-frequency specs. Evaluate fine-tuning or specialized models. Only if Claude API becomes bottleneck.

Future

Ecosystem & Integrations

Plugin SDK for custom signal sources. Marketplace for spec templates. SDK for embedding Intent in other platforms.

Future

The vision these decisions serve →

The advisory voices that challenge decisions →