We're looking to more than double our founding team at @beacon.sh, hiring aggressively across research and engineering.
We're building the visibility and control layer for AI agents, and we've got some serious momentum:
$5.5M raised in seed funding
3,200+ GitHub stars and a growing OSS community
#1 Product of the Day on Product Hunt
Our founding team brings experience from Doppel, Brex, and Trail of Bits, and we're looking for exceptional builders to join us.
We're hiring:
Founding Engineer: Build high-performance infrastructure to secure and govern AI agents at scale.
Founding Security Researcher: Break AI agents, uncover novel attack surfaces, and publish cutting-edge research.
Who we're looking for:
Deep technical curiosity and obsession with craft
High agency, relentless ownership, and bias toward shipping
Exceptional problem solvers with incredibly high standards
We want world-class engineers and researchers. We don't care about pedigree. We care about what you've built, the problems you've solved, and the quality of your work.
NYC in-person preferred, open to exceptional remote talent.
DMs open. Come build with us! Contact me at founders[at]asymptotelabs.ai
One of my favorite things about Beacon is that it makes your coding agents smarter the more you use them.
For everyone in the Product Hunt community building and shipping with Claude Code, Cursor, Codex, or other coding agents, you've probably experienced how frustrating it is to solve the same problem multiple times across different sessions and tools!
Beacon learns from your past sessions, turns useful discoveries into reusable memories and skills, and makes them portable across all your coding agents.
I personally switch between multiple agents every day, and seeing them build on each other's work has been a game changer.
We're building Beacon in the open, it's completely free to get started, and I'd love to hear what you think!
See the public repo: github.com/asymptote-labs/agent-beacon
@justindsouza S/O for the great work! keep launching
@fmerian thank you!
@justindsouza Congrats! When Beacon turns a past debugging session into a reusable skill, how do you decide what’s worth remembering versus what could become stale or misleading later?
@swati_paliwal Great question Swati! We try to capture the reusable lessons like debugging patterns, architectural context, and hard-earned lessons. Staleness is definitely a challenge, which is why we see agent session traces as a continuous feedback loop. As agents run into new situations, Beacon can use those traces to validate, update, or retire skills that no longer hold up.
I'd love your feedback on Beacon! If you like the project please upvote us and don't forget to star our repo: https://github.com/Asymptote-Labs/agent-beacon
@justindsouza, love the idea behind this!
One of the biggest frustrations with coding agents is losing useful context between sessions. Being able to carry over debugging insights and lessons across different tools could be a huge time saver.
Congrats on the launch, guys! 🚀
@csaba_kissi appreciate the kind words Csaba! Would love your feedback on Beacon if you try it out: https://beacon.sh/
@justindsouza @csaba_kissi spot on! curious how many different coding agents do you use in a typical week? would love your input here in /p/asymptotelabs
Memory is where most agents fall apart for me, so this is the right problem to go after. The part id push on is source and staleness. A memory learned from a trace 3 weeks ago can be confidently wrong after a refactor, and then every agent sharing it inherits the mistake. Does each memory point back to the trace it came from, and does anything expire it when the code it refers to changes? We made our memory cite a source or say it doesnt know and that alone killed alot of bad answers. congrats on the launch
@ali_shaheen Really appreciate your thoughts here Ali! I totally agree with you that shared memory is only useful if you can trust it.
Beacon approaches the stale memory problem by grounding learnings in your agent session traces, so there's provenance behind what an agent remembers. On staleness, we skills to the files and code they originated from, then using subsequent traces as a feedback loop to identify when a learning is no longer valid and should be updated or retired.
I'd love your feedback on the product! https://github.com/Asymptote-Labs/agent-beacon
How many times did you re-explain the same project to a different AI? @beacon.sh fixed that.
Switch sessions between coding agents like @Claude Code and @Cursor, and one command hands the work to the next agent with everything it learned.
They just raised $5.5M, and it's open-source.
Star this repo: github.com/asymptote-labs/agent-beacon
@fmerian we're just getting started!
@justindsouza keep launching! it pays off in the long term
@fmerian From today! https://intel.beacon.sh/ -- more to come!
Congrats on the launch!
Local first and shared knowledge support for almost all coding agents. I have used few similar tools in past, would love to see any benchmark or internal findings on how much token/cost saved if I use Beacon on cross harness. How are you handling stale context issue with it?
@astrodevil Great question Anand! The biggest opportunity we’re seeing is eliminating repeated exploration and debugging by letting agents reuse hard-earned context from previous sessions.
On staleness, traces give us a continuous feedback loop. Beacon can see how agents apply what they’ve learned in future sessions, catch patterns that stop working, and update or retire stale knowledge.
Would love your feedback on Beacon! And if you find it useful, an upvote and GitHub star would mean a lot :) https://github.com/Asymptote-Labs/agent-beacon
@astrodevil @justindsouza yes, and claim your @beacon.sh profile to see where you stack up on the leaderboard: beacon.sh
@astrodevil @fmerian here's the current leaderboard btw! https://beacon.sh/leaderboard
@astrodevil @justindsouza omg @ryanyannelli used 400B+ tokens 🤯
Congrats Justin. Saw the launch on X. How does Beacon decide which learnings are worth turning into reusable skills and how does it discard outdated or conflicting learnings?
@rohanrecommends Thanks Rohan! Beacon looks at your agent session traces to identify repeated workflows that can be turned into reusable skills. The idea here is to use those traces as a continuous feedback loop, so over time, Beacon actually understands which skills are stale or being heavily used! For conflicted learnings, we do have a configurable human-in-the-loop step, so you can decide what learnings are persisted or not.
Congrats on the launch @justindsouza !
What happens when two branches need different fixes for the same issue? Does Beacon track which advice applies to each branch? Or could an agent end up using a fix that only works on main?
@byalexai thank you Aleksandar! It really depends on how you want to leverage the skill and memory candidates Beacon generates. You can definitely choose to share them across branches if you want, we expose the memories and skills as markdown files and you can choose how you want to consume them.
The main feedback loop is that Beacon continuously distills your agent session traces to understand where learnings are coming from and to update skills/memories when they stop being relevant.
Wow love it! Does the mem also carry over when switching between different coding agents? Would be really useful. Congrats on the launch though
@trulysurya precisely. @beacon.sh saves your sessions across Claude Code, Cursor, Codex, and 20+ other tools, so the next agent starts with everything it learned.
it's open-source, view the source code here: github.com/asymptote-labs/agent-beacon
icymi @justindsouza recorded a live demo here. hope it clarifies
@trulysurya Yes Surya! That's one of Beacon's core use cases. Beacon captures context and learnings across different coding agents like Claude Code, Cursor, Codex, and 20+ other harnesses, so the context and lessons from debugging in one tool can carry over to another. The goal is to make your knowledge reusable regardless of which agent you're using!