aws B

// the access broker for everything

lanyard is an access broker: it grants just-in-time, least-privilege access to a resource for as long as it's needed, then revokes it on expiry — working through each provider's own API, never in your connection path. Agentless, audited, self-hosted.

lanyard request for
policy auto-approve approval chains · webhook alerts revoked on expiry · audited
$brew install EmiraLabs/lanyard/lanyard
macOS & Linux — Homebrew
How it works

Grant access, then forget about it.

lanyard is a broker, not a proxy — it grants and revokes native access through provider APIs and is never in the connection path.

requestpolicy or an approval chain decidestime-boxed grantauto-revoke on expiry
requester
approver
a reconciliation loop re-checks every grant each sweep · nothing outlives its expiry
Grants & revokes native access to
One broker, many providers — each grant native, through the provider's own API.
Why lanyard

Access that shouldn't exist a minute longer than it needs to.

Standing access is the real security problem. lanyard makes every grant temporary, least-privilege, and provable — without agents or a certificate authority.

Agentless by design

No agents on your targets, no CA, nothing in the data path. One binary talks to each provider's own API.

github 0 agents your targets 0 agents
one binary · no cluster, no CA, never in the path

Guaranteed revocation

A reconciliation loop drives reality toward “no grant outlives its expiry” — and records each sweep durably, so a stopped sweep is never mistaken for a clean one.

g_8f3a · repo/acme/api:pushexpires in 1h 58m
revoked on expiry — 0 standing grants

Audited by default

Every request, approval and revoke is an event answering who, what, when, where, why and how — on a tamper-evident hash chain you can verify.

14:02:11request g_8f3a
14:02:18approve g_8f3a
16:02:11revoke g_8f3a

Policy + approval chains

Declarative rules auto-approve the routine. Anything else runs an ordered chain — levels are AND, the roles inside a level are OR — and a webhook tells the approvers, so nobody polls.

if routineauto-approve
chain [[prod_approver], [platform_admin]]

Secrets stay yours

Vendor credentials are always referenced, never inlined. lanyard stores a pointer and resolves it at use — the secret never enters its config or its logs.

env:// vault:// aws-sm:// env:// resolves today · dashed are next

Built to be extended

Every provider is an adapter behind one small port — four methods, proven against a conformance kit. If it has an API, lanyard can broker it.

// one port, four methods
func (a *MyProvider) Grant(ctx, ent, actor) { … } passes the conformance kit
broker & proxy

A proxy secures the session. A broker decides who gets one.

They secure different layers, and they compose — already running a proxy? lanyard doesn't replace it; it governs whether the session should open at all, and for how long.

an access proxy — in the path
youproxytarget
Every byte flows through it — so it can record or cut a session live, and it has to scale with your traffic.
lanyard — out of the path
youtarget grant · revoke · expire
Decides who may connect and until when, natively on the target — then steps aside. Nothing to route, nothing to scale.
an access proxylanyard, a broker
sees your trafficyes — that is the featurenever
governsthe session, while it is openwhether it opens, and for how long
reacheswhat you can proxy — SSH, DB, K8sanything with an API — SaaS, cloud, source control
buy it whenyou must watch inside sessionsyou must prove who had what — and that it ended
Zero stored credentials

lanyard's database holds pointers, not secrets.

Provider credentials stay in the secret manager you already run. lanyard keeps a reference, resolves it at the moment of use, and drops the value when the call returns — never written to its database, never logged. Breach lanyard's store and you hold addresses, not keys. And your users' credentials are further away still: lanyard grants native access and never sees them at all.

lanyard's DB — holds a reference
integrations/github · private_key_ref = env://GITHUB_APP_KEY
# no secret value at rest — breach this, you hold an address
1 · at use, follow the ref 2 · value returns — memory only
your secret manager — holds the value
vault aws sm gcp sm bitwarden 1password
3 · one provider call, then dropped — never in the DB, never in logs
env:// today (vault agent, op run, bws run) · native vault:// & aws-sm:// next
Built for developers

A CLI you'd actually use, and an API underneath.

Request, approve and revoke from the terminal — or wire lanyard into your own tools over plain HTTP. Every entitlement is four segments, provider:instance:resource:capability, so a broker fronting two orgs can never resolve a grant ambiguously.

# request 2h of push on one repo, with a reason
$ lanyard request \
  --entitlement github:acme:repo/acme/api:push \
  --reason "debugging INC-4821" --for 2h
✓ requested · g_8f3a · pending approval

$ lanyard approve g_8f3a
✓ approved · active · expires in 2h

$ lanyard list --status active
# same thing, over HTTP
$ curl -X POST $LANYARD/grants \
  -H "Authorization: Bearer $LANYARD_TOKEN" \
  -d '{"entitlement":"github:acme:repo/acme/api:push",
    "reason":"INC-4821","duration_seconds":7200}'

201 {"id":"g_8f3a","status":"pending"}
entitlements:
  "github:acme:repo/acme/api:push":
    policy:
      max_duration: 4h
    # levels are AND, roles in a level are OR
    approval_chain: [[prod_approver], [platform_admin]]
  "github:acme:repo/acme/docs:push":
    policy:
      max_duration: 24h
      auto_approve: true
Pricing

Self-hosted. Flat per org. No per-seat math.

You run the binary and own your data — no metering, no lock-in. The core is free forever, and security is never an upsell: approvals, audit and auto-revoke are in every tier, starting at $0.

Free
$0forever
free forever · self-hosted
Get started
  • Full loop: request → approve → time-boxed grant → auto-revoke
  • Multi-level approval chains, delegation and policy YAML
  • Role-based access control over every console resource
  • Tamper-evident audit log with integrity verification
  • Approver notifications to any incoming webhook — Slack, Discord, Mattermost
  • GitHub provider · admin console · requester portal
Planned
Pro
$1,490/ yr · per organization
indicative · not yet on sale
Follow along
Everything in Free, plus — on the roadmap
  • SSO / SAML + SCIM provisioning
  • Access reviews & attestation campaigns
  • Compliance evidence export (SOC 2 / ISO 27001)
  • Audit streaming to your SIEM
Enterprise
$449/ mo-equiv · annual invoice
indicative · not yet on sale
Talk to us
Everything in Pro, plus — on the roadmap
  • Support SLA & priority response
  • Invoicing & compliance paperwork
  • Continued-use terms on license expiry

lanyard is pre-1.0 and the paid tiers are not on sale yet — the prices above are the plan, not a checkout. The core stays free, and price changes will be announced at least 3 months ahead.

Get started

Stop granting access forever.

Self-host the whole broker — agentless, audited, and yours to run.