> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles
STARLOG RESEARCH / ARTEX FIELD GUIDE

How ARTEX
worksInside the code.
Across the descendants.

Follow a task from planner to evidence. Inspect the control boundaries. Decide what to evaluate in your own environment.

18descendants reviewed
06deeper code reviews
04control boundaries compared
01observed deployment

How ARTEX works: a practical guide to 18 descendants

Research deep dive · 16 November 2026.

ARTEX coordinates a model, a planner, workers and tools around a persistent graph of goals and observations. To understand a run, follow how work enters that graph, how a worker executes it, and how the resulting evidence becomes a finding. To choose a descendant, inspect where it changes that flow.

We inspected 18 selected derivatives at pinned commits: 17 Go branches and one Python rebuild. Six received deeper review; twelve received targeted comparisons. A separately labeled live example shows how graph state and finding review appear in an operator-provided deployment. The comparison maps mechanisms and practical choices; it does not rank testing effectiveness.

Cloudflare counted 204 public ARTEX repositories with their own code changes after the creator removed the original. That count is useful context, but it does not tell an operator which implementation to evaluate. A translated UI, a process-local budget, a database-backed budget, and a new implementation can all appear in the same fork tree. The question for a reader is what changed at the point where an agent plans work, invokes a tool, or declares a finding.

Our clearest example is the budget boundary. BaaRai keeps a task ledger in process memory; DITING reserves tokens in a database transaction. Both add limits. A restart changes the meaning of one limit, while the other records reservations durably. Neither excerpt proves that every model call or dollar of spend is covered.

Choose a reading path

For a first read, follow the engine and worked example, Cairn’s architectural connection, then the observed task. For installation and evaluation, go to practical answers. For a code review, use the comparison below and the collapsed source entry points.

Use this table to choose where to begin:

Your questionRelevant implementations in this sampleWhat the source answers
Can I bound a run and understand its cost?BaaRai, DITING, PojunChoose process-local or durable admission; configure limits and account for recorded usage separately.
Can another client or teammate safely launch work?RuoJi6, MoLeft, AntiFoxInspect scopes at invocation, account authentication and role checks before delegating access.
Can I distinguish a finding from an unsupported claim?sharenjun, NiuDao, ARTEX-MUTANTFollow saved evidence, shadow-verification results and review disposition as distinct steps.
Can a local model handle the workflow?ScopeWeaverConfigure native Ollama, context and inference-network policy; evaluate quality on your own lab task.
Is this a source fork or a new implementation?ARIA-X and the branch notesSeparate the Python conceptual rebuild from the Go source comparisons.

The most useful reading rule is to separate a feature in source, a feature enabled in a deployment, and a feature demonstrated to work. This study primarily addresses the first.

The shared ARTEX engine

The frozen Hinln/ARTEX snapshot is a comparison reference, not a verified byte-for-byte copy of the deleted upstream. Its schema stores exploration nodes, plus edges and asset anchors. A planner loop reacts to graph activity; separate workers claim intents. The diagram is a schematic of that design, not a traced execution.

INTERACTIVE EXPLAINERSchematic · not a live run
Graph stategoals + observations Plannerreads → decides Intent queueclaimable work Worker + toolsinvestigate the intent Observationspreserve + write back STATE → WORK → EVIDENCE
01

Graph state becomes a decision

The planner reads the current exploration state and proposes work. Its output is an intent: a unit of work, not a grant of authority.

server/engine.go · planner loop
Open the reference architecture diagram · static source schematic
The ARTEX reference control loopSchematic from the frozen reference: graph changes wake the planner; workers return observations. The ARTEX reference control loop Schematic from the frozen reference: graph changes wake the planner; workers return observations. Exploration graph goal, intent, fact, finding Planner reads graph state Intent queue claimable work Worker executes an intent Tools network / browser / shell Observations write evidence and facts Asset graph target relationships Arrows show the conceptual loop, not a traced runtime call graph.
Architecture: the shared graph, planner, intent queue, worker, and observation loop in the frozen reference.

This common loop matters because a change can land at several very different boundaries. A prompt can ask the planner to stop; a server can reject a tool call; a network boundary can block a request; a database can refuse to record a result. Those are different guarantees, even when a README calls all of them “scope control.”

Follow one task through the loop

Consider an authorized lab exercise: can a read-only account retrieve a record that the lab's policy reserves for another account? This is an illustrative scenario, not a finding from our observed deployment.

