System Architecture

Deprex operates on a multi-layered architecture modeled on human cognitive processes. It is designed not as an “AI tool that responds to instructions” but as a cognitive ecosystem that thinks, plans, executes, and learns autonomously, working backward from goals, memory, and observations.

Design Philosophy — AI Reimplementation of Palantir FDE

Deprex’s architecture starts from the question of how to reimplement Palantir’s Forward Deployed Engineer model with AI. Human FDEs deployed on-site at customers’ offices, absorbing context directly and reflecting it into software, achieve a quality of implementation that external proposals cannot reach.

Deprex recreates this “deployment → observation → internal problem framing” model with AI agents. The AI FDE is embedded in the customer’s chat, email, and document management systems, learning the context of operations while autonomously executing routine work.

This vision is the starting point for every layered design decision in Deprex.

5-Layer Architecture

Deprex separates responsibilities into 5 layers. Each layer is loosely coupled, so changes in upper layers do not affect lower layers.

Layer	Responsibility	PM Engagement
L5 Customer Adaptation Engine	Tenant-specific business rules, onboarding, pattern library management	High (provides domain knowledge)
L4 Autonomous Execution Engine	Cognitive loop control, resident scheduler, mid/long-term strategy	Medium (task approval & review)
L3 Knowledge Accumulation Engine	Wiki management, knowledge query and curation	Low (FDE manages autonomously)
L2 Data Collection Layer	Differential collection from chat, email, documents, etc.	Low (initial connection only)
L1 Foundation Infrastructure	Agent runtime, authentication, daemon residency	None (operated by 0ai)

PMs interact with the FDE primarily through L5. L4 and below — cognition, execution, data collection — are driven autonomously by the FDE.

Adding a new data source affects only the L2 connector; changing tenant-specific rules affects only L5. The blast radius of any change is structurally localized.

Reactive Mind and Proactive Mind

Following the brain’s processing hierarchy, Deprex has both a reactive mind triggered by inputs and a proactive mind driven internally.

+--------------------------------------------------+
|  Sensory                                         |
|  - Receive, resolve metadata, fetch files        |
|  - No reasoning                                  |
+--------------------------+-----------------------+
                           |
+--------------------------v-----------------------+
|  Reflexive                                       |
|  - Triage input (instant / light / complex)      |
|  - High-confidence patterns get instant replies  |
|  - Complex items escalate to the cognitive layer |
+--------------------------+-----------------------+
                           |
+--------------------------v-----------------------+
|  Cognitive                                       |
|  - Run the full cognitive cycle                  |
|  - Also self-activates on internal timers        |
+--------------------------------------------------+

This unifies in a single system both “a reactive bot that responds instantly to @mentions” and “a proactive agent that continues to observe and learn on its own.”

Reflexive responses return at sub-second latency without harming the PM’s perceived speed. Tasks requiring complex judgment or external side effects are handed to the cognitive layer and executed only after a full cognitive cycle.

Cognitive Cycle — Bidirectional Network

In the cognitive layer, every complex task is processed through a cognitive cycle. This is not a linear pipeline but a network where each phase can feed back bidirectionally to others.

Phase	Role
PERCEIVE	Observe the environment
REMEMBER	Reference relevant memory
REASON	Inference and judgment
PLAN	Plan formulation
ACT	Execution and external effects
EVALUATE	Result evaluation
LEARN	Knowledge formation and memory update

Phases are dynamically reactivated based on the situation, not controlled in fixed order. This mirrors how humans naturally “observe again” or “revise the plan” while solving problems.

Cycles iterate recursively until acceptance criteria are met, completing only when quality has converged.

Structural Bias Removal

When LLMs make judgments alone, confirmation bias takes hold and reinforces wrong directions. Errors in the reasoning phase are especially damaging because they propagate through every downstream phase.

Deprex structurally embeds multi-layer guardrails in reasoning. Each conclusion is challenged by an independent context separate from the one that produced it. Higher-risk decisions are audited from more perspectives, and a negative judgment halts further progress at that point.

These guardrails increase reasoning cost, but the gain is substantial compared to the cost of a flawed decision contaminating everything downstream.

AC-Driven Autonomous Development

The completion of a Deprex cognitive cycle is judged not by a vague sense of “done” but by whether predefined Acceptance Criteria have been mechanically satisfied.

Requirements              Implementation       Verification
-----------------------   -----------------    ----------------
Objective + AC         -> Spec (with         -> Independent
                          evidence type and     verification
                          verification steps)   subagent
                                                  |
                                                PASS / FAIL
                                                  |
                                                FAIL -> fix -> reverify
                                                  |
                                                Repeated failure
                                                -> escalate to human

Each AC declares an evidence type that ties it to a verification procedure suited to its nature: test execution, semantic LLM judgment, state inspection, command output review, or human review.

Verification is delegated to a verification subagent running in an independent context, not to the agent that did the implementation. The subagent receives only the target and the criteria — implementation process and prior attempts are deliberately hidden. This structurally removes the confirmation bias of “evaluating one’s own output.”

Autonomous Execution Without Approval Gates

Deprex executes every phase of the cognitive cycle end-to-end autonomously. There is no human approval gate between phases.

This is not about overlooking dangerous operations. It is the explicit design judgment that human approval speed is thousands of times slower than AI processing speed, and gates trap AI in the role of an “expensive assistant.”

In place of gates, the following structural safeguards apply:

• Predefined escalation conditions: Irreversible operations, externally impactful actions, and threshold breaches are handed to humans before execution
• Quantitative limits: Batch caps, parallel-work caps, and cost budgets prevent runaways
• Append-only judgment ledger: Every cognitive module decision is recorded; quality is ensured by retrospective review
• AC verification loop: Code and artifact correctness is verified structurally

Designing “what humans must judge” leaves the rest to AI. This is Deprex’s autonomy philosophy.

3-Axis Self-Improvement Loop

Deprex autonomously improves its own harness (skills, rules, cognitive modules) from three independent signal sources.

Signal Source	Trigger	Behavior
Failure signal	Task failure, user correction, friction	Real-time causal analysis and fix
Ground-truth signal	Quality gap against human artifacts	Convergence loop optimizing the producer of the artifact
Experiment signal	Improvement room with only criteria defined	Exploration that monotonically increases quality with criteria fixed

The three axes share the same optimization target; only the signal source differs. A continuously running daemon monitors each signal and synchronously drives improvement upon detection.

The experiment signal in particular adopts a pattern where, if you define only the criteria and walk away, many improvements are tried and verified in the background. Only confirmed improvements are kept; the rest are discarded — a behavior that guarantees monotonic quality increase.

Agent-First Execution — Concentrating Judgment in AI

The responsibility boundary between scripts and AI in Deprex is clearly separated.

Responsibility	Implementation
I/O pipelines (collection, storage, formatting)	Scripts (deterministic)
Database and file operations	Scripts
Relevance judgment, summarization, context selection, document composition	AI (requires natural language understanding and semantic judgment)

Operations involving judgment, interpretation, or inference have a quality ceiling when implemented as heuristics. Delegating them to AI keeps the structure where AI model improvements directly translate into system-wide quality improvements.

Daemon-Driven — Two Always-On Processes

Deprex runs two daemon processes continuously.

Reactive Daemon

Receives @mentions in chat and routes them through three-stage triage.

• Reflexive response: Greetings, simple Q&A → instant reply
• Light tasks: Summarization, search → handled in place
• Complex tasks: Report generation, analysis → fed into the cognitive cycle

Proactive Daemon

Beyond cron schedules, performs internally driven activity.

• Memory curation: Detect staleness in accumulated memory, propose merges and refinements
• Harness self-improvement: Continuous execution of the 3-axis (failure / ground-truth / experiment) loop
• Cognitive scheduling: Dynamically optimize execution order using each task’s history (success rate, duration, dependencies)
• Operational observation: Detect new task patterns from chat and meeting transcripts and propose them as skill candidates

It is designed not as a command to be invoked but as a residency that keeps running.

Autonomous Task Displacement Pipeline

Deprex’s most important capability is autonomously displacing human tasks. This is realized through a 6-stage pipeline from observation to production cutover.

1. Operational flow observation
   FDE detects task patterns from chat and meeting transcripts

2. Task flow recording
   Detected patterns are recorded as structured I/O ground truth

3. Skill auto-generation
   Skills are auto-generated from task flows

4. Shadow comparison
   FDE output is run in parallel with human output and compared

5. Production displacement
   After PM approval, FDE switches to autonomous execution

6. Continuous improvement
   Skills self-improve via the 3-axis loop on execution feedback

The PM receives notifications at each stage and approves them. The essence of this structure is self-propagating automation — FDE finds its own tasks, builds its own skills, and improves itself.

Multi-Tenant Isolation

To deploy FDEs simultaneously to multiple client organizations, tenants are completely isolated.

app/orgs/
  acme/          # Acme's environment
    skills/      # Skills auto-generated for Acme
    memory/      # Memory learned from Acme's operations
    config/      # Acme-specific authentication and config
  beta-inc/      # Beta Inc's environment
    skills/
    memory/
    config/

The directory structure itself is the tenant definition; no separate tenant declaration file is required. Adding a new tenant is just creating a directory.

Each tenant’s memory, skills, and configuration are not visible across tenants. Patterns observed in Acme’s chat will never contaminate Beta Inc’s skills.

Differences from Other AI Agent Systems

Multiple systems claim to “act autonomously.” To clarify Deprex’s positioning, here is a comparison against general-purpose OSS agent runtimes.

Aspect	General OSS agent runtime	Deprex
Central metaphor	Personal learning agent	FDE deployed in the customer organization
Memory abstraction	Personal notebook	Organizational wiki (per-tenant knowledge graph)
Cognitive loop	Single agent loop	Bidirectional network + multi-layer guardrails
Bias removal	Mostly relies on user review	Structural context separation via independent subagents
Self-improvement	Per-PR review	Multi-axis daemons running continuously
Multi-tenant	Not central to the design	Central to the design (tenant isolation as a first-class concept)
Completion check	Trial-and-error test pass	Structural verification with AC × evidence type
Approval	Halts on dangerous ops	No approval gates + structural safeguards
Target user	Individual developers / SaaS automation	B2B customers requiring an embedded operator

General OSS chooses “broad and shallow”; Deprex chooses “narrow and deep.” The two are not competitors — they solve different problems. Deprex commits deeply to challenges intrinsic to embedded operation (tenant isolation, long-term knowledge accumulation, judgment-quality assurance, autonomy throughput), achieving a quality that general-purpose OSS cannot reach.

What This Means for the PM

PMs do not need to understand the architectural details. The four points that matter:

1. The FDE is always on — observation and learning continue even without requests
2. Automation progresses in stages — observe → propose → approve → execute, with PM control at each step
3. Quality improves autonomously — the FDE itself improves outputs through the 3-axis loop
4. Judgment quality is structurally protected — multi-layer guardrails and AC verification break chains of bad decisions

Deprex is designed not as “an AI tool the PM operates” but as a resident agent that continuously surfaces decisions to the PM for approval against the organization.