Document Purpose: This document provides a comprehensive specification of Archer—the persistent ambient orchestrator that serves as both the primary user experience layer and the meta-coordinator for the entire ARCHER Suite. Archer is not just an assistant or chatbot; it's the always-on operational presence that maintains continuity, synthesizes across the enterprise, and orchestrates intelligence toward outcomes.
Created: January 2026
Status: Conceptual Architecture & Implementation Specification
Before diving in, let's establish clear terminology:
Definition: The complete client-facing product comprising all components:
Use ARCHER (all-caps) when discussing:
Definition: The persistent ambient interface and agentic orchestration runtime layer.
Use "Archer Orchestrator" or "Archer" when discussing:
This document focuses primarily on Archer Orchestrator—the UX layer and uber orchestrator.
Archer Orchestrator is a persistent ambient agent that serves as the primary interface between users and the ARCHER Suite. Unlike traditional chatbots that respond to queries, Archer:
Archer is not "the app." Archer is the persistent operating presence that keeps the system coherent across time, tools, and actions.
This means Archer:
Archer functions as an orchestrator for the client company, not just for individual users:
┌─────────────────────────────────────────────────────────────────────┐
│ ENTERPRISE ECOSYSTEM │
├─────────────────────────────────────────────────────────────────────┤
│ Data & Business Apps │ Communication │ External │
│ - ERP (SAP/Oracle) │ - Email │ - Customers │
│ - CRM (Salesforce) │ - Teams/Slack │ - Vendors │
│ - PLM/MES │ - Meetings │ - Partners │
│ - HRIS │ - Calendar │ - Competitors │
│ - Finance systems │ │ - Industry │
├─────────────────────────────────────────────────────────────────────┤
│ Content & Knowledge │ Development │ AI Work │
│ - SharePoint/OneDrive │ - GitHub/Jira │ - ChatGPT logs │
│ - Google Drive │ - Azure DevOps │ - Claude chats │
│ - Network files │ - CI/CD pipelines │ - Copilot usage │
│ - Document repositories │ - Code repositories │ - Gemini │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ ARCHER ORCHESTRATOR │
│ │
│ Sense → Understand → Engage → Orchestrate │
│ │
│ Continuously collecting, synthesizing, evaluating, and acting │
│ to advance outcomes across the entire enterprise │
└─────────────────────────────────────────────────────────────────────┘
Near-term, Archer can:
Future-state, Archer could:
Current focus: Creating new integrations and automations, not modifying existing processes.
Archer operates in a continuous four-phase loop:
┌─────────────────────────────────────────────────────────────────────┐
│ ARCHER BEHAVIORAL LOOP │
│ (Continuous Operation) │
└─────────────────────────────────────────────────────────────────────┘
┌───────────┐ ┌─────────────┐
│ SENSE │────────▶│ UNDERSTAND │
└───────────┘ └─────────────┘
▲ │
│ ▼
┌───────────┐ ┌─────────────┐
│ORCHESTRATE│◀────────│ ENGAGE │
└───────────┘ └─────────────┘
Observe changes, events, conversations, and signals from across connected systems.
What Archer Senses:
Sensing Principles:
Sensing Capabilities:
- Subscriptions: Real-time change notifications
- Deltas: What changed since last observation
- On-demand fetch: Pull specific objects when needed
- Scheduled scans: Periodic comprehensive checks
Synthesize across sources, resolve contradictions, identify gaps and opportunities.
What Archer Understands:
Understanding Principles:
Understanding Outputs:
- Synthesized insights (across sources)
- Outcome status updates (progress, regression, blockers)
- Opportunity alerts (underserved outcomes detected)
- Context packages (assembled for specific tasks)
Deliver role-based nudges and recommendations in the flow of work.
How Archer Engages:
Engagement Principles:
Engagement Channels:
- Web/Mobile app (primary interface)
- Teams/Slack bot
- Email digests and alerts
- In-app notifications
- Calendar integrations
- Voice interfaces (future)
Trigger actions across humans, agents, and tools. Coordinate execution.
What Archer Orchestrates:
Orchestration Principles:
Orchestration Capabilities:
- Task delegation (to agents via Fluxio)
- Approval routing (to humans)
- Workflow execution (via n8n/Power Automate)
- System updates (via connectors)
- Automation assembly (create new workflows)
Archer requires operational memory—not just chat history, but persistent understanding of the user, their context, and the system state.
┌─────────────────────────────────────────────────────────────────────┐
│ LAYER 1: CONTEXT MEMORY (Cogniscient) │
│ - Entities: people, accounts, projects, products, processes │
│ - Relationships: who works with whom, what depends on what │
│ - History: what happened, when, why │
│ Persistence: Long-term (months to years) │
└─────────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────────────────────┐
│ LAYER 2: OUTCOME MEMORY (ODIE) │
│ - Active outcomes and their status │
│ - Opportunity scores and priorities │
│ - Constraints and dependencies │
│ Persistence: Long-term (stable anchors) │
└─────────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────────────────────┐
│ LAYER 3: ENGAGEMENT MEMORY (Archer-specific) │
│ - User preferences (communication style, timing) │
│ - Approval history (what they typically approve/reject) │
│ - "Do not nudge" zones (topics to avoid) │
│ - Interaction patterns (when they respond, how they respond) │
│ Persistence: Medium-term (months) │
└─────────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────────────────────┐
│ LAYER 4: EXECUTION MEMORY (Fluxio integration) │
│ - Actions taken and their results │
│ - Pending tasks and their status │
│ - Rollback paths (how to undo if needed) │
│ Persistence: Medium-term (task duration + history) │
└─────────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────────────────────┐
│ LAYER 5: TRUST MEMORY (Librarian integration) │
│ - Per-source reliability (which sources to trust) │
│ - Per-signal confidence calibration │
│ - Resource performance (which tools work well) │
│ Persistence: Medium-term (calibrated over time) │
└─────────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────────────────────┐
│ LAYER 6: WORKING MEMORY (Ephemeral) │
│ - Current conversation context │
│ - Active task state │
│ - Assembled context bundles │
│ Persistence: Session or task duration │
└─────────────────────────────────────────────────────────────────────┘
Archer is not a command-line interface. Archer is not a chatbot. Archer is a persistent operational partner.
Design Principles:
Mode: AMBIENT
Description: Background monitoring, no active UI
User experience: Archer is working invisibly
Triggers: Change detection, scheduled tasks
Outputs: Notifications when attention needed
Mode: NUDGE
Description: Gentle prompt for attention
User experience: Non-intrusive suggestion appears
Triggers: Opportunity detected, action recommended
Outputs: Dismissible notification with one-click action
Mode: CONVERSATIONAL
Description: Active dialogue with user
User experience: Chat-like interaction
Triggers: User initiates, complex situation requires discussion
Outputs: Natural language exchange, clarifying questions
Mode: FOCUSED
Description: Deep work on specific task
User experience: Dedicated workspace for task
Triggers: User selects specific workflow
Outputs: Structured interaction with clear progress
Mode: REPORTING
Description: Summarized view of state
User experience: Dashboard or digest
Triggers: User requests summary, scheduled report
Outputs: Consolidated view of outcomes, actions, opportunities
Nudges are Archer's primary engagement mechanism. A nudge is a gentle prompt toward a beneficial action.
Nudge:
nudge_id: unique identifier
# Content
message: human-readable nudge text
summary: one-line version for notifications
rationale: why this nudge is being given
# Targeting
recipient: user_id
channel: where to deliver (Teams, email, app, etc.)
urgency: low | medium | high | critical
# Context
linked_outcomes: [outcome_ids this nudge supports]
linked_signals: [signals that triggered this nudge]
# Actions
recommended_actions: [actions user can take]
- action_id: identifier
label: button text
effect: what happens if clicked
requires_confirmation: boolean
# Lifecycle
created_at: timestamp
expires_at: timestamp (nudge becomes stale)
status: pending | delivered | seen | acted | dismissed | expired
# Feedback
user_response: accepted | rejected | snoozed | modified
user_feedback: freeform text
outcome_impact: did it help? (measured after action)
Delivery Rules:
# Timing
- Respect user's working hours
- Batch low-urgency nudges
- Deliver high-urgency immediately
- Don't interrupt focused work
# Frequency
- Max nudges per hour: configurable by user
- Cooldown after dismissed nudge
- Escalate only if ignored and critical
# Channel selection
- Critical: All channels simultaneously
- High: Primary channel + one backup
- Medium: Primary channel only
- Low: Digest only
# Personalization
- Learn user preferences from responses
- Adapt tone to user's communication style
- Consider time zone and calendar
Archer connects to the enterprise through a standardized connector framework:
Connector:
connector_id: unique identifier
name: human-readable name
type: crm | erp | communication | file_storage | development | custom
# Capabilities
capabilities:
- search: Can search for objects
- fetch: Can retrieve specific objects
- watch: Can subscribe to changes
- write: Can update/create objects
- delete: Can remove objects
# Authentication
auth_type: oauth2 | api_key | service_account | user_delegated
permission_model: how permissions are enforced
# Data Model
supported_entities: [entity types this connector provides]
relationship_mapping: how entities relate to canonical model
# Status
status: active | degraded | unavailable
health_check: endpoint for status verification
last_sync: timestamp
Every connector should provide:
StandardCapabilities:
# Discovery
list_entities(): Available entity types
describe_entity(type): Schema for entity type
# Read
search(query, filters): Find matching objects
fetch(id): Get specific object
# Watch
subscribe(filter, callback): Notify on changes
get_changes(since): Delta since timestamp
# Write (if supported)
create(entity): Create new object
update(id, changes): Modify existing object
delete(id): Remove object
# Permissions
check_permission(user, action, object): Can user do this?
get_accessible(user): What can this user access?
Tier 1 (MVP):
Tier 2 (Near-term):
Tier 3 (Future):
Default posture: "See what the user can see"
Permission Principles:
- Archer inherits user's permissions
- Source-enforced permissions (respect ACLs)
- No elevation without explicit grant
- Audit all access attempts
Permission Resolution:
1. Check user's identity
2. Query source system for permissions
3. Cache permission decisions (with TTL)
4. Log access with rationale
Maturity ladder for autonomy:
Level 0: READ-ONLY
- Archer can observe and report
- No actions taken without user initiation
Level 1: DRAFT
- Archer can prepare actions
- User must review and execute
Level 2: RECOMMEND
- Archer suggests actions with one-click execution
- User approval required
Level 3: EXECUTE WITH APPROVAL
- Archer can execute after explicit approval
- Approval may be pre-configured for routine actions
Level 4: NARROW AUTONOMY (rare)
- Archer can execute specific, well-defined actions
- Within strict guardrails and limits
- Full audit trail
Every significant action is logged:
AuditEntry:
audit_id: unique identifier
timestamp: when
# Actor
actor_type: user | archer | agent | system
actor_id: who/what took the action
# Action
action_type: read | create | update | delete | approve | execute
action_description: human-readable description
# Target
target_type: what kind of thing
target_id: specific object
target_system: which system
# Context
rationale: why this action was taken
triggered_by: what initiated this (nudge_id, outcome_id, etc.)
# Outcome
result: success | failure | partial
error_details: if failed, why
# Reversibility
reversible: boolean
rollback_procedure: how to undo if needed
One of Archer's key capabilities is proposing and deploying new automations.
1. OPPORTUNITY DETECTION
- Archer identifies repeated manual work
- Archer spots missing signals or reports
- Archer notices decision latency
- User requests automation
2. AUTOMATION PROPOSAL
- Archer drafts workflow definition
- Specifies triggers, actions, conditions
- Estimates impact and cost
- Identifies risks and failure modes
3. SIMULATION & VALIDATION
- Run in sandbox environment
- Test with synthetic or limited-scope data
- Validate permissions and security
- Check failure modes and edge cases
4. HUMAN APPROVAL
- Route to process owner
- Route to security/compliance if needed
- Explain what it does and why
- Provide risk assessment
5. DEPLOYMENT
- Promote to production
- Configure monitoring and alerting
- Set error budgets and rollback triggers
- Enable observation
6. CONTINUOUS OPTIMIZATION
- Measure impact (time saved, errors reduced)
- Gather feedback
- Propose improvements
- Deprecate if no longer valuable
AutomationProposal:
proposal_id: unique identifier
name: human-readable name
description: what this automation does
# Justification
opportunity: why this automation is needed
expected_impact:
time_saved: estimate
errors_reduced: estimate
other_benefits: [list]
# Definition
trigger:
type: event | schedule | condition | manual
specification: details
actions:
- action_type: what to do
target_system: where
parameters: how
conditions: when (within the workflow)
# Risk Assessment
risks:
- description: what could go wrong
likelihood: low | medium | high
impact: low | medium | high
mitigation: how to handle
# Governance
required_approvals:
- role: who needs to approve
reason: why
permissions_needed:
- system: which system
permission: what access
reason: why needed
# Execution Details
platform: n8n | power_automate | custom
workflow_definition: [platform-specific definition]
# Status
status: draft | proposed | approved | deployed | deprecated
created_at: timestamp
approved_by: user_id
deployed_at: timestamp
Archer ODIE
│ │
│ "New signals detected" │
│──────────────────────────────────▶│
│ │
│ "Outcome X regressing. │
│ Opportunity score: 87. │
│ Recommend Action Y." │
│◀──────────────────────────────────│
│ │
│ "User approved Action Y. │
│ Execution result: +12 delta" │
│──────────────────────────────────▶│
│ │
│ "Belief updated. │
│ Action hypothesis accuracy: 80%"│
│◀──────────────────────────────────│
Archer provides to ODIE:
ODIE provides to Archer:
Archer Cogniscient
│ │
│ "Store entity: Meeting with │
│ Acme Corp, discussed pricing" │
│──────────────────────────────────▶│
│ │
│ "Retrieve context: What do we │
│ know about Acme Corp?" │
│──────────────────────────────────▶│
│ │
│ [Entity graph, relationships, │
│ history, related outcomes] │
│◀──────────────────────────────────│
│ │
│ "Check consistency: Does this │
│ contradict anything we know?" │
│──────────────────────────────────▶│
Archer provides to Cogniscient:
Cogniscient provides to Archer:
Archer Fluxio
│ │
│ "Execute Action Y with these │
│ parameters, expected delta +15" │
│──────────────────────────────────▶│
│ │
│ "Which agent/tool should │
│ handle this?" │
│ ────────────▶ [Librarian] │
│ │
│ [Routes to appropriate agent] │
│ │
│ "Execution complete. │
│ Result: success, delta +12" │
│◀──────────────────────────────────│
Archer provides to Fluxio:
Fluxio provides to Archer:
Archer Librarian
│ │
│ "I need capability X for │
│ context Y" │
│──────────────────────────────────▶│
│ │
│ "Best resource: Agent Z │
│ Score: 87, confidence: high" │
│◀──────────────────────────────────│
│ │
│ "Execution complete. Feedback: │
│ success, latency 234ms" │
│──────────────────────────────────▶│
Archer provides to Librarian:
Librarian provides to Archer:
┌─────────────────────────────────────────────────────────────────────┐
│ A) ACCESS PLANE │
│ (Federation / Connectors) │
│ │
│ Provides: search, fetch, deltas, permission checks │
│ Components: M365 Connector, CRM Connector, File Connector, etc. │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ B) CONTEXT PLANE │
│ (Cogniscient) │
│ │
│ Holds: entity graph, relationships, histories, provenance │
│ Purpose: semantic spine (NOT a data lake) │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ C) REASONING PLANE │
│ (Archer Orchestrator + ODIE) │
│ │
│ Routes: which sources to consult, which objects to retrieve │
│ Reasons: synthesis, planning, nudges, recommendations │
│ Delegates: to specialized agents and tools │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ D) ACTION PLANE │
│ (Fluxio + n8n/Power Automate) │
│ │
│ Executes: approved workflows and integrations │
│ Produces: auditable results back into context │
└─────────────────────────────────────────────────────────────────────┘
ARCHER RUNTIME LOOP:
1. INGEST
- Pull/receive events from connectors
- Detect changes via subscriptions and deltas
- Receive user inputs and feedback
2. NORMALIZE
- Map events to canonical Event schema
- Extract entities and relationships
- Tag with metadata and provenance
3. UPDATE COGNISCIENT
- Store new entities and relationships
- Update existing entities with new information
- Maintain temporal history
4. EVALUATE OUTCOMES (via ODIE)
- Map events → signals → outcome state changes
- Recalculate opportunity scores
- Identify outcomes that need attention
5. GENERATE CANDIDATES
- Actions and nudges with expected outcome deltas
- Prioritize by opportunity score
- Check constraints and policies
6. GOVERN
- Apply permissions and access controls
- Check approval requirements
- Validate against policies
7. ENGAGE
- Deliver nudges through appropriate channels
- Ask clarifying questions if needed
- Await user decisions for significant actions
8. EXECUTE (via Fluxio)
- If approved, run the action plan
- Route to appropriate agents/tools
- Handle errors and fallbacks
9. OBSERVE
- Capture resulting events
- Measure actual outcome delta
- Compare to expected delta
10. LEARN
- Update beliefs and confidence (ODIE)
- Update resource scores (Librarian)
- Refine engagement preferences
- Store lessons learned
[REPEAT CONTINUOUSLY]
These principles must not be violated:
No datalake-by-default. Centralizing content is the exception, not the mechanism.
Zero-copy retrieval by default. Retrieve minimal content on demand.
Compute-to-data. Prefer source-side processing where feasible.
Permissioning is foundational. Default posture: "see what the user can see."
Auditability. Every nudge/action must be explainable and attributable.
Ephemeral working memory. Persist pointers, metadata, provenance; keep content task-scoped.
Governed autonomy. Propose → simulate → approve → deploy → monitor.
Orchestrator, not BI. Dashboards may exist, but they are not the center of gravity.
For Archer Orchestrator prototype:
Skip for MVP:
Frontend:
- Web: React/Next.js
- Mobile: React Native or native
- Chat integrations: Teams SDK, Slack SDK
Backend:
- Runtime: Node.js or Python
- API: REST + WebSocket for real-time
- Queue: For async processing
Storage:
- Cogniscient integration for entities/relationships
- Cache for working memory (Redis or similar)
- Time-series for signals and events
Execution:
- Fluxio integration for agent routing
- n8n or Power Automate for workflow execution
Engagement Metrics:
- Nudge acceptance rate
- Time to action after nudge
- User-initiated vs. proactive interactions
- Channel preference patterns
Outcome Metrics:
- Outcomes achieved/progressed
- Opportunity scores reduced (underserved → served)
- Actions that moved outcomes forward
Efficiency Metrics:
- Time saved per user
- Automations deployed
- Manual work eliminated
Trust Metrics:
- Nudges dismissed without action
- Feedback sentiment
- Accuracy of recommendations
Archer Orchestrator is the persistent ambient intelligence layer that serves as both:
Key Characteristics:
The Core Loop:
Sense → Understand → Engage → Orchestrate
The Ultimate Goal:
Be the trusted operational partner that helps users and organizations achieve their outcomes—continuously, contextually, and safely.
Document created January 2026