Team communication with coordination built in.

Coordination shouldn’t be a pile of threads.

Behind the notifications is a process. You and I discuss a change. It affects another team, so we need their input. Someone has to approve it. The plan changes again. The tasks need updating, and somebody else needs to know what we agreed.

Today that process is a pile of Slack threads. People and agents chase each other through them, working out who to ask, what else is affected, which tools to update, who to tell. It creates more notifications than it resolves, and a lot falls through the cracks: a question unanswered for a week, a doc three versions behind, a customer promised something nobody is building, two teams on different plans until there’s a meeting about it.

AI can already spot the problem. Point Claude at your tools and it will tell you the plan and the tasks disagree. It can make the fix, too: once you’ve decided, it will update Linear, Notion and Jira in one go. Both are getting good fast, but neither is the hard part.

The hard part is getting from the problem to the fix. The people it touches have to hear about it, weigh in, and agree on what gives. Every answer changes the fix, and the fix changes who else needs to hear. That’s coordination: a conversation across teams that keeps changing shape until it’s settled.

Slack gives you a thread for it. An AI in Slack gives you a thread that nags. Neither works.

We think the communication app should run that process.

That’s what we’re building Ink to do.

Ink is team communication with coordination built in.

It puts the right conversations in front of the right people at the right time. Some conversations need you: a question only you can answer, a decision that’s yours to make. Others you’d want to know about: a plan changing under your feet, a deadline moving on a team you depend on. Ink brings you both, at the right time. The rest is there if you go looking, and it doesn’t interrupt you.

It’s not an assistant sitting in your chat, nudging people. That just makes more notifications. In Ink, every conversation knows what it’s proposing, who it affects, and who has to sign off. It checks that against the rest of the company, the plans you don’t know about, the promises you weren’t in the room for, and pulls in what’s missing: the context, and whoever you’ll need to coordinate with.

Every team has its own rules for how work moves: who approves what, which team gets asked first, what counts as done. Ink follows how your team already works. Each conversation knows which step it’s on and who it’s waiting for, so nobody has to keep track.

You talk things through with your colleagues and make the decisions. Ink makes sure the right people are in the room with the right things in front of them. Once you’ve decided, it updates the tools and tells the people who need to know.

A conversation should show you what it’s changing.

Say we’re deciding to leave export out of the next release. In Slack that’s a message, and then a lot of remembering. In Ink the conversation has a second half: a live draft of every change the decision would make, next to the discussion. Nothing is pushed until you say so.

As we talk, the draft fills in. Three tasks come out of this cycle in Linear. The launch plan in Notion loses its export section. The campaign brief still promises export, so there’s an edit for marketing to approve. The draft isn’t a snapshot. It changes as the discussion does, as each person weighs in, until it’s what everyone has agreed to.

Ink checks the draft against everything else it knows. Maybe it finds a renewal sales is closing Friday that promised export. That lands in the conversation now, with the person who owns the renewal, while we can still do something about it. We offer them export in November instead, and that goes into the draft too.

If you join halfway through, you don’t read the thread to catch up. You look at the draft. What’s proposed, what it changes, who’s agreed, what’s still open: that is the state of the discussion. When we agree, we push, and every tool updates at once.

Ink also remembers why. A month later, that customer churns. The November plan assumed their renewal, so Ink knows it needs another look, and brings the people who made the call back together before anyone finds out the hard way.

Your tools should agree with each other and stay up to date.

Things drift. Someone moves a task in Linear and the plan in Notion is now wrong. A meeting ends with decisions and next steps that never reach the tools. Ink notices, and if it matters, starts the conversation to fix it, with the people it affects and the changes already drafted. If it doesn’t matter, you never hear about it.

Ink isn’t another system of record. Your work stays in Notion, your tasks in Linear, your tickets in Jira, or wherever it already lives. Ink sits between them and keeps your tools, your teams, your projects and your knowledge saying the same thing across all your systems, pulling you in only when you’re needed.

You get your attention back.

A conversation reaches you because you’re needed in it, or because it’s one you’d want to know about. When you’re not needed, you can step away. It will find you again when there’s something you’d want to see.

That means more room for the work you wanted to do. Fewer surprises after everybody has moved on. Fewer things that only happen because one person remembered. It’s communication that’s all signal, no noise.

We’re building Ink for the people who have been holding all of this together. If that sounds like you, we’d like to build it with you.