From another comment:

> Kontext holds secrets server-side and mints short-lived tokens per session.

That probably makes this thing DOA for most people (certainly for me and everyone I know).

[dead]

yes, atm there's nothing that keeps the agent from reading the key from the environment. If a static API key is injected into the agent’s env, the agent can in principle read it. The value of our threat model is better custody, short-lived creds where possible, and auditability, not “the process can’t see its own env.” You can make the hooks a lot stricter and check that the agent can basically never do anything with the credential, the agent is still inside the trust boundary in this case.

Yes, that’s the ideal model. For services with OAuth/OIDC/token exchange support, we want to mint short-lived delegated creds instead of returning the underlying secret. For services that don’t support that, we don’t want them to be unsupported entirely. But they’re a weaker security tier: you can still improve custody/rotation/auditability, just not get the full “agent never sees the real secret” property without a proxy/broker/signing layer.

If they use the system keyring, it depends on the OS and other details - MacOS, Linux, and Windows all have different implementation tradeoffs.

Great question. Two main differences:

Workflow: OneCLI runs as a self-hosted Docker gateway — you route agent traffic through localhost:10255. Kontext doesn't change how you use Claude Code at all, just kontext start --agent claude.

Visibility layer: OneCLI intercepts outbound HTTP requests. Kontext hooks into Claude's PreToolUse/PostToolUse events, so you see bash commands, file ops, and API calls and not just network traffic.

Trust model tradeoff worth naming: OneCLI is fully self-hosted. Kontext holds secrets server-side and mints short-lived tokens per session. We do this via token exchange, RFC 8693, and natively build upon Oauth to support only handing over short-lived tokens - you don't need to capture refresh tokens for external tool calls at all.

Thanks for flagging - wasn't aware of Aperture! It's a little different to what the Kontext CLI does though.

Aperture solves “make multiple coding agents talk to the right LLM backend through an Aperture proxy.” We solve “launch a governed agent session with identity, short-lived third-party credentials, and tool-level auditability.” They overlap at the launcher layer, but the security goals are different.

Nice! I'd love to hear what you think about our approach, and what features you'd like to see first.

Thank you! OpenClaw/NanoClaw is one of the obvious next integration targets. I don’t think the right model there is just “wrap the outer process” the way we do with Claude Code today. OpenClaw has a real plugin surface, so we’d more likely ship a plugin that hooks before_tool_call / after_tool_call and talks to a local Kontext sidecar for policy + telemetry. The nice part is OpenClaw can actually block there, so you can do real allow/deny/approval at the tool boundary.

Very interesting article! Yes, I think that’s plausible, but probably not as “just eBPF” in practice. Once you need request rewriting, signing, and TLS-aware handling, you usually end up in eBPF + userspace or kernel-module territory. I believe the post is basically making that exact argument. Our current CLI is intentionally at the tool/session layer. A transport-layer mode is interesting, especially for containerized/SDK-driven agents, but it’s a different and more OS-specific implementation path.

[dead]