Built to keep your secrets secret.

Two requests, two outcomes.

This example is representative of a run on the same enforcement path the automated suite drives: a 403 on the secret, and a 200 with the infrastructure tokenized. The host, address and token identifiers are illustrative, and the tokens are shortened. The provider is sent tokens in place of the real names, and your team gets the real values restored in the reply.

This has a cost: the model loses your topology. It cannot infer which environment a host belongs to, how your subnets group, or what your naming scheme implies. That is intended. Those relationships are the map an attacker builds first, and withholding them from the model narrows what can leak: to a provider, to a log, or to whoever reads either one later. What survives is everything unrelated to topology: the error in the traceback, the type mismatch in the config, the logic in the code.

One checkpoint for outbound web traffic.

Who can send what, where, and how much.

The aim is evidence that your own reviews and audits can use. Polymux holds no compliance certification, and nothing here claims otherwise. Each item carries its maturity.

Planned items are listed under Maturity.

What is Tested, what is only Built, and what is Planned.

After data leaves the network, what happens to it is usually unknown.

One narrow waist. Every routed stream crosses it.

Outbound security is usually split across a dozen products, each seeing a slice and none of them having the last word. Polymux covers one narrow job. The internet is built as an hourglass: countless applications above, countless networks below, one narrow waist between. Polymux gives outbound web traffic the same architecture: users, apps, and agents on one side, the services they call on the other, and a single governed junction between them. The aim is no ambiguous states: a stream is inspected and forwarded, or stopped and recorded.

Streams stay individually isolated as they multiplex through: each authenticated, inspected, and budgeted on its own terms. When an enforcement check fails, or even errors, that stream stops at the waist. A few paths do not behave that way yet and are being worked through. The deliberate exceptions exist to keep the service available, and each is documented as an architecture decision.

Polymux sits behind your edge and works alongside it. A firewall and an edge router decide whether a connection may be made (address, port, destination), and the deep-inspecting ones match signatures and categories on what passes. Polymux adds one more step: it recognizes that a value is yours, substitutes it before it leaves, and restores it in the reply. That step needs to see inside the boundary, so the junction sits inside it.

The two planes are built to fail differently, on purpose. The data plane fails closed by design. The control plane degrades visibly: when its own guard rails trip it boots fenced, stays reachable, and reports unready so that it does not serve. An operator can still reach the instrument that clears the fault.

What's already standing at the junction.

The cards below give the detail behind Maturity. Each card’s tag gives the stage of its features.

An agent's authority should be checked somewhere the agent can't reach.

The AI features run on the same inspection and enforcement engine. AI is where that engine matters first, because an agent breaks assumptions the rest of the stack still makes: it chooses what to send, it acts on whatever enters its context, and it does both faster than anyone reviews.

A gateway has limits here. It cannot tell which tool call is a mistake, because that judgement needs intent, and Polymux does not claim a detector for intent. It moves the decision off the agent and onto a policy the agent cannot edit, at a point the agent cannot route around when the gateway is its only way out, with a record of what was decided and why. The policy still has to be written. Once it is, it is enforced, and it no longer lives inside the thing that might be compromised.

Engineering rules already in force.

Fails closed by design. Where possible, the unsafe option is deleted. When the weak token format was replaced, the switch that selected it was deleted. A service started with no environment declared refuses to boot. The control plane cannot clear a safety fence that it is itself subject to. None of those are checks someone has to remember to run. Security refinements and feature coverage are in progress (Maturity lists what is still open), and each fix moves it forward.

The same rule applies to what gets written down. A security product asks you to believe a lot of sentences, so the project's own claims are held to one standard: a claimed guarantee has to be enforced or cited. Where a claim's shape can be checked mechanically, that standard is a build gate: a grant-style claim that does not name the line enforcing it fails the build. Where it cannot be checked mechanically, it is a review duty, and whatever that leaves unresolved is tracked.

More than a hundred architecture decisions are recorded with their reasoning and the alternatives that were considered. The readiness file is generated and carries measurements with named sources. It has no status column. The project also audits itself with one question: what in this repository reads as implemented but isn't? The findings go in the repository, resolved or not.

Built by one person: what that means for you.

Polymux is built and run by the Founder of Synergy Geeks LLC, a single-member company. A buyer is right to ask what that means. The pace is one person's pace, availability is one person's availability, and if that person is unavailable there is nobody to cover.

What reduces that risk today is true of the product itself. Polymux is self-hosted, so it runs on your infrastructure. Its design is written down in recorded architecture decisions and a generated readiness record (see Engineering). Licenses are signed and checked offline. You also deal directly with the person who writes the code. At this stage that is an advantage.

The ambition is to become a vendor large organizations can rely on. Nothing on this page claims that has happened. If continuity matters to your decision, ask what exists and what doesn't. You will get a direct answer.