Launching today
Agently
Your whole stack, running itself!
363 followers
Your whole stack, running itself!
363 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.
Ahmad — the "writes carry an explicit reference time, conflicts reconcile by when the event actually happened, not arrival order" answer to Aymen is the detail I'd want to poke at. WinBidIQ ingests federal opportunity data (SAM.gov postings and amendments), and our version of "reference time" is messier than an internal system's clock: an amendment can get issued and only show up in the feed hours or days later, sometimes out of order relative to the original posting, and occasionally a correction supersedes a correction. For a one-way external feed like that, where you don't control the source and can't always trust its own reported timestamp either, does Agently's reference-time model take the source's self-reported time as ground truth, or is there a layer that sanity-checks it against ingestion order when the two disagree?
@medal411 You've nailed the exact hard case, and honestly it's the line between a toy and a system: a one-way feed whose own clock you can't trust, out-of-order amendments, and corrections superseding corrections.
Short answer: we don't take the source's self-reported time as ground truth, and we don't collapse it into ingestion order either. It's bi-temporal, so both are first-class and stored separately. The source's reported time is treated as a claim (an attribute of the event), and our ingestion order is always retained independently, which is what lets the two disagree without forcing a destructive pick. When a correction supersedes a correction, each one invalidates the prior with a validity interval, so the lineage stays intact even when they land out of order.
Where I'd rather be precise than hand-wavy: for a feed like SAM.gov, where the timestamp itself is unreliable, the right reconciliation isn't a global rule, it's source-specific logic in the adapter. That's where you'd encode "order on the amendment/version sequence, not the reported clock," since those postings usually carry a monotonic version that's safer to trust than the timestamp. Some of that is turnkey, some we'd tune for your exact feed, and I'd rather scope it with you than oversell one answer.
Genuinely a fun problem. DM me and let's go deep.
@medal411 Ahmad gave you the how, here's the principle: a source's clock is a claim, not the truth, so the brain reconciles reality rather than trusting whatever landed last. For a feed as adversarial as SAM.gov that's not a generic setting we'd flip, it's something we'd tune with you. Genuinely our favorite kind of hard, let's get into it.
the policy gate + approval queue answers in this thread are the most thorough I've seen on this, but they're all about what the gate does. what I haven't seen addressed: who can loosen it, and is that change logged the same way an agent action is? "handle refunds under $50 on your own" is a great rule until someone quietly bumps that number on a Friday and nobody notices until the damage is done. is changing the policy itself a consequential action that goes through the same approval/audit trail as everything else, or is it just an admin setting anyone with access can flip
@galdayan Sharpest question in the thread shows that you have been reading up. It's the one most tools get wrong: governance has to be recursive. A gate anyone can quietly widen isn't a gate, it's a suggestion. Our stance is that changing the rules is itself a consequential action. It should be permission-gated, logged with who changed it and when, and loosening a limit should take the same kind of sign-off as the actions it governs, not a solo Friday toggle. I won't overstate exactly where every piece is today vs on the roadmap, but this principle is non-negotiable for us, and you just described the precise failure mode we're building against. Grateful you pushed here 🙏
@omarships that's the right answer, honestly. a lot of teams treat the policy as static config instead of as another thing agents (or people) can act on, and that's exactly the gap that bites you later. good luck with the launch
@omarships @galdayan Appreciate it Gal and hope you get to try it out and see for yourself.
@galdayan Spot on brother. There is always a validation and invalidation process, nothing can happen from nothing, hence why the brain is a continuously valid source of ultimate truth for the business
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.
Really interesting launch. The strongest part for me is the persistent context across tools not just another AI assistant answering prompts, but a system that can connect events and move work forward automatically.
Curious how do you keep the shared memory accurate and prevent outdated context from affecting decisions?
Congrats on the launch! 🚀
@muhammadtanveerabbas Thank you 🙏 Two layers keep it honest. The brain doesn't just stack facts, it understands state changes, so for example "churned" replaces "active" and the stale version stops driving decisions. And since nothing consequential runs without your sign-off, even if something outdated slipped through, it surfaces to you before it acts, not after. It remains a ultimate source of truth
@muhammadtanveerabbas Thanks so much — really appreciate you zeroing in on the context layer, that's the part we care most about too. 🙏
On keeping shared memory accurate: a few things do the heavy lifting. Every piece of context is timestamped and tied to its source event, so nothing floats around as free-standing "facts" — it always knows where a memory came from and when. Newer signals supersede stale ones, and anything that hasn't been reinforced decays in weight rather than lingering with full authority. When two sources conflict, we surface the conflict instead of silently picking a winner, so a decision never quietly rides on outdated info.
Still plenty to sharpen here as we scale, but that's the core of how we stop old context from steering new decisions.
@muhammadtanveerabbas Mechanically it's a temporal graph: contradicting facts invalidate the old version (with a validity interval, not a delete), and retrieval favors current, provenanced context over stale. So outdated facts don't quietly leak into a decision, they're either superseded or visibly flagged as old.
Congrats on the launch! The temporal knowledge graph is really interesting. How does it decide a fact has gone stale, like a customer that churned or a deal that moved vs just keeping the newer fact alongside the old one? Really like that you framed the brain as the moat and the agent as the commodity
@artstavenka1 Appreciate it and definitely the right question 🙏
The way we see it: your company's brain should understand that reality changes, not just pile up facts. A customer isn't "active" forever, they're active until they churn. A deal doesn't sit in one stage, it moves. So the brain doesn't keep the new note next to the old one and shrug. It understands that "churned" replaces "active" because they can't both be true, and it remembers exactly when that flipped. You get the current truth and the history of how you got there. That's the difference between memory and a filing cabinet. Ahmad will give you the actual mechanics
@artstavenka1 Thanks Omar. So conceptually Omar's answer will be easier to understand but here's a more technical breakdown.
Here's the mechanic. Staleness isn't a timer or "newest overwrites," it's contradiction detection at write time. When a new fact comes in, we check whether it conflicts with an existing relationship. "Customer churned" contradicts "customer active," and a deal has one current stage, so those old edges get invalidated (we stamp them with an end time rather than deleting them). Additive facts that don't conflict, bought product A then product B, just coexist. So invalidation is semantic, not chronological: mutually-exclusive states supersede, independent facts accumulate. And because it's bi-temporal, you can still ask "when were they active" and get the exact interval. Honest caveat: the contradiction call is model-assisted, so clean state transitions are reliable, and for genuinely fuzzy ones we keep both and lean on recency + provenance instead of forcing a merge.
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 🙌
Triforce Todos
@abod_rehman Thank you 🙏
"chatbot with extra steps" might become our tagline.
The first workflow is almost always the recurring, boring, high-context one, the thing that quietly eats your Sunday. Weekly updates for the team or investors, personalized cold outreach, a competitor or account teardown.
It's the work that needs your whole company's context but not your genius, which is exactly what the brain unlocks. Once that one lands, people get bold fast. What's the one eating your week?
@abod_rehman From the eng side there's a reason it's usually those: the first workflow people trust is read-heavy. Pull context from the brain, synthesize, draft. No consequential action, so nothing needs sign-off, which makes it the perfect on-ramp, real value at zero risk. It also stress-tests the brain in the best way (retrieval + cross-tool linking) before anyone hands it anything irreversible. So teams start with "summarize and draft," then graduate to "go do it" once they've watched it be right a few times 🔥