ARTEX conceptMeaning in the workflowExample in this lab
TaskThe overall run and its configurationEvaluate the specified access-control rule within an approved scope and budget.
GoalA question the run is trying to resolveDetermine whether the account boundary holds.
IntentA unit of work a worker can claimInspect the relevant request using the permitted lab accounts. An intent is work to do, not a grant of authority.
FactAn observation recorded in the graphSave what the application returned and link the supporting artifact. A stored fact still needs interpretation.
FindingA claim of a security issue, with supporting evidenceExplain a demonstrated policy violation and its impact, then submit it for review.

The planner reads the current graph and proposes work. A worker claims an intent, calls the available tools, and records observations. Those observations change what the planner knows, so the next round can investigate a remaining question or move toward completion. In this example, an HTTP success code alone would not establish an access-control failure: the response content, account identity and intended policy matter.

That is the key distinction when reading a graph: an edge records a relationship asserted by the system; the linked evidence is what lets a reviewer assess that assertion. A node marked complete or confirmed does not, by itself, establish a validated vulnerability. The observed task shows this distinction in actual stored results.

Follow the loop in code · three useful entry points

Start with the reference planner loop, then the worker intent-claim path, and finally the finding graph-node writer. Read these as entry points into a larger implementation, not three adjacent calls. For each fork, ask which part of that flow its change intercepts and what state it reads or writes.

Cairn: why shared state matters

oritera/Cairn is an important reference for understanding ARTEX. The frozen ARTEX README explicitly lists Cairn under references. Cairn describes a blackboard architecture built around facts, intents and human hints: workers coordinate through shared state, and the next direction depends on what has been learned. That acknowledgment and the matching pattern establish a concrete connection; they do not establish code inheritance or a runtime dependency.

Our architectural reading is that ARTEX’s central advantage is the opportunity to make progress accumulate across worker sessions. Cairn makes that idea particularly clear. Three mechanisms explain why it matters:

01 / REMEMBER

Keep the result

A shared board gives the next worker a place to recover prior observations. Cairn persists facts, intents, their source links and hints in its database schema.

02 / RECONSIDER

Choose from current state

Cairn’s reasoning task prepares the graph snapshot, valid fact IDs and open intents. Its prompt asks for useful, non-overlapping directions; that instruction still depends on model judgment.

03 / CONNECT

Feed the next step

When an exploration concludes, Cairn stores a new fact and links the intent to it. The outcome becomes part of the state available to later reasoning.

In the lab example above, discovering how a record is associated with an account can inform the next authorized comparison. A later worker can use that recorded result to choose its next question. This is the useful promise of the loop: each step can build on the last, including observations that rule out an approach. It also creates a failure mode: an unsupported statement saved as a fact can misdirect later work. Persistent state makes evidence quality more consequential.

ARTEX gives this pattern a testing-specific shape. Its reference implementation has separate planner and worker loops, and its exploration edges and asset anchors connect the progress of a task to the assets it concerns. Cairn’s simpler vocabulary helps explain the organizing principle; ARTEX’s implementation provides the additional structures examined throughout this article. ARIA-X also explicitly credits Cairn for its state-and-search layer, showing that the idea extends beyond Go source forks.

How would we know this contributes to success? In a controlled lab, inspect whether later decisions cite useful prior observations, whether workers repeat completed work, and whether final claims have a reviewable evidence path. Measure validated outcomes and review time alongside cost. Isolating the graph’s causal contribution would require a controlled comparison with shared-state reuse disabled, holding model, tools, task and budget constant. We have not run that experiment; the source supports the mechanism and its rationale, rather than a measured improvement in success rate.

Read the ScopeWeaver code map

Explore the same code knowledge graph used by Starlog’s ScopeWeaver article. Start in Concepts, use the four-step walkthrough, then switch to Files to inspect the selected code and dependency relationships. Follow Task → Agent → Evidence, and compare the Transcript / Session and PTY branches.

This map helps you find code; its concept links are generated relationships, not a runtime trace. It contains a sample of 41 code/dependency nodes, 16 file-level relationships and 10 concepts, including tests, vendored helpers and external imports. The core planner loop is better explained by the source entry points above.

Graph provenance and reviewed annotations · captured 16 November 2026

