Dev & Engineering team-contextsession-memorycross-agent-recallcontext-injectionsession-recordingsecret-redactiondeveloper-coordinationcoding-cli

SageOx CLI

Shared, persistent engineering context across coding agents, machines, and teammates.

FollowAgents review · FARS-2.1
Use with care
71/ 100 5-point scale 3.6 / 5
1 2 3 4 5 6
Per-dimension scores and reasoning
1Trust18 / 29 · 3.1/5

The README thoroughly discloses capture of prompts, responses, tool calls, paths, diffs, and outputs, along with the local cache, sageox.ai-hosted ledger, team visibility, default recording, and publishing controls. User-level configuration takes precedence and offers manual or disabled modes, while CI declares read-only contents permission. However, automatic recording and publishing are defaults rather than per-session confirmations, and disabled mode still permits explicit manual capture. Secrets are pattern-redacted locally before upload, but the documentation expressly warns that .gitignore is ignored, nonstandard secrets can escape detection, and cached sessions have no TTL. Dependency versions are declared and CI actions are commit-pinned, but the dependency surface is large and the supplied evidence contains no vulnerability scan, update policy, or go.sum. Upload effects are clearly described, yet uninstall cannot remove already-synced sessions, limiting rollback. The MIT copyright holder and a credits path provide attribution, although publisher identity remains unverified and the full third-party credits were not supplied.

2Reliability8 / 14 · 2.9/5

The README says ci.yml is disabled and only documentation and smoke workflows are active, while the supplied .github/workflows/ci.yml is an enabled, comprehensive build, test, and lint workflow. This material inconsistency limits self-consistency. Dependencies and build entry points are clear, with Linux, macOS, FreeBSD, and some Windows coverage, but the central shared-history function depends on sageox.ai and has no self-hosted or local-ledger substitute. Offline caching, retry behavior, doctor/status diagnostics, and explicit integration-test pass, fail, and skip messages support ordinary failure handling; the main command implementations were not supplied for a complete error-path review.

3Adaptability15 / 18 · 4.2/5

The evidence clearly targets human and multi-agent engineering teams, enumerates querying, capture, coordination, planning, and expert-loading scenarios, and distinguishes shipped from planned compatibility. Configuration precedence, personal overrides, and the distinct recording and publishing meanings of manual are documented. Per-agent trigger mechanisms are listed and the coworker test uses domain descriptions, but its autonomy check requires an optional live Claude invocation plus a reinforcing system prompt, so precise triggering in normal environments is only partially substantiated. Platform and agent coverage is broad, although Claude Code is expressly the primary and most-tested target and equivalent maturity elsewhere is not demonstrated.

4Convention15 / 18 · 4.2/5

The README has strong information architecture covering installation, quickstart, capture, configuration, compatibility, and contribution. Installation alternatives, verification, and the risk of building HEAD are well documented. Command naming is generally coherent, but manual means different things for session_recording and session_publishing and requires a special warning. Examples are extensive, and limitations are candidly stated: no self-hosting, no cache TTL, no fine-grained session privacy, and no .gitignore protection. The complete MIT license justifies full credit. Versioning evidence is limited to a release badge and upgrade command, with no supplied changelog or compatibility policy. SageOx Inc., the issue tracker direction, and contribution instructions establish a maintenance route, but named maintainers, service expectations, and governance are absent.

5Effectiveness10 / 13 · 3.8/5

The command-oriented interface, diagnostics, structured test artifacts, and multiple agent entry points appear usable for ordinary workflows, but no representative query outputs, context-quality controls, or handling of bad retrievals are shown. Persistent context shared across agents, machines, and teammates offers clear marginal value over isolated sessions and supports recall, coordination, and planning. Costs and controls are partly disclosed, but full-conversation capture, mandatory hosted storage, indefinitely retained local cache, and team-wide readability impose privacy, storage, and operational costs that are not quantified.

6Verifiability5 / 8 · 3.1/5

Many central claims map to named commands, configuration keys, architecture references, or reference-document paths; the workflow and integration script also corroborate build gates and coworker loading. Cross-source support is meaningful but incomplete because core implementations, secret patterns, go.sum, test results, and linked documentation were not supplied, and the CI-status contradiction remains unresolved. The README generally separates shipped, planned, and unavailable capabilities, yet promotional outcomes are mixed with factual claims, and the autonomous-use test relies on extra prompting, so fact-inference separation is adequate rather than thorough.

Evidence confidence: Low Reviewed Sep 17, 2026 Reviewed revision 31eef641d245
The upstream repository has new commits since this review. The score still applies to the reviewed revision shown and may not cover the latest changes.
Before you use it
  • Complete agent conversations are recorded and published automatically by default; set both session_recording and session_publishing explicitly before organizational deployment.
  • Redaction is pattern-based and does not honor .gitignore; agents should not be directed to read .env files, credential stores, or nonstandard secrets that must not be uploaded.
  • Already-synced sessions are not removed by ox uninstall, and there are no fine-grained per-session access controls; verify server-side retention, deletion, and team-membership policies before adoption.
  • The shared ledger must be hosted on sageox.ai, with no current self-hosted or local-only option; assess outage exposure, vendor dependency, and data-residency requirements.
  • The README and supplied workflow conflict about whether CI is enabled; confirm the actual workflow state at this revision before relying on its release-quality signals.
Review evidence [1][2][3][4][5][6]
See the full review method →

What does this agent do, and when should you use it?

