Launching today
Agently
Your whole stack, running itself!
105 followers
Your whole stack, running itself!
105 followers
Every other tool answers, retrieves, or runs brittle rules. Agently holds your whole company in context and does the work. 100+ connectors flow into one brain that never forgets. It links a Stripe event to a Slack thread to a Linear ticket on its own. When something needs doing, Jarvis routes it to an agent that runs it end to end: triggered, running, shipped. The work lands without you, nothing falls through the cracks. Connecting takes minutes. The layer between today's AI and tomorrow's AGI.
Huge congrats @omarships on hitting the leaderboard.. qq what's the average millisecond latency overhead between an incoming trigger event and agent execution?
@priya_kushwaha1 Great question.
We keep the trigger path deliberately thin: an incoming event (a webhook, or a manual dispatch from Command Center) is acknowledged and the run is handed off asynchronously, so the trigger-to-execution overhead is small and roughly constant.
The latency that actually dominates is the agent loop itself: brain retrieval + model inference + tool calls. That's seconds-scale, and it's where we spend our optimization budget (prompt caching, a frozen prompt prefix, incremental cache breakpoints so repeat runs stay fast).
Happy to go deeper. DM me and I'll share the real prod numbers we're seeing.
Thanks, Omar That makes sense, I also sent you a DM just waiting for your response. Looking forward to learning more about the production latency numbers.
@omarships @priya_kushwaha1 This one's my corner 🙂 The pipeline: trigger comes in → validate + persist + hand off to a stateless agent service, all off the request path → then the loop runs (retrieval → inference → tool calls, iterating to done). We tag every stage with correlation IDs so we can see exactly where the time goes, and the trigger→handoff segment is by far the cheapest part. It's the tool round-trips and inference that set the pace. Ping me and I'll share real traces with the exact split.
Honestly the linking between Stripe, Slack, and Linear without me setting anything up kind of freaked me out in a good way. Curious how it handles edge cases when the context gets messy though.
@saadetpz2y That auto-linking is entity resolution on hard signals (shared email, domain, IDs), so it connects the same customer/thread/ticket across tools with zero setup. For the messy stuff the rule is: degrade to asking, not guessing. Strong signal it acts, weak or conflicting it flags and defers to you instead of forcing a match. Edge cases get surfaced, not papered over.
@saadetpz2y Appreciate that 🙏
Here's the belief behind it in a less technical manner: messy context isn't an edge case, it's the normal state of every company. Tools disagree, data goes stale, half of it lives in someone's head. So we made a deliberate call early: the system should be honest about what it doesn't know rather than confidently wrong.
Sounds small, but it's the whole product. The fastest way to lose a founder's trust is one confident action taken on bad data. So when context gets messy, Agently narrows down and tells you instead of guessing and shipping. We'd rather look a little less magic in that moment and earn the right to run more of your company over time.
The "freaked me out in a good way" part is the payoff of getting the boring foundation right. Glad it landed 🙌
The "running itself" promise is the dream and the fear at once. As a solo builder leaning hard on agents, my honest worry is trust: how much can I actually hand off unattended before I need to babysit again? Curious where you draw that line.
@virko_kask Honestly the most important question in this space, and I'd be skeptical of anyone who answers it with "just trust it."
Our line is the point of consequence. The agent runs on its own for the most part: drafting, research, pulling context, prepping the deliverable. But anything that ships or touches the outside world (sends an email, posts, spends money) hits an approval queue and waits for you.
Two things keep that from being annoying instead of empowering: it remembers what you reject, so it stops proposing the stuff you don't want, and you can widen that line per action type as trust builds. You start at "propose everything" and move toward "send the routine follow-ups on your own."
So you're never babysitting, you're reviewing. And you review less over time. Trust should be earned, so we built it to be earn-able.
@virko_kask Ahmad here, I own the agent loop. The thing that lets us make that promise honestly: the guardrail lives in the runtime, not the prompt. Every tool call passes through a policy gate before it executes, first-deny-wins. Anything classified as consequential gets intercepted before it runs and dropped into an approval queue. When you approve, we replay the exact call, so what executes is byte-for-byte what you signed off on, no re-interpretation in between. There's a kill switch and per-run budgets so a bad run can't spiral. We're not asking the model to please behave, we're structurally stopping it from shipping without you.
FuseBase
Congrats @omarships @ahmadhajj The comments have quietly answered my biggest worry (does it ship stuff without me looking) and raised a new one (what happens when my tools disagree with each other about reality). How is conflicting data across tools resolved?
@ahmadhajj @kate_ramakaieva Great question, and it's exactly why the brain is a temporal knowledge graph and not a vector dump.
We don't do "latest tool wins" or silently overwrite. Every fact lands with a timestamp and its source, so when two tools disagree, both are kept, with provenance and when each was recorded. Resolution is temporal first: newer information supersedes stale facts, and the graph invalidates the outdated version instead of pretending it never existed. Recency and source both factor in.
And when a conflict is genuinely ambiguous, the agent surfaces it instead of guessing: "these two disagree, here's each side and when." Which ties back to the sign-off model, you resolve reality, it acts on it.
So conflicts aren't resolved by hiding them. They're resolved by remembering everything, when it was true, and where it came from.
@omarships @kate_ramakaieva This is my favorite part 🙂 Under the hood it's bi-temporal: every fact carries when it happened and when we ingested it as separate axes, so "my CRM updated late" and "the thing actually happened Tuesday" don't get confused. Writes are idempotent per source record, so re-syncing a tool doesn't spawn phantom conflicts. When new info contradicts old, we invalidate the specific relationship rather than deleting history, and retrieval is a query over that graph, so the agent pulls a resolved current view but can still see the contradiction and its provenance. For genuinely ambiguous cases we flag, we don't auto-merge and hope.
Hey Product Hunt 👋,
I'm Omar, founder of Agently.dev.
Here's the bet I'd stake the company on: one person should be able to run a whole company without being its memory, and a small team should ship like a big one. That only happens if the agent stops being the product. The agent is the commodity. The brain is the product.
Most agents are stateless: grab data, do a task, forget. Fancy macros. Ours runs on a persistent, entity-resolved model of your whole company, what each thing is, why it matters, when it's relevant, how it connects, across every tool, never forgetting. A living graph, not a chat history, so work lands instead of waiting on you.
Jarvis reads that brain, decides what needs doing, and dispatches event-triggered agents that act back through 100+ two-way connectors, so the work closes instead of piling on you: triggered, running, shipped. Real artifacts, not summaries. The hard part everyone stops at is keeping that model live, correct, and safe to write back through.
It compounds. Months in, your brain knows your company in a way even your co-founder cant, and you come off the critical path. That's the moat.
The teams already running on it go from solo founders to enterprises. This is where work is going. Become part of the future. 🧠
Learnetto
@omarships Looks super cool. Will give it a try!
@hrishio Looking forward to your feedback. In our vibe building era
@omarships Super excited for this launch. First company of its kind
Hey Product Hunt 👋, I'm Ahmad,
Co-founder and CTO of Agently.dev
Here's what nobody warns you about when you build agents: entity resolution. The same customer shows up in Stripe, Slack, and Linear under three different names, and if your model of the company gets that wrong, everything downstream is wrong too. Agent demos are easy now. The hard part is what the agent knows.
We spent most of 8 months there: one living automated temporal knowledge graph of the whole company, kept correct enough that agents can safely write back through it. Our 100+ connectors are two-way, so agents don't just read your tools, they act back in them. Jarvis reads that graph, decides what needs doing, and dispatches agents on what it sees, not prompt by prompt.
"Do I trust the write-back" was the first question every beta cohort asked. Fair question, and parts of this are still early.
Happy to go deep on architecture, entity resolution, how Jarvis dispatches, or write-back safety. Ask away. 🛠
@ahmadhajj Building a the future for founders!
EverTutor AI
Congrats on the launch, Omar and team! 🚀 The idea of having an AI chief of staff that keeps your entire company context and actually gets work done across tools is incredibly exciting. Building something this ambitious isn't easy, and it's great to see you pushing the boundaries of what's possible with AI agents. Wishing you an amazing Product Hunt day and can't wait to see where Agently goes from here! 🙌🔥
@suryansh_tiwari2 Thank you, this genuinely made our day 🙏
You captured it perfectly.
The way we think about it: the agent is the commodity, the brain is the moat. Agently pulls your whole stack into one living temporal company brain, so Jarvis (our orchestrator) never knows your company better than even your cofounder. It cross-references that context, drafts the real work across your tools, and opens it for your sign-off before anything ships.
And the brain compounds the more you feed it, so it gets sharper and more yours over time. That's the part we're most excited about. Grateful for the support, especially today 🚀🔥
@suryansh_tiwari2 Appreciate it 🙏 The part I'm proudest of on the eng side: agents don't get your company stuffed into a giant prompt. The brain is a temporal knowledge graph, and retrieval is a tool call the agent makes when it needs something. So it stays grounded, doesn't blow the context window, and can reason across tools without hallucinating the state of your company. Genuinely fun to build.