We preserved Starlog’s nodes, edges and concept-to-file links, and revised its descriptions and walkthrough against the pinned ScopeWeaver source. The graph payload does not record its extraction commit, so it cannot be assumed to match the article’s reviewed revision. The dated snapshot keeps this article stable if Starlog regenerates the live map. In particular, the selected evidence helper does not prove immutability, and the advisory-lock test does not describe every database operation.

The annotation review used these source files:

One observed task: done versus validated

To see how the architecture appears in stored results, we inspected an operator-provided ARTEX deployment on 16 November, using read-only database transactions, then inspecting its task and graph views. We selected the most recent completed task with a finding in the inspected set. No new scan or retest was launched. This is a deliberately selected example, not a representative sample or a benchmark. The local image had no source-revision label, so these observations cannot be attributed to one of the pinned public branches.

TASK LIFECYCLEDone

The application marked the run complete.

GRAPH NODEConfirmed

The graph records a finding assertion.

FINDING REVIEWPending

The separate finding record awaits disposition.

The task was marked done. Its graph held nine nodes: two goals, two intents, four facts, and one finding. It had 111 model-usage rows and 128 tool-use activity events. Those counts describe recorded activity, not successful actions or a provider invoice.

The finding’s graph node was confirmed, while its separate finding record remained pending. The record had evidence text, a report, and five traffic bindings; there were no records for it in the application’s retest table. That does not establish whether someone reviewed it elsewhere, nor whether the claimed vulnerability is real. It shows why a reader must ask which state a dashboard is displaying.

A stored graph is not a validation verdictAnonymized subset from one completed task. Solid edges retain the stored relation labels. A stored graph is not a validation verdict Anonymized subset from one completed task. Solid edges retain the stored relation labels. derived_from yields proves yields record link Origin fact state: origin Intent A state: done Fact A state: confirmed Goal A state: met Finding node graph state: confirmed Finding record disposition: pending 5 traffic bindings Other nodes and edges are omitted. The dashed link is a record association, not an exploration-graph edge. No target details or evidence bodies are shown; neither node labels nor bindings establish vulnerability validity.
Observed graph subset, with target details and node identifiers removed. Labels and edge directions come from stored metadata; the drawing is not a replay of execution or independent validation of a finding.

The public reference also illustrates the distinction: its finding recorder writes a graph node with state confirmed, while the separate finding table has a default disposition of pending. That is a source example of distinct state fields, not proof that the live deployment matches that commit.

For an evaluator, the useful chain is recorded activity → preserved evidence → reviewed conclusion. Keep the counters for each stage separate. A coverage percentage needs the same discipline: name its denominator and distinguish a known asset, an attempted check, and a demonstrated security outcome.

Practical answers: from checkout to reviewed result

The source and configuration let us answer several adoption questions now. The instructions below apply to the named snapshots; they are not interchangeable settings for every descendant. We checked the three Compose configurations by resolving them with a minimal environment and a dummy database password. This validates their declared services, builds, ports and mounts; it does not demonstrate a successful installation.

What will the default installation actually run?

Pinned snapshotApplication image configurationWeb port 8787Practical consequence
BaaRaiBuild from this checkout; artex:localExplicit 127.0.0.1 defaultBuild the pinned checkout and retain its commit plus image ID.
ScopeWeaverBuild from this checkout; scopeweaver:localNo host address specifiedSet the intended host binding before starting a local evaluation.
RuoJi6Pull ruoji6/artex:latest by default; no app build stanzaNo host address specifiedPin an image digest and establish its source provenance separately. Checking out a commit does not pin this image.

All three bind port 8788 explicitly to loopback. Docker normally publishes a port on all host addresses when the mapping omits a host address, although daemon/network defaults can override that behavior. A loopback web binding controls access to the UI; it does not constrain requests sent by agent tools. Docker port-publishing documentation.

For a first local evaluation, pin the checkout, replace template credentials, inspect the effective Compose configuration privately, and verify the running image and mounts before adding a target. Record the build inputs and image digest alongside the task. That small provenance record would have let us connect the observed deployment to a particular source revision.

How do I configure a local model?

ScopeWeaver documents a native Ollama path: open LLM → New → Configuration template → Local inference (Ollama). Use http://127.0.0.1:11434 when both processes run on the host, http://host.docker.internal:11434 when the app runs in Docker and Ollama runs on the host, or http://ollama:11434 for its bundled Compose service. Select an installed model; leave the key blank unless your own proxy requires a token. These are deployment-dependent addresses, not three equivalent localhost aliases. Pinned setup guide.

The template starts with a 32K context and one concurrent request. Choosing it discovers model metadata; it does not download a model or save and activate the profile. Run the connection test, then save and activate the intended profile. The native adapter sends the context setting to Ollama; the runtime also uses it for compaction. A successful connection establishes reachability and a model response. Evaluate tool use and evidence quality on a small authorized lab task before increasing concurrency or context. Context controls, runtime policy.

What data reaches the model, and does “local” mean offline?

The native adapter constructs requests containing system instructions, conversation text, tool calls, tool-result text and tool schemas. If target material appears in a tool result included in the conversation, that material can reach the selected inference endpoint. That conclusion follows from the request-construction code; it does not require full LLM recordings to be enabled.

ScopeWeaver's optional SCOPEWEAVER_LOCAL_LLM_ONLY=true policy restricts LLM connections to loopback or explicitly trusted CIDRs. Its network client checks the socket destination. A Docker or LAN inference server therefore needs its actual reachable address allowlisted; a service name alone grants no trust. The documented policy also blocks web search and remote updates, while target tools remain connected. Policy and deployment guidance.

There is a second boundary at the inference server. ScopeWeaver's bundled Ollama service sets OLLAMA_NO_CLOUD=1. A host or remote Ollama needs its own cloud setting checked; the application cannot establish what that server forwards. Ollama documents this switch as disabling its cloud models and web search. Ollama FAQ.

How do I limit work and account for cost?

For BaaRai, the four controls are ARTEX_TASK_BUDGET_TOKENS, ARTEX_TASK_BUDGET_TURNS, ARTEX_INTENT_BUDGET_TOKENS and ARTEX_INTENT_BUDGET_TURNS. Unset, zero or invalid values mean unlimited. Configure positive limits deliberately and verify the effective environment. This is process-local accounting, so a restart begins a fresh ledger. Budget parsing and storage.

A small cap can also explain a run that launches no worker: admission checks remaining capacity against an estimated worker cost and reserves capacity for wrap-up. The initial estimate is 50,000 tokens and ten turns, clipped to the configured intent cap; later estimates use completed workers. That is admission policy, not a promise that each worker costs that much. Constants, dispatch decision. Use DITING's durable reservations and Pojun's deadline-extension behavior in the control comparison to decide which stopping semantics you need.

For measurement, separate metered calls, provider charges, and human review time. The reference stores usage by task, model, profile and status, separately from request/response recordings. Writes are best-effort, so the ledger is useful for attribution but is not an authoritative bill. Usage schema, write path.

Inspect recorded usage · read-only SQL template

This original query matches the reference schema. Replace the placeholder with your task ID and use read-only database access. Grouping by status keeps error rows visible.

SELECT model, status, COUNT(*) AS metered_calls,
       SUM(input_tokens) AS input_tokens,
       SUM(output_tokens) AS output_tokens,
       SUM(cache_read) AS cache_read_tokens
FROM llm_usage
WHERE task_id = 'YOUR_TASK_ID'
GROUP BY model, status
ORDER BY model, status;

ScopeWeaver documents that its cache counts are included in input tokens and reasoning counts in output tokens; adding those categories again double-counts usage. Its task view also excludes rows without a task tag, including report-writer rows. Reconcile task totals with the wider run window and provider records before assigning a dollar cost. Accounting notes.

What should I review before calling a finding valid?

The observed task gives a concrete answer: completion, graph confirmation, finding disposition and retest records are separate states. Our proposed review workflow is to open the finding record, follow its bound traffic and artifacts, and compare each claimed precondition and impact with what was actually captured. Record duplicates and missing evidence explicitly. Arrange an independently reviewed reproduction when it is necessary and authorized, then record the disposition and rationale. A graph label or an automated shadow verdict can help route that work; neither supplies a human review record by itself.

For evaluation, count accepted, non-duplicate findings separately from generated findings. Keep failed and zero-result runs in the cost and time totals. Measure review minutes as well as agent runtime. This makes “useful result” an explicit criterion rather than a synonym for “the task finished.”

What must survive an upgrade or rebuild?

In BaaRai's Compose layout, the database, data/, keys/ and skills/ are separate persistence concerns. Its backup script dumps PostgreSQL and optionally archives data/; --with-data does not include keys/ or custom skills. Mounts, backup implementation.

Preserve the configured secret-encryption key separately with suitable access controls. The branch's backup instructions explain that encrypted database secrets require that key to restore; deployments can supply it through ARTEX_SECRET_KEY instead of a key file. Include custom skills and configuration in the recovery plan, and rehearse a restore into an isolated environment before upgrading. This is a recovery recommendation based on the storage layout; we did not perform a restore. Backup and key documentation.

Map the differences across descendants

Several Starlog articles return to the same design questions. Its ARTEX-ymh and LuaN1aoAgent pieces emphasize graph state and evidence. The ScopeWeaver and Decepticon pieces ask where scope, tool execution, and isolation actually apply. The failsafe ARTEX piece raises release and deployment trust. LuaN1aoAgent and Decepticon are comparison peers, not verified ARTEX source descendants. These are themes from published articles; their particular technical assertions are not imported as proof here.

The graph below connects five source-reviewed ARTEX branches to the decisions visible in their pinned source. An edge to a topic means that branch implements a relevant mechanism. It does not imply that the feature is on by default, complete, or superior.

Five ARTEX descendants, four design decisionsRelationships connect shared design to reviewed mechanisms; this is not a reconstructed ancestry tree. Five ARTEX descendants, four design decisions Relationships connect shared design to reviewed mechanisms; this is not a reconstructed ancestry tree. Shared ARTEX design graph + planner + workers BaaRai / ARTEX in-memory task budget DITING DB token reservation RuoJi6 / ARTEX MCP token scopes ScopeWeaver local-model context policy NiuDao shadow evidence checks Execution limits memory vs durable admission Access delegation scope checked at tool call Model runtime context and compaction Evidence checks saved artifacts, shadow verdict
Knowledge graph: five reviewed descendants connect a shared ARTEX design to four decisions. The lines do not establish parent-child ancestry.

Where an agent can be stopped

BaaRai's optional target gate blocks when its rules or exemptions cannot be read. Its guard also checks target scope even if a user interception rule otherwise permits a call. The source documents an important limit: exact or fuzzy URL rules can miss alternate encodings or constructed URLs. For an operator, the immediate action is to enable and inspect the gate when relying on it. Its coverage of every network route was not established here.

Pojun shows why a stop condition needs more than a prompt review. Its autopilot server path can extend a task deadline and suppress idle, coverage, and planning-round finish reasons when autopilot is enabled. For an operator, a configured deadline must be read together with the autopilot policy: the inspected source allows that deadline to move. We did not execute this behavior.

The two budgets are similarly distinct. BaaRai's ledger exists only when configured and starts afresh with the process. DITING's reservation path locks a task budget row, checks used plus reserved tokens, and inserts a call reservation before committing. These abridged, non-runnable excerpts illustrate storage and admission. Fields, SQL columns, and surrounding control flow are omitted:

// BaaRai: one ledger per task, held in this process.
type BudgetLedger struct {
    task, intent Budget
    mu           sync.Mutex
    spent        Spend
    // Other fields omitted.
}
-- DITING: admission and reservation inside a transaction.
SELECT ... FROM task_budgets WHERE task_id=$1 FOR UPDATE;
INSERT INTO task_budget_calls(task_id,reserved) VALUES($1,$2);

The relevant call paths are easier to compare side by side. DITING’s provider wrapper reserves before calling the model; its estimate is explicitly separate from provider billing.

Four branches, four control pathsEach row is an independent source path. These mechanisms do not form one combined system. Four branches, four control paths Each row is an independent source path. These mechanisms do not form one combined system. MCP client requests an action RuoJi6: scope check token checked on invocation MCP handler runs if permitted Model request observed provider wrapper DITING: reservation database token admission Model provider called after admission Guarded tool call session gate must be enabled BaaRai: target gate evaluates declared targets Tool execution continues if permitted Saved evidence artifact and traffic claims NiuDao: local checks recomputes selected assertions Shadow verdict finding status unchanged Source presence does not establish default enablement, complete coverage, or runtime effectiveness.
Architecture: four independent control paths, rather than one combined pipeline. RuoJi6 gates incoming MCP actions; BaaRai gates agent tool calls.

Who can steer it

RuoJi6 adds MCP tokens with read, task-create, and task-control scopes. The server filters tools it advertises and checks scope again when a tool is invoked. The invocation check matters because a client may already know a tool name even when it is hidden from the advertised list. These scopes govern what an MCP client may ask ARTEX to do; target scope governs where ARTEX may act. This abridged branch retains the decision point:

case !token.HasScope(tool.Scope):
    result = actool.Errorf(/* denied */)
default:
    result = s.runMCPTool(ctx, tool, token, args)

Its schedule API exposes schedule-management operations, making token issuance and schedule review operational questions. Other branches address identity in different layers: MoLeft adds passkey credentials, while AntiFox defines role and module permissions. In AntiFox's route-permission mapper, an unmapped route passes through that RBAC layer. That is a source observation, not a demonstrated access-control failure; other middleware and route checks were not exhaustively reviewed.

What counts as proof

The shared graph stores findings, but a stored conclusion is only as useful as its evidence path. The sharenjun branch's goal-evidence admission check rejects inferred or incomplete results in the goal-proof commit path, while explicitly leaving semantic sufficiency for independent review. NiuDao's shadow verifier locally recomputes selected artifact and captured-traffic assertions. The inspected verifier checks saved data without issuing target requests. Its shadow runner persists a separate verdict, leaving finding status and human-review records untouched. This simplified type shape shows the intended distinction between a contradiction and missing evidence:

type CheckResult string // "pass" | "fail" | "unknown"
type VerifyVerdict struct {
    Verdict string
    Checks  []Check
}

ARTEX-MUTANT addresses a different part of the evidence trail. It hashes terminal tool decisions into a chain and checks the stored sequence. Its mutex protects one process; the verifier has no external checkpoint against which to detect a deleted tail or a fully recomputed chain. It does not establish tamper resistance against a database writer. These mechanisms answer different questions: whether a goal may be marked done, whether a claim matches saved artifacts, and whether a simple edit to a decision log is detectable.

What changes at runtime

Some descendants shift the model environment rather than the security boundary. artex-global adds output-language selection. ScopeWeaver's prompt normalization changes recognized stock templates while leaving other text alone, and its Ollama context policy adjusts output and compaction for smaller context windows. Its compactor tries to retain matching tool calls and results. For a local-model evaluation, these settings determine how much context can be carried between steps. The setup guide above explains how to configure the native path.

At the edge of the lineage, ARIA-X has a Python orchestrator with runs, tools, budgets, and workers. Its README describes an independently implemented Python runtime inspired by ARTEX, Cairn, and PentAGI. We classify it as a conceptual derivative, rather than a Go source fork. Conversely, BRTEX's default same-provider retry change changes one specific policy: the reference defaults of two retries and exponential backoff become ten retries with a fixed ten-second interval. Configuration can override these defaults. This alone does not establish better reliability; it may also increase waiting time.

Questions to answer for your deployment

The remaining choices depend on your targets, organization and success criteria. Use this short list when evaluating a branch:

  1. Scope and authority: Which targets, accounts and actions are allowed, and who can approve exceptions or stop a run?
  2. Data handling: Which inference endpoints and storage locations may receive target content, and how long may prompts, traffic and credentials remain there?
  3. Model and budget: Which model, context size and hardware fit your workload, and what limits will you set on spending, elapsed time and human review?
  4. Success criteria: What counts as a useful, independently validated result compared with your current workflow, including missed cases, duplicates and failed runs?
  5. Adversarial behavior: What lab evidence will you require that target-controlled content cannot redirect work beyond your chosen scope and approval boundaries?
  6. Ownership and recovery: Who maintains the chosen revision, checks license obligations, reviews updates and proves that backups restore?

A small repeated lab comparison can answer these for your team: hold the target snapshot, task, credentials, model and budget constant; reset target state between runs; preserve failures; and have an independent reviewer judge the results. The code differences in this article tell you what to configure and inspect. Your evaluation establishes whether that configuration is useful in your environment.

Branch notes and research method

