Launching today
Agently
Your whole stack, running itself!
296 followers
Your whole stack, running itself!
296 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.
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.
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 🔥
How do you handle data consistency across 100+ connectors, especially when dealing with concurrent updates or network failures? Is there a specific data modeling approach or conflict resolution strategy in place?
@aymnart Actually Great question (might give you the award), and the honest answer starts with humility: you can't wrap 100 third-party systems in one clean transaction, and any tool claiming to is lying to you. So we designed for the real world, where retries, duplicates, out-of-order events, and half-failed syncs are the normal case, not the exception. Every write is idempotent, so a flaky webhook firing three times still lands once. And we reconcile truth by when things actually happened, not when they showed up. The payoff for you: a network blip or a connector hiccup never corrupts your brain which remains the source of ultimate truth, it just converges on the right picture once things settle. Ahmad can take you under the hood 👇
@aymnart Here's the mechanic. Consistency across connectors is eventual, not transactional, we don't pretend to two-phase-commit across Stripe and Slack. What makes it safe:
Idempotency — every synced record is keyed by (connection, source-record-id) with a uniqueness constraint, so at-least-once delivery from retries or failures collapses to exactly-once effect. Replays are free.
Failure handling — sync writes run off the request path, each tracked by a status column, so a failed or partial sync is observable and retryable instead of corrupting state. Webhooks ack fast, then process async.
Ordering + conflicts — writes carry an explicit reference time, so concurrent updates reconcile by when the event actually happened, not arrival order, and conflicts resolve through the temporal graph (contradiction detection + validity intervals), not last-write-wins.
So the model is idempotent ingestion + temporal reconciliation. Boring on purpose, because boring is what survives 100 flaky APIs.
ProdShort
@amraniyasser You just articulated our entire bet, thank you 🙏
It bends upward, and the reason is the part people miss: connecting sources is table stakes, that curve does flatten once your stack is in.
What keeps compounding is everything that happens after, every correction you make, every decision you approve or reject, every "no, do it this way." That gets encoded, so the brain stops just knowing your data and starts knowing your judgment.
That's the moat and the switching cost you're pointing at: a competitor can copy the features, they can't copy six months of your company's context and your decisions living in one place. The data is the commodity. What you've taught it is the moat.
@omarships @amraniyasser from a more technical standpoint:
Two curves here: raw source-connection does plateau once your big tools are in, you're right.
But the graph keeps compounding on a different axis, entity resolution links more previously-siloed things over time, the temporal history deepens, and every correction or approval becomes a durable signal, so the value curve keeps bending up well past "everything's connected."