SageOx CLI (`ox`) is an open-source Go command-line application that preserves and reuses project context across coding agents, computers, and team members. It associates a repository with a team through `.sageox/`, while `ox agent prime` injects conventions, security requirements, architectural decisions, and previous sessions into a new agent session. Session capture records prompts, agent responses, tool calls, and their outputs, writes them first to `~/.cache/sageox/`, and then synchronizes them to a team Git history hosted by sageox.ai, with content stored as LFS blobs. Teams can search that history with `ox query`, coordinate through `ox murmur`, and incorporate prior work, contention, and code insights into plans using `ox plan enrich`, `ox plan render`, and `ox code insights`. It supports several coding-agent products, but there is currently no self-hosted or local-only ledger, making sageox.ai the deployment boundary for shared history.

ox init creates .sageox/ in a code repository and connects the project to its team; ox agent prime then loads team conventions, decisions, and earlier sessions before an agent begins work. Session capture records user prompts, agent replies, commands, files read or written, and tool outputs. A local scanner replaces recognized secrets with [REDACTED_*] markers before storage or synchronization. Records are staged in ~/.cache/sageox/ and uploaded to the shared team history on sageox.ai; failed or offline uploads remain cached and can be retried with ox doctor --fix. Users can search cross-agent history with ox query "...", send live coordination signals with ox murmur "...", and produce planning material informed by previous decisions, hotspots, and possible collisions through ox plan enrich, ox plan render, and ox code insights. Recording and publishing behavior is configured with ox config, while ox session start, ox session stop, and ox session upload provide manual controls.

  1. A development team using both Claude Code and Codex CLI wants each new session to inherit decisions and implementation history created in the other agent.
  2. Engineers working from multiple machines need to find who made an architectural decision, where it was discussed, and what implementation context already exists.
  3. Several teammates are changing the same repository concurrently and want coordination signals plus warnings about overlapping files, prior approaches, and area ownership.
  4. A technical lead preparing an implementation plan wants recent discussions, recorded sessions, and code hotspots included through ox plan enrich.
  5. A team wants automatic capture of coding-agent conversations while having common credential patterns redacted locally before upload.
  6. An organization reviewing its data boundaries wants manual or disabled capture and the option to hold completed sessions locally until an explicit upload.

What are this agent's strengths and limitations?

Pros
  • The same context layer works across documented integrations including Claude Code, Codex CLI, Gemini CLI, Droid, OpenCode, Amp, Pi, Aider, and Goose, reducing context fragmentation when teams change agents.
  • It captures implementation evidence—not just summaries—including prompts, responses, tool calls, file paths, and diffs exposed in the agent conversation.
  • Recognized cloud keys, service tokens, private keys, connection strings, authorization headers, JWTs, and similar credentials are scanned and redacted locally before upload.
  • Offline caching and retry through ox doctor --fix reduce the risk of losing sessions, while recording and publishing have separate controls.
  • Search is complemented by live murmurs, plan enrichment, and code hotspot or contention insights for concurrent engineering work.
Limitations
  • There is no self-hosted or local-only ledger; shared history must reside on sageox.ai, and enterprise self-hosting is not currently available.
  • Automatic recording is enabled by default and includes commands, file interactions, and tool outputs visible in the conversation, creating a data-governance review requirement.
  • Capture does not honor .gitignore; secrets in unrecognized formats can evade redaction, so agents should not be directed to sensitive credential files.
  • Recorded sessions are visible to teammates who can access the shared history, with no finer per-session privacy control other than not recording that session.
  • Cached sessions have no TTL or automatic pruning, and ox uninstall does not remove sessions that have already synchronized.
  • Integration maturity varies: Claude Code is identified as the primary, most-tested target, while recording for Cursor, Windsurf, Cline, Copilot, and Kiro is only planned.

How do you install or deploy this agent?

On macOS or Linux, run brew install sageox/tap/ox. On macOS, Linux, or FreeBSD, the documented install-script path is curl -sSL https://raw.githubusercontent.com/sageox/ox/main/scripts/install.sh | bash. Contributors can run git clone https://github.com/sageox/ox.git && cd ox, followed by make build && make install; this builds a less-tested bleeding-edge version that does not self-update. Verify the installation with ox version. Initial use requires network access to sageox.ai and a SageOx account.

How do you use this agent?

From the target Git repository, run ox login to authenticate with sageox.ai, ox init to create .sageox/, and git add .sageox/ && git commit -m "initialize SageOx" to commit the project metadata. Then run ox doctor to diagnose the setup and ox status to inspect authentication, project, synchronization, and daemon state. At the beginning of an agent session, run ox agent prime to load team context. New sessions in an initialized repository record automatically by default; use ox query "your question" to search history or ox murmur "message" to coordinate. Run ox config to choose the auto, manual, or disabled recording mode. To record without publishing automatically when a session stops, run ox config set session_publishing manual, then publish explicitly with ox session upload.

FAQ

Can the shared history run entirely locally or on company infrastructure?
No. The current version always hosts shared history on sageox.ai and provides neither a self-hosted nor a local-only ledger. The local cache is only a staging and retry mechanism.
What is recorded by default?
New agent sessions in an initialized repository are automatically captured, including prompts, agent replies, tool calls, commands, files read or written, and outputs. Files are not passively scraped outside the conversation.
How are credentials protected?
Common credential formats are scanned locally and replaced with redaction markers before storage or synchronization. Because capture ignores .gitignore and pattern matching may miss unusual secrets, sensitive credential files should still be kept out of agent conversations.
What happens when the machine is offline or an upload fails?
The session stays in ~/.cache/sageox/, and ox doctor --fix can retry it later. Cached sessions have no automatic expiry or pruning.
Can a session be recorded without immediately sharing it?
Yes. Set session_publishing to manual with ox config set session_publishing manual; the completed session remains unpublished until ox session upload is run.

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents