Tracker: Move the laptop data plane to Praxis when the upstream gaps close #1714

Follows #1437 (assessment and prep, closed) · laptop only · stays open until the switch is complete

Summary

This issue tracks the move of the laptop data plane from Cortex's Go proxy to Praxis. It holds the end state, the phases and their triggers, the work (sub-issues), the upstream asks, and the decisions made on 2026-11-07. The design is #1717.

#1437 assessed the move, and its prep sub-issues (#1497–#1504) are closed. Its migration tracker moves here, updated on 2026-11-07.

End state

Cortex is one Rust binary built on the Praxis crates, in the shape of praxis-ai today. It has three layers:

• Praxis core: CONNECT, decryption and the dial.
• Cortex's own filters: attribution, parsing, recording and pricing.
• Cortex's own store, and the session API served by filters.

There is no Go service. agentop stays a Go client and does not change: the session API contract (docs/session-api.md, the golden fixtures, schemaVersion) is the boundary at every phase.

Each capability row below has three states:

• Go only: Cortex's Go code does it, as today.
• Rust port passes parity: the Rust version in the binary gives the same results as the Go version on the same saved test cases.
• Rust only: we delete the Go copy one release later.

A row moves only on test results, not on belief.

Rule until then: build only what survives the switch. Keep throwaway parts as thin as possible.

Migration tracker

Status as of 2026-11-07. Praxis v0.8.0 is the latest release (2026-11-07). praxis-ai v0.10.0 is built on Praxis 0.7.5. On 2026-11-09, praxis-ai main (de1d372) pins Praxis 0.8.0.

Upstream asks

Plan

The order is A → B → D → C. B, D and C each start only on an upstream trigger: no work on them starts before Praxis upstream is ready (decided 2026-11-10).

A. Now: praxis mode (no upstream dependency). Cortex runs with an empty pipeline. Our own Praxis binary (cortex-gateway: the published praxis-proxy crates plus Cortex filters in Rust) parses each request and records the rows. The rows go back to the Go Cortex through a loopback ingestion endpoint. agentop's observation views work as before: sessions, the timeline, tokens, cost, tool calls and titles. The features that come from plugins stop: agentop server, the script commands, tools scan --write, the plugin pane, savings, and policy denials. Off by default. Praxis mode stays behind --praxis until phase C leaves one network proxy (decided 2026-11-10, criterion C7 on #1725). Built behind the #1491 hairpin on a pinned Praxis v0.8.0. Design: #1717. Work: #1718 to #1725.

B. Trigger: praxis#1479 and praxis#1480 in a release. The hop sends absolute-form requests, and Praxis dials the origin. The egress listener and X-Cortex-Dest go away. Cortex still does CONNECT and decryption. Work: #1726.

D. Trigger: praxis#782 and praxis#1447 in a release (the trigger of C). D runs first, then C. Cortex moves into the binary. (Changed 2026-11-10: users are not asked to use --praxis, so D does not start while praxis mode is only an opt-in. D exists to prepare C, so it waits for C's upstream.) The Go store, archive, timeline, pricing, ledger, session API and attribution (about 13.7k lines) are ported into the binary. They become a Cortex store crate on SQLite, and Rust filters. Attribution moves together with the store, because the store's events feed its state. The Go front door passes the client's socket address in a token-protected header, and the binary does the process lookup itself. The Go tests become parity cases. agentop sees no change. Work: #1727.

C. Trigger: praxis#782 and praxis#1447 in a release, after D. Praxis core takes over CONNECT and decryption. The Go front door and the hop go away, and one binary is left. The client address comes from the connection (#1447). If upstream lands before D is done, C waits for D, so no attribution service is ever built. Work: #1728.

Work

Each row is a sub-issue of this issue. The design is #1717.

Sizing: not estimated for this plan. The 35–52 engineer-weeks on #1437 were for a different design (the Go pipeline linked into Praxis as a C library).

Decisions

Decided 2026-11-07:

• D0. Build the hairpin, for processing and recording in Praxis (praxis mode), not for new checks.
• D1. The store, archive and ledger stay in the Go Cortex until phase D, then move into the binary. agentop does not change.
• D2. Cortex prices at ingestion in praxis mode. A Rust port of the pricing logic follows in the binary. When Praxis Tokenomics is on par, we switch to it.
• D3. Attribution is Rust in the binary from phase D, with its own process lookup. No attribution service.
• D4. Rust filters in our own binary on the published praxis-proxy crates (Praxis's manual registration). Not the Go pipeline as a C library, and not the praxis-ai binary.
• D5. No stop-loss date. The owner of Praxis version bumps is decided later.

Decided 2026-11-09:

• D6. Cortex owns the Rust parsers (option 1 in "Parser ownership"). It is the only option that does not wait for upstream. The goal is that another owner takes the parsers later, for example praxis-ai. Until then, the parity gate keeps the Go and Rust copies in step.

Still open:

• Which remaining plugins (inference-router, tool-prune, script and the rest) are ported or retired. Each one is its own decision. The list must also name lineage, session-budget, litellm-budget-track, token-broker, token-exchange and token-exchange-aiac. They are on main, and the design does not name them.
• Measurable criteria for the soft gates (see "Gates" below).

Review findings (2026-11-09)

Parser ownership

Praxis does not have the parsers that Cortex needs. Read on praxis-ai main (de1d372):

• Inference request (apis/src/anthropic/messages_request, openai/chat_completions/request, openai/responses/request): format, model, stream, max_tokens and has_tools only, plus the Responses ids, store and background. messages_request/mod.rs:168 says: "The parsed body is deliberately not retained." There is no typed message model. The translation filters work on serde_json::Value.
• Inference response (filters/src/token_usage): input, output and total tokens, cache read and write, and reasoning tokens. No gzip or zstd handling.
• MCP (filters/src/agentic/mcp): method, kind, tool name, session id and protocol version. A2A (filters/src/agentic/a2a): method, kind, family, streaming and routing.
• That is about 10 of the about 35 fields of Cortex's InferenceExtension (core/model/extensions.go). Messages, tools, tool calls, tool results, thinking, agentRole, servedModel and the completion have no praxis-ai equivalent.
• The crates praxis-ai-apis and praxis-ai-filters have publish = false.

So Praxis removes the proxy core from our maintenance (phase C), not the parsers. The options:

1. Own the Rust parsers (the current plan). During phase A we maintain two copies, Go and Rust.
2. Contribute them to praxis-ai. This needs U4, and it goes against praxis-ai's stated design of keeping no parsed body. The crates must also be published.
3. A mix: use praxis-ai's token_usage after U6 (gzip), and own only the conversation parsing.

Decided 2026-11-09: option 1 (D6).

Gates

• Inside phase A: the parity gate and the schema drift test are automatic. The live check (Praxis mode 8/8: Run the live check and decide the default #1725) is manual. The criteria for the default decision, C1-C7, are on Praxis mode 8/8: Run the live check and decide the default #1725 (comment). C7 (one network proxy) makes the default wait for phase C.
• A → B: praxis#1479 and [MOCA SBX] Fail closed on hosts that have a credential: never fall back to an opaque tunnel #1480 in a release, plus U11. No one owns the Praxis version bumps (D5), and the triggers for B and C need those bumps.
• → D: praxis#782 and build(deps): Bump github.com/open-policy-agent/opa from 1.21.1 to 1.21.2 in /core #1447 in a release, the same trigger as C. D runs first, then C. The first live run (2026-11-10, Praxis mode 8/8: Run the live check and decide the default #1725) passed C2-C6, apart from one wrong error kind (gateway_refused for a client stop, fixed by fix: Record a client that leaves before the head as client_canceled #1777) and the Codex part of C5 (not run). D does not need B.
• D → C: praxis#782 and build(deps): Bump github.com/open-policy-agent/opa from 1.21.1 to 1.21.2 in /core #1447 in a release, plus U12 and U14, and C waits for D.
• Rollback criteria: the five conditions on Praxis mode 8/8: Run the live check and decide the default #1725 (comment). When one occurs, set praxis.enabled: false and run agentop service install --restart.

Performance (estimates, not measured)

• A Claude Code request line on /v1/ingest is about 7–12 MiB: the parsed conversation plus the base64 capture. Each turn sends the whole conversation again, with no interning on the wire.
• The Go JSON decode is possibly 40–120 ms of CPU per late-session turn, off the latency path. The capture is held in both processes.
• The W1 result (about 0.4 ms p50 above direct mode) was measured in batches, not interleaved.
• Measure the CPU and heap of both processes, and interleaved latency, in Praxis mode 2/8: Build cortex-gateway and the Cortex ingestion endpoint #1719 and Praxis mode 8/8: Run the live check and decide the default #1725.

What phase A throws away at phase D

Five of the eight phase A issues survive without change: #1718, #1720, #1722, #1723 and #1724. The throwaway work is in #1719 (/v1/ingest and the emitter transport) and #1721 (the Go-side joins). The Go front door stays until phase C on both paths.

Other

• The design skips the outbound pipeline in praxis mode. It does not say what happens to the inbound pipeline (for example jwt-validation).

Moved here from #1497

The ingestion endpoint and the cost headers on the response row are now part of #1719.

References

• Proposal: Assess replacing the laptop Go forward proxy with Praxis — blocked on three upstream capabilities #1437 — the assessment, blockers B1–B3, the work breakdown and the sizing
• Spec: Hairpin gateway — run the Praxis filter pipeline on all laptop traffic, with no upstream changes #1491 — the hairpin spec and its W1 results
• Docs: Design praxis mode, where Praxis processes and Cortex records #1717 — the design (praxis mode, and phases B, C and D)
• praxis-proxy/ai — the shape of the end state (one binary on the Praxis crates, with its own filters and store)
• Spike: HTTP CONNECT forward-proxy tunneling praxis-proxy/praxis#781, build(deps): Bump the codeql-action group with 4 updates #782, Docs: Add an Uninstall section to the README #1228, build(deps): Bump github.com/open-policy-agent/opa from 1.21.1 to 1.21.2 in /core #1447, [MOCA SBX] Per-VM Unix-socket listeners handed over at run time (SCM_RIGHTS), with a control channel #1477, [MOCA SBX] Inject into the header the credential declares (Bearer, Basic for git, x-api-key), always overwriting #1479, [MOCA SBX] Fail closed on hosts that have a credential: never fall back to an opaque tunnel #1480, [MOCA SBX] SSRF guard: resolve once, refuse private and metadata ranges, dial the checked address #1484
• Tokenomics: API + Capabilities praxis-proxy/enhancements#35 (Tokenomics 00121), Bump rojopolis/spellcheck-github-actions from 0.36.0 to 0.55.0 #38

Assisted-By: Claude (Anthropic AI) noreply@anthropic.com