Open the six deeper-reviewed branches · controls, runtime, and audit
Descendant and reviewed commitDistinctive code in this snapshotWhat that means for an operator
BaaRai/ARTEX · Starlog analysisTarget gate and in-memory run budgetsBoth mechanisms are disabled unless configured; full route coverage was not established
RuoJi6/ARTEXScoped MCP tokens and task schedulesMore automation and a larger access-management surface
jiwoochris/artex-global · Starlog analysisOutput-language wiringThe cited output-language mechanism is one inspected change, not a summary of the whole branch
cskwork/scopeweaver · Starlog analysisLocal-model context handling and prompt localizationA more extensive runtime branch than a translated UI
AntiFox-AI/antifoxRole/module permissions and route mappingTeam access controls; unmapped routes pass through this RBAC layer
Braedach/ARTEX-MUTANT · Starlog analysisHash-chained tool decisionsSingle-process append serialization; no external integrity checkpoint in the inspected verifier
Open twelve additional source comparisons · narrower file-level review
BranchCode observed at the reviewed commitComparison with the shared starting point
sharenjun/ARTEX-mainGoal-evidence admission rejects inferred or incomplete proof.Adds a deterministic gate before a goal is promoted; semantic sufficiency still needs human review.
MoLeft/ARTEXPasskey authentication introduces WebAuthn credentials.The inspected path concerns account access; it does not establish the scope of all branch changes.
Ernket/CodeScan-ArtexJava dependency decompilation runs a local subprocess with a timeout and heap cap.Adds a Java dependency-analysis mechanism; this is not a full assessment of its source-review capability.
bluechips-zhao/DITINGTask token reservations lock a database row and persist reservations.Offers a different budget boundary from BaaRai's in-memory counters; neither code path alone proves end-to-end cost control.
willsurpass/WSARTEX · Starlog analysisFactory reset requires the caller to stop other writers and checks for other database clients before clearing application tables.An operational reset path, not evidence of improved testing effectiveness; reset behavior was not executed.
IcebergN2026/artex-ld · Starlog analysisTask topology relations require a fact or finding reference belonging to the task on this write path.This path is restricted to the internal-pentest task category; reference existence is not semantic proof of a relation.
wufufu770/reArtex · Starlog analysisSeparation-of-duties context distinguishes worker intents from planner and chat calls.The context reader returns an empty managed scope for calls without a worker intent; full policy enforcement was not traced.
digital-pickles/NiuDao · Starlog analysisLocal evidence verification recomputes selected artifact and traffic claims in shadow mode.Adds checks without sending requests or changing finding state.
ThanatosXingYu/BRTEX · Starlog analysisSame-provider retries rise from two to ten, with a fixed ten-second interval.A default retry-policy difference; it is configurable and has not been benchmarked here.
chu0119/Pojun · Starlog analysisAutopilot guidance is conditional; the server also extends deadlines and suppresses selected finish reasons.Autopilot changes execution lifecycle as well as prompts. Treat its effective stopping policy as a separate evaluation question.
Xiao1an/ARTEX-God · Starlog analysisAsset collections expose explicit FOFA-synced target sets.The inspected asset-collection API is a concrete change; this review makes no claim about the rest of the engine.
01NGVI-QINGYI/ARIA-X · Starlog analysisA Python orchestrator initializes run, tool, budget, scope and worker state.An ARTEX-inspired conceptual rebuild, not a Go code fork; file-hash comparison with ARTEX would be meaningless.
Research method and limits · source snapshots, lineage, and article boundaries

Public GitHub source archives were downloaded on 16 November 2026. We inspected source without building or running the application snapshots. For three branches, we additionally resolved Compose configuration using a minimal environment and a dummy database password; no containers were started. Every cited file was separately fetched at its pinned commit and compared byte-for-byte with the inspected copy. A valid link verifies provenance, not the meaning or completeness of a claim. Non-test, first-party Go files were compared by relative path and SHA-256 against the Hinln snapshot; vendored code was excluded. This helped select files for human review and is not a quality or lineage metric. The Python rebuild was inspected separately. Cairn was inspected at commit 8e7e0ea67552383851dfcabfba0c4e9c8d007878 for architectural context; it is not counted among the 18 descendants. We recorded 49 candidates from the ARTEX.sh catalogue; 31 entries outside the selected set still need source review.

The Starlog articles linked above provided editorial questions, not evidence for our code claims. In particular, Starlog's current “Cairn” article points to cairn-framework/cairn, while the Cloudflare comparison concerns oritera/Cairn; that article is excluded here. README claims and Cloudflare traffic observations were not independently reproduced. Three static diagrams and the interactive loop summarize reviewed source. The observed-case diagram is an anonymized subset of database relations from the separately described deployment. The ScopeWeaver code graph is a separate generated navigation aid with reviewed annotations. None of these graphics establishes deployment topology or proves that every execution path was traced. Private target names, addresses, credentials, payloads and evidence bodies were excluded from the case study; the underlying private records are not a publicly reproducible benchmark.