mc-serious

Really cool direction. For folks thinking about the “agent safety” stack more broadly, this feels complementary to things like Kontext’s kontext-cli (github.com/kontext-dev/kontext-cli) and OneCLI (github.com/onecli/onecli)

Open-Source will handle access to models, someone will find a way. Security by obfuscation has never worked.

hm i see so a bit like pagerank for md files - would be curious about the equivalent to backlinks, what do you think that is for skills? Skills that embed other skills?

Yeah tbh I think this might be close to impossible to do as it probably 1) requires alignment that every stateful system needs a rollback capablity 2) it needs to be standardized which will probably take a minimum of 2 years after consensus (and that's probably conservative).

I'd love to learn more on how egress can be handled securely in sandboxes, and in general also ingress as this has some security impact - as soon as you allow reading from an external system you open up a new threat vector. Curious to understand whether you have any strategy for network access?

How's this different from the built in skill finder? Anything specific?

Nice, I think that's pretty neat. Do you have an idea where to take this further? I.e. for the filesystem it's great but what if you need to touch external systems that keep their own state?

I think the hardest part is the environment/support matrix, not getting it to run in the first place.

It’s usually pretty doable to make a system self-hostable on a happy path. The hard part is supporting it across lots of customer environments without being in the loop every time: custom IdPs, private networking, KMS/HSM/BYOK requirements, upgrade/migration paths, backup/restore, observability, and all the weird edge cases that only show up once other people operate it.

And yes, I think your last point is right: the customers who care most about this category are often exactly the ones who will require self-hosted.

What's your take? Curious what you found effective vs. what you deem hardest from your experience.

Fair pushback and point taken. The reason this isn’t trivial is that the CLI is the easy and lightweight part. The heavy part is the infra behind it: auth, vaulting, token refresh/exchange, revocation, provider edge cases etc.

We'll think how to best accomodate full self-hosting in the future!

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.

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.

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.

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.

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

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.

Yes, with one important distinction: our visibility is at the agent tool boundary, not the raw network layer.

So if Claude Code invokes Bash and runs curl ..., we see that tool invocation. If it invokes Bash and runs python script.py, and that script makes HTTP requests internally, we still see the Bash invocation.

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.

great, I'll directly compare it to graphite.com - the main point really is the user interface in my opinion. Still a bit sceptical whether github can out-deliver here, but happy to be proven wrong!

Has anyone already tried that was a graphite user before?

Every automation wave produces people who genuinely can't imagine what comes next, and they're always right that something dies and always wrong that nothing replaces it. The deeper issue though is that you've started measuring yourself with the machine's ruler. Heidegger called this "enframing". Technology doesn't just change what you do, it changes how you evaluate everything, including yourself. Once you accept output speed as the metric you've already lost the argument on its own terms.

The kid learning french and dutch shouldn't try to out-translate an API. He's trying to exist in someone else's world, adapting to someone's culture gives and edge that's not easily measurable.