+ An effect-aware execution optimizer + actor runtime
+
Optimize the plan. Own the execution.
+
Compile declared tool calls into guarded execution plans. Preserve each call's authority and observable behavior. Let an actor runtime own the workers, workspaces, connections, and recovery.
Logical calls stay intact. Physical work can change.
An optimizer batches, schedules, and reuses certified observations. Each original call retains its admission, budget, result, and receipt. The actor runtime executes the chosen plan.
+
Embedded fast pathPersistent resource brokerExisting isolation backends
A cost model chooses among permitted execution strategies. Use the embedded path for tiny native calls and a broker for reusable workers or clients. Retain Erlang-style ownership and existing isolation backends.
+
+
+
01 / Contracts
Describe the effects
Trusted registrations supply dependencies, resource access, and observable contracts.
+
02 / Optimization
Remove physical work
Batch requests and reuse eligible immutable observations while retaining logical calls.
+
03 / Runtime
Own reusable resources
Actors retain workers and clients under explicit leases, epochs, and reset rules.
+
04 / Effects
Retain evidence
Track what started, what committed, and what remains unknown.
+
+
This is a design proposal, not an implemented compiler or runtime. The local measurement below characterizes a small native transport experiment. The isolated eval target is a working assumption; native macOS execution remains a distinct trusted mode.
+
+
+
+
+
01
The system map
A bounded logical plan describes the requested calls. The host admits each resolved action. The optimizer changes only eligible physical execution; the actor runtime owns resources and recovery.
+
+
Trusted controlTask scopeExisting providers
+
+
+
+
+ Select a component to inspect its ownership boundary.On small screens, scroll the diagram horizontally.
+
+
Proposed / execution planning
Effect-aware execution optimizer
Transforms eligible admitted logical calls into guarded physical work while preserving the declared observable contract.
Each original call retains its authority, budget, result, and receipt.
Trusted effects constrain reuse, batching, scheduling, and executor selection.
Runtime guards recheck resource identity and generations before start.
+
Ownership
Each mutable resource has one owner. The owner serializes state changes and can delegate concurrent I/O.
Isolation
Arbitrary tool code runs in a worker or sandbox. A logical actor in the broker is not a memory isolation boundary.
Portability
Language adapters use the operation contract. Backends report their actual containment and lifecycle capabilities.
+
+
+
+
+
+
02
An effect-aware execution optimizer
Compile declared tool execution plans into guarded physical work. Optimize the operation graph; existing language runtimes continue to execute Python, JavaScript, and shell code.
+
+
Compiler / proposed
Logical plan → physical plan
The intermediate representation (Tool IR) preserves original call IDs, arguments, dependencies, budgets, and result contracts. Trusted registrations supply effect summaries and executor equivalence rules.
The optimizer can share certified immutable computation, group transport, and schedule independent work. It must retain required errors, audit events, effects, and publication order.
Actor runtime / proposed
Resources with owners
The runtime retains workers, clients, and workspaces. It owns admission queues, lifetimes, cancellation, output credits, generation checks, and effect receipts.
Pooling reuses setup. Each required application request still executes. A repeated HTTP GET or SQL query does not become a pure expression because its client is persistent.
02Prepare and admitResolve each action; bind its allowed executor
03Optimize ready workApply only certified equivalent strategies
04Guard and executeRecheck leases, versions, epochs, and budgets
05Project each resultKeep logical receipts and publication intact
+
Planning candidates may precede admission, but planning cannot perform tool effects or mint authority. Initial fx passes stay inside existing admitted execution contracts. A lowering that changes an executor or effective environment must be prepared and admitted through the host. The planner cannot read protected preimages outside the host's existing preparation and read-authority policy.
+
Explore legal and blocked transformations
+
+
Logical requests8
Fresh physical reads6
Reuse decision1 cache + 1 shared
All eight calls are separately admitted against snapshot S0. A valid completed value satisfies r2; r1 and r3 share one certified read. Six fresh reads can use a bounded group. No logical call disappears.
Logical Tool IR / schematic
r1 = snapshot.read(S0, A)
+r2 = snapshot.read(S0, B)
+r3 = snapshot.read(S0, A)
+r4 = snapshot.read(S0, C)
+r5 = snapshot.read(S0, D)
+r6 = snapshot.read(S0, E)
+r7 = snapshot.read(S0, F)
+r8 = snapshot.read(S0, G)
Physical plan / schematic
cache_value(B) → r2
+read(A) → r1, r3
+read(C..G) → r4..r8
+
+6 fresh reads
+8 logical admissions and receipts
+1 bounded group if the cost model selects it
Proof required for immutable sharing
Same immutable input, implementation, result contract, and authority partition. Preserve per-call audit, budgets, error behavior, and cancellation; a required physical audit event may prohibit coalescing.
This is an explanatory simulation, not an implemented optimizer or measured speedup. The fixture assumes compatible contracts, permitted concurrency, and a valid cached value. Grouping and backend choice remain cost-based.
+ Trusted effect declarations and optimization permissions
Effects describe behavior under a trusted implementation contract, not a model's claim about a tool
Proposed structural sketches. Supporting types are placeholders for bounded typed contracts. An agent-cast operation ID remains a logical identity; physical work IDs expose actual sharing. Fixture replay has separate provenance and cannot claim current execution. Budgets count logical calls even when physical work is reused.
+
Initial optimization passes and their guards
Pass
Legal transformation
Guard / stop condition
Completed-value reuse
Return a certified immutable value through the existing renderer
Current authority, input identity, contract, and implementation; a failed guard requires rejection or fresh preparation/admission; cache successful values only
Inflight coalescing
Share one physical read among compatible admitted consumers
Independent subscriber deadlines, cancellation, credits, audit, failure provenance, and retry eligibility; never cache shared execution failures as semantic results
Transport batching
Send compatible calls together without removing their identities
Preserve per-call errors, limits, ordering, and failure policy; do not wait indefinitely to fill a batch
Dependency scheduling
Execute already independent nodes within resource budgets
Keep control dependencies, conflicts, and deterministic write order
Executor selection
Choose a certified native or worker implementation
Stay inside the admitted executor contract; a changed binding requires host admission
Cost-based strategy
Select direct, cached, grouped, or persistent execution where permitted
Include planning, hashing, guards, queueing, projection, and persistence; decline unprofitable passes
+
The compiler must be able to decline optimization. A live read is not an immutable observation; a shell command is not a native read by resemblance; an unused result does not erase a requested action. Unknown effects remain barriers.
+
Compile fixed plans and currently ready graph segments. Dynamic arguments require preparation and admission after their inputs arrive. Arbitrary Python or JavaScript orchestration runs in its admitted runtime; the pre-admission planner does not execute or statically understand arbitrary code. MCP tool annotations also require a trusted source; annotations alone do not establish purity.
+
+
+
+
+
03
A call has more than one outcome
Admission, completion, cancellation, and committed effects are separate facts. An operation can be cancelled after it has changed external state.
+
+
queued→running→settled
+
+
+
01 / 07
Admit the exact operation
The host binds arguments, workspace, environment, and authority to the operation identity before invoking the broker.
Persist the known result before publication. A reconnect retrieves this operation's receipt without repeating its mutation.
The walkthrough is an explanation. It executes no tools. The receipt always shows the scenario's terminal state, independently of the selected event.
+
+
call, cast, monitor
Use tracked calls for effects, notifications for events, and monitors for lifetime changes. An unacknowledged cast is not a durable mutation API.
Same operation, same identity
Bind identity to the principal, tool implementation, exact arguments, and task/workspace lease. Reconnect queries that operation. Reject reused IDs with different bindings; retries do not automatically authorize repeating an effect.
Bounded data movement
Length-framed JSON-RPC control travels over a persistent local Unix socket. Negotiate a maximum frame size and reject oversized frames before allocating. Separate output transport uses byte credits, sequence numbers, quotas, and artifact handles.
Deadline and cancellation
Queue time consumes the execution budget. Reconnect cannot extend the stored deadline. Cancellation acknowledgement means observed; a terminal receipt describes effects.
Durability by operation class
Persist recovery-relevant intent before dispatch. Cheap reads can use ephemeral receipts; syncing every read could dominate its execution time.
Uncertain external effects
A service may commit before a worker loses its reply. Reconcile through an idempotency key or service evidence. Infrastructure restart alone cannot prove exactly-once effects.
+ Proposed invocation envelope and authority checks
Schema sketch, not an implemented API. Enroll the harness through an authenticated control channel. Keep authority issuance outside tool workers; keep privileged descriptors and credentials outside arbitrary agent code. Recheck policy, credential, workspace, and implementation generations before start. Revocation stops future grants; an already released operation may still perform an effect.
Erlang contributes ownership, messages, monitors, and supervision. Restart policy describes resource recovery; retry policy describes whether work may be performed again.
+
+
Proposed supervision tree
runtime_supervisor
control_ownersRouting, plan templates, caches, ledger; bounded reconstruction
service_supervisors
http_client_ownerPool scoped by endpoint, principal, and configuration
database_session_ownerTransaction ownership; drop uncertain connections
task_supervisor
workspace_ownerAuthority loss stops dependants and quarantines state
command_jobTemporary; do not restart an effect automatically
Explore a failure
What should restart?
A control actor can reconstruct state. A failed tool operation can require reconciliation even after its worker has been replaced.
Select a failure boundary
Logical actors share a native process. Their ownership rules do not create BEAM-style memory isolation; a native fault can still terminate the broker.
+
Cooperative stop
Stop admission, request cancellation, and allow bounded cleanup.
Forced stop
Terminate the owning process or containment domain after grace expires.
Fencing
Invalidate old actor epochs and leases before replacement state is published.
Restart limits
Apply a bounded restart budget and backoff. Repeated failure quarantines the resource.
+
Actors are state machines, not one OS thread each. Keep trusted bookkeeping bounded; delegate blocking I/O. Unknown native plugins belong outside the broker process.
+
A Zig implementation would not inherit BEAM's preemption, garbage collection, or process isolation. Choosing Zig supports integration with fx; this research does not establish BEAM as a performance bottleneck. Erlang process efficiency.
+
+
+
+
+
05
Reuse needs a validity contract
Persistent resources avoid setup work. Cached observations avoid repeated computation. Both require current authority and an explicit consistency boundary.
+
+
Eligible: immutable inputs
Snapshot reads and search
An immutable snapshot gives a stable input identity. Cache file bytes, directory listings, or search results against that identity.
Identity
snapshot digest + tool version + exact arguments + options
Validity
The snapshot and implementation are unchanged; the caller still has authority to read the result.
Boundary
A write produces a different revision. A live checkout cannot silently stand in for an immutable snapshot. Reused values pass through each call's current renderer and receipt.
Benefit
Reuse search/index work and coalesce identical reads without repeating shell or interpreter setup.
+
01 / Resource reuse
Retain setup
Keep a permitted worker or client alive. Its state remains explicitly owned.
02 / Memoization
New call, cached result
Issue a new receipt after current admission and input validation.
03 / Receipt lookup
Same call, old outcome
Recover the existing operation without repeating its effect.
04 / Fixture replay
Recorded observation
Supply saved data without claiming the effect occurred now.
+ Full cache policy matrix
Proposed first-version reuse rules
Resource
Allowed reuse
Invalidation / boundary
Images, schemas, binaries
Immutable content and implementation metadata
Digest, platform, implementation, or configuration change
Snapshot files / search
Results against immutable input identities
Snapshot, exact arguments, tool version, ignore rules, visibility, or options
Live filesystem
Existing kernel caches; reopen through existing semantics
Watchers are hints. Metadata equality cannot prove unchanged bytes.
HTTP
Persistent clients; response caching under HTTP semantics
Endpoint, principal, credentials, TLS, proxy, policy; freshness and validators
DNS
Established resolver and client behavior
Lifetime, resolver configuration, and network context
Database
Connections under driver/pooler reset contracts
Transaction, session, role, tenant, credential, and configuration state
Shell output
No general result cache
Only declared pure operations with known immutable dependencies qualify
Interpreter state
Within the declared task/session
Fresh-call semantics, worker epoch, task ownership, and reset qualification
+
A previous write receipt cannot satisfy a write in a fresh eval workspace. The operation may be recorded as successful while its effect is absent from the new environment.
+
Networking reuse requires a protocol-aware owner. A new shell-launched client cannot transparently borrow another process's HTTP connection. A CONNECT tunnel cannot pool arbitrary application sessions. Reuse existing HTTP clients and database pooling contracts.
+
+
+
+
+
06
Batch the work. Preserve each action.
The Tool IR keeps data and control dependencies. The optimizer groups eligible ready work; unresolved actions and effect barriers remain explicit.
+
+ Illustrative graph. Future unresolved arguments cannot be authorized by an earlier graph-level approval.
+
Effect-aware scheduling
Immutable reads can run concurrently.
Workspace mutations hold an exclusive lease.
Opaque execution invalidates mutable derivations before it starts and retains its exclusive lease until contained descendants are quiescent.
Transactions retain their service-session lease.
The trusted registration derives access; model-supplied purity claims do not establish it.
Two optimization tracks
Transport batching preserves individual tool requests and results. Programmatic tool calling lets the model express loops, transformations, and dependencies in code.
Programmatic calling can reduce inference round trips and intermediate context. It changes the model's affordances, so evaluate quality separately from execution latency. Established code-execution pattern.
+
Fresh
Per-call state
Preserve the harness's fresh interpreter promise. Preloading cannot silently retain a previous call's globals, descriptors, or threads.
Session
Task-owned state
Retain imports and state within one task. Worker loss changes the epoch and reports state loss to the caller.
Template
Qualified preparation
Create fresh workers from a tested, uncredentialed template. Fork safety and cloned state require qualification.
+
Whole-workspace exclusion is the initial policy. Reject conflicting batch nodes without explicit dependencies so lock acquisition cannot choose a different write order. Command exit alone does not establish quiescence; cache eligibility returns only against a newly established immutable revision. Fine-grained path locking must account for aliases, symlinks, hard links, mounts, and directory mutations. External editors bypass broker locks, so live host workspaces remain ineligible for immutable-result caching.
+
+
+
+
+
07
A warm environment must still be a clean trial
Use the task or evaluation attempt as the containment boundary. Share prepared infrastructure while giving mutable task state a fresh owner.
+
+
Separate lifetimes
Host scope
Immutable images, executable metadata, artifact content, and warm capacity.
Fence the taskReject new starts and invalidate old leases and epochs.
Resolve outstanding workFinish, cancel, or retain an explicit unknown outcome.
Stop the containment domainRequest graceful shutdown, then force termination after grace.
Verify process drainConfirm descendants cannot keep writing. Process-group termination has weaker guarantees than qualified containment.
Revoke resourcesClose routes, credentials, subscriptions, and task-scoped handles.
Discard owned task stateDispose of runtime-owned overlays and temporary storage. User mounts and external databases have separate lifetimes.
Initialize the replacementUse pinned images, fixtures, versions, environment, and fresh worker identities.
Probe the boundaryCheck prior files, jobs, state, handles, and credentials are absent. Quarantine failed resets.
+
Memory snapshots can duplicate randomness, identifiers, and credentials. Network connections may not survive restoration. Prepare templates before credential injection and retain external client pools outside the snapshotted guest. Firecracker snapshot constraints.
+
Declare the evaluation mode
Reconstruct declared task state and run actual tools. Warm images and permitted pooled clients may remain, but previous trial mutations and cached stateful observations cannot carry over. Measure performance and independently grade terminal effects.
ThinkingBox provides a relevant evaluation pattern: fresh backend state per attempt, repeated trials, terminal-state grading, and checks for extra effects. A deterministic environment does not make model outputs deterministic.
+
+
+
+
+
08
Plug into fx at the execution boundary
The logical plan builder can describe calls before admission. Native optimization and portable execution stay after existing exact-action admission and before result publication. Preserve fx's ownership-bearing contracts.
+
+
ExistingDecode tool
ExistingPermission admission
ProposedGuarded optimizer + adapter
ExistingEffect handoff
ExistingResult publication
ExistingSession persistence
+
Existing SDK seam
Begin with a libfx host tool
The Node SDK invokes a registered tool through execute(input, { signal }). A client can retain a broker connection and translate the signal into cancellation.
Use immutable snapshot reads first. A deterministic provider fixture should generate an actual tool call through libfx, receive the broker result, and complete the turn.
Compare optimizer disabled versus enabled with identical descriptors, calls, and results. Keep per-logical receipts outside model-visible content initially; use the existing renderer for reused values.
Keep fx's existing HTTP pool and cheap native paths. The first passes preserve admitted executor selections. Do not rewrite a shell command into a builtin by inference. Create broker connections lazily; terminal and file-mutation migration need separate reviews.
+
Source review: fx commit c1db919112c5c83fdcc0be508f8d34d189d149af. Relative source links work while the explainer remains in this checkout's docs/ directory.
+
+
+
+
+
09
Measure the work that disappears
Attribute latency before optimizing it. Include plan construction, canonicalization, cache validation, guards, and result fan-out alongside launches, imports, IPC, service setup, useful work, and durable publication.
+
+
Measured / native transport probe
Verified 4 KiB warm file read
Median cost in microseconds per read. Every operation opens, reads, checks EOF, and closes the fixture. Batch cost is total batch time divided by eight.
Direct native
9 µs
Warm native RPC
16 µs
RPC, batch of 8
10.75 µs
Fresh native process
1,128 µs
1101001,000
Logarithmic axis starts at 1 µs. Numeric values are the measured medians.
256 interleaved samples per path. Batch quantiles are full-batch times divided by eight, not individual-call latency quantiles. Full batch: p50 86 µs; p99 102 µs.
Path
p50 µs
p95 µs
p99 µs
Direct native
9
12
13
Warm native RPC
16
20
22
RPC batch, amortized
10.75
12.125
12.75
Fresh native process
1,128
1,315
1,436
Illustrative / Amdahl's law
Execution gain versus total gain
Change the assumed fraction of addressable tool work and its speedup. Other work remains unchanged.
1.18×
20% of time accelerated by 4× leaves 85% of the original runtime.
Baseline · 100%
Candidate · 85%
Other workAddressable tools
speedup = 1 / ((1 − f) + f / k)
A scenario calculation, not an agent-cast performance prediction. Throughput also depends on resource budgets and contention.
+
The native probe excludes JSON encoding, permissions, durable receipts, sandbox boot, and fx. It uses a pre-established Unix stream socketpair and warm file data. It supports retaining direct native paths and targeting launch/batch costs; it does not establish an end-to-end harness speedup.
+ Measurement provenance and portable evidence
Recorded on 6 October 2026 using macOS 26.5.2 arm64, Apple Clang 17, and -O2. All returned bytes were checked. Fixed buffers, process-count bounds, CPU limits, and a wall timeout bounded the run. This host rejected memory resource limits; that failed attempt was retained separately and is not a performance result.
Measurement receipt is embedded in this HTML file.
The receipt and probe source are embedded in the file. They remain available when this explainer is copied elsewhere. No external request is made by the downloads.
+
Strong comparison baselines
Stock fx native operations, warmed terminals, persistent MCP servers, Hermes's existing kernel, pooled HTTP clients, and existing warm sandbox providers.
Account for total resources
Report broker and complete process-tree memory, CPU, guest memory, worker density, pools, cache state, and marginal cost per active task.
Two evaluation tracks
Fixed tool traces isolate execution changes. Full agent trials measure outcome rate, repeated reliability, tokens, and cost with equivalent fresh state.
Charge for optimization overhead
Measure planning, hashing, guard checks, and result fan-out. Keep authorization-to-start dispatch separate from total completion, which includes output and required durable synchronization.
+
+
+
+
+
10
Build on what already exists
Persistent workers, sandbox pools, programmatic tools, and evaluation adapters are established. The proposal must demonstrate useful savings across these existing boundaries.
+
+ Execution providers
DeepSeek Harness
Replaceable providers, canonical tool values, permission boundaries, and declared concurrency provide an integration seam. Its fresh Node program execution must keep fresh semantics when adapted.
Persistent Python kernels and environment plugins already amortize startup. Bounded concurrent tool RPC is a candidate improvement to compare against the existing persistent path.
Reuse lifecycle APIs, execd, warm capacity, and backend adapters. Its experimental client pool hands out fresh prepared sandboxes; acquired sandboxes belong to the caller until destruction.
Public command execution, filesystem operations, output streaming, cancellation, and environment APIs provide another adapter surface. They do not establish this session's internal service architecture.
The joint post on 3 October 2026 is a plausible match to the recent release discussed. Fresh backend state, repeated attempts, terminal-state grading, and extra-effect checks directly inform reset validation.
Repository activity began 4–5 October. The artifact is a Git-backed memory specification and skill/plugin. Cognition's devin-connect is a separate transport gateway; these inspected artifacts do not expose the full Devin runtime.
Reuse existing task orchestration and grader boundaries. Environment and sandbox interfaces are natural integration points for a new execution backend.
The independent study submitted 1 October examines model–harness interactions. Tool affordances and recovery behavior can change agent results, so evaluate code mode separately from transport acceleration. This is not identified as a Hugging Face organizational harness release.
The two recent release identities remain plausible matches to the original references, rather than user-confirmed identities. Research date: 6 October 2026.
+
+
+
+
11
Start with a slice that can disprove the design
Establish equivalent useful work and real interoperability before expanding into a general execution platform.
+
Foundation locally exercised
Implementation checkpoint, 6 October 2026. The standalone Zig 0.16.0 foundation captures actual bytes and preserves ten logical receipts while grouping eight approved reads into four backing reads. A completed-value cache serves four new admitted logical calls from owned values and rejects three unauthorized or stale consumers without output. The refreshed qualification passed 52 tests and exercised both built binaries against two different actual fixtures. Subscriber and framing contracts have unit evidence; real broker clients, supervision, and harness integration remain pending. CI is pending. Follow the milestones, task ledger, model assignments, and prototype instructions.
1
Attribute current costs
Trace current optimized baselines. Separate normalization, admission, useful work, service setup, rendering, and persistence; record logical and physical operation counts.
2
Define Tool IR and trusted operation contracts
Preserve original IDs, arguments, dependencies, result contracts, and budgets. Whitelist immutable fixture reads; default unknown registrations and commands to opaque.
Implement one immutable read executor and current-authority checks. Reuse certified successful values through the existing renderer, with a new logical receipt and explicit provenance.
4
Qualify inflight sharing and bounded batches
Keep independent subscriber cancellation, deadlines, output credits, and audit. Add deterministic scheduling and a cost model that can choose the original direct path.
5
Prove broker and libfx interoperability
Use Python/Node clients and a fixture-driven host tool. Keep descriptors identical. Add one scoped pooled HTTP client while executing every required request.
6
Qualify isolated tasks and failure recovery
Integrate one existing Linux backend. Test clean reset, stale plans/epochs, worker loss, output pressure, and effect uncertainty without automatic replay.
7
Integrate harnesses and profile further passes
Add Hermes/DeepSeek and Harbor/Inspect adapters. Expand certified lowering, service actors, or plan-template reuse only where measurements justify it. Review terminals separately.
Count arenas, queues, stacks, and metadata. Also report workers, pools, guests, and total cost per task; moving allocations elsewhere does not establish efficiency.
Correctness gate
Equal logical calls, outputs, errors, audit, limits, authority, and terminal effects. Test disabled/enabled passes and reject stale reads, unauthorized fan-out, duplicate effects, and state leaks.
Performance gate
Compare warm, persistent, pooled baselines under equal resources. Preserve fx's Linux startup budget through lazy service connection.
+
Disable a pass if effect declarations are unavailable or contradicted, or if planning, hashing, guards, and fan-out erase its gains. Reject improvements based on skipped logical actions, weaker isolation, changed outputs, or stale observations. Use the unchanged fallback only while its exact authority and applicable guards remain valid. Stale authority or generations require rejection or fresh host preparation/admission.
+
The prototype uses fixture-owned admissions and two logical agent identities in one process. Backing read counts refer to captured-content reader invocations, not OS reads or elapsed time. The native transport probe above is a separate experiment. No production fx integration or sandbox qualification has been performed.
+
+
+
+
+
12
The decisions that constrain the build
Keep the first implementation small enough to compare against existing paths and explicit enough to recover from failure.
+
Retain
Effect-aware plan optimization
Optimize certified physical work while preserving logical identities, current authority, error behavior, audit, budgets, and receipts.
Reject
Universal tool-code compilation
Use bounded declared plans. Do not infer purity, replace shell semantics, or execute arbitrary model-authored code during planning.
Retain
Embedded native operations
The local probe shows IPC overhead on tiny reads. Existing fx operations can keep their direct execution path.
Retain
Optional persistent broker
Own cross-language workers and clients where batching or retained setup repays dispatch cost.
Reuse
Existing packaging and containment
Use OCI, backend SDKs, and qualified container or VM services. A new VMM is outside the initial scope.
Reject as default
MicroVM per tool call
Lifecycle, control-channel, filesystem, and memory costs belong at a task boundary unless measurements justify finer isolation.
Reject
Transparent syscall memoization
Arbitrary commands depend on mutable files, clocks, randomness, credentials, services, and process state.
Defer
Shared-memory transport
Ownership, crash reclamation, and tenant separation add cost. Profile socket copying and framing before adding it.
Reject
Automatic uncertain-effect retries
Restart infrastructure and expose uncertainty. Repeat an effect only under an explicit eligible retry or reconciliation contract.
Defer
Native fx terminal migration
Review ownership, input authority, recovery identity, cancellation, output drainage, and publication before moving terminals.
+
+
+
+
13
Sources & evidence
Primary references support the existing capabilities and constraints. The proposed architecture and engineering budgets are design judgments.