The integration that became the project
By Soumen Sarkar · October 2026
Story. When every teammate wires Claude into a different tool, the glue becomes a project nobody owns, and one update breaks it quietly. Keep the connectors that act on a tool in one shared file, and carry the team's context through one shared layer.
What happens when the glue becomes the project?
This story is a scene, built from how teams work with agents today. What comes after it is real.
It's 9:00 on a Monday, and I'm sitting on a spare chair at the end of Maya's desk. Maya leads a team of five. Last week she said something I wrote down: "This month, Claude talks to everything." She means the tracker, Slack, GitHub, the design docs and CI.
Dev goes first. He adds GitHub's MCP server to his own settings with his own token. By lunch his sessions open pull requests and read review comments. He grins at me across the desk. The agents are fast, and they're good at it.
On Wednesday, Sara writes a small script that posts to the team channel when a session finishes. Maya likes it. She can see what shipped without asking.
The next week, Priya builds a connector for the tracker, because the team's tracker has no server she trusts yet. It runs on her laptop with a personal token. She shows the others how to copy it. Two of them do.
Then Maya writes a hook. At the start of every session it pastes the team's decisions file into the agent's context. "Now they'll all know what we decided," she says. Dev adds a second script that reads CI failures back into his sessions. Nobody else has that one.
By the end of the month, I count it on a sticky note. Five connections. Three tokens on three laptops. Two hooks. One decisions file that Maya updates by hand on Friday afternoons. It works, mostly, and everyone is proud of it. Nobody has shipped much else.
On the fifth Tuesday, the tracker's company releases a new version of its interface. Priya's connector stops answering. Her own sessions show an error, and she spends the morning fixing it. The two teammates who copied it don't see the error. Their sessions simply have no tracker. The agents carry on, as they should, with what they've got.
That same morning, Sara tidies the repository and moves the decisions file into a folder called docs. Maya's hook can't find it. The hook fails, the session starts anyway, and every session that day begins with no decisions at all.
On Tuesday afternoon, Maya decides to move invoices to the new payments client. She adds it to the file in its new place. Dev's session never sees it. It writes a beautiful, well-tested change on the client the team just left behind. Sara's session does the same in another folder.
On Thursday, in review, Maya finds both. She doesn't shout. She puts her face in her hands for a second and says, to nobody in particular, "I've become the person who keeps the glue working." Then she spends Friday afternoon updating the file by hand, the same as every Friday.
Nobody did anything wrong. The agents did exactly what they were told, very well. Each connection was reasonable on its own. Together they were a system nobody owned, living in five people's settings, and when one thing changed, it broke without telling anyone.
I come back three weeks later. It's a Monday again.
The team has done one boring thing. They wrote every hook, script and server on a whiteboard, and marked each one "acts on a tool" or "carries what we know". The GitHub server and Priya's tracker connector act on tools. They now live in one shared file in the repository, with each person's token kept in their own environment. Sara's channel script stays too.
The decisions file, the paste-it-in hook and Dev's private CI script carried what the team knows. Those are gone. In their place is one plugin and one server connection, the same on every laptop. Decisions are recorded as they're made, with a reason and a name. Each session gets a brief when it starts, and an area brief the first time it opens a folder.
At 10:20, Dev's session opens the invoices folder for the first time this week. I watch the brief arrive: the decision about the payments client, Maya's name on it, and a note that Sara has work in progress next door. The session builds on the new client. Nobody typed anything.
On Wednesday, the tracker's company ships another update. Priya's connector breaks again. This time she fixes it once, in the shared file, and pushes. By lunch, every session on the team has the tracker back. Nothing else stopped while she did it. The decisions, the briefs and the reasons never went through her connector in the first place.
On Friday afternoon, Maya doesn't update a file. She reviews Dev's change, reads the reasons linked from the pull request, and merges it. Then she opens a session of her own and starts the feature she meant to start a month ago. Priya and Dev are arguing, happily, about who gets the next one.
Here's what I want you to notice
The agents were brilliant from the first morning. Every connection they were given, they used well. What broke was everything between the people: five private setups, a file one person kept alive by hand, and a failure that looked exactly like silence.
Look at which glue hurt. The connectors that act on a tool broke loudly, and one person could fix them. The glue that carried the team's decisions broke quietly, and it cost two afternoons of good work built on a call the team had already changed.
Stop building your team's memory out of scripts. Build the connectors that do real work, share them in one place, and put what the team knows in one layer that every session reads first. If you're the person who keeps the glue working, that isn't leading. It's maintenance.
What's the proof?
- Every connection is its own project. When Anthropic introduced the Model Context Protocol, it named the problem: "Every new data source requires its own custom implementation."
- The tools keep changing under you. In its March 2025 version, MCP's new Streamable HTTP transport replaced the HTTP+SSE transport from the version before. That's healthy progress for a young standard, and every hand-built connector has to keep up with it.
- Context glue fails quietly by design. In Claude Code, a hook that exits with any code other than 2 is a non-blocking error, and the session goes ahead (Claude Code hooks). That's the right default. It also means a broken context script looks exactly like a working one with nothing to say.
- Sharing is built in. A checked-in
.mcp.json gives every teammate the same MCP servers (Claude Code MCP docs), and plugins bundle hooks and servers into one install. - Our glue breaks too, and we fix it once. On 20 October 2026, our own record shows hooks "installed both in a repo and in ~/.claude ran twice: the brief and area briefs arrived twice." We fixed it in the shared hooks, and every install got the fix. The next day, our install instructions pointed at a private repository "which only worked for us." One change fixed it for everyone.
That's what Campfyrr does today: one plugin and one MCP server carry decisions, briefs, area briefs, handoffs and the reasons for each change to every session. It doesn't replace your tracker, your CI or GitHub's own server. Keep those, in one shared file. It doesn't read Slack, and it has no audit logs yet.
What do I do on Monday?
- List every hook, script and MCP server your team runs, and who owns each one.
- Mark each one "acts on a tool" or "carries team context".
- Move the tool connectors into one shared
.mcp.json in the repository. - Keep each person's token in their own environment. Never commit a token.
- Install Campfyrr from /connect for yourself and one teammate.
- Remove each context script once the briefs cover it.
- Count how many Friday afternoons you get back.
For the problem in full, read when the glue becomes the project. The trade-off is set out in building your own Claude glue vs a shared layer. For the basics, see what MCP does for a team and the hooks playbook. The idea behind it is answer it yourself.
The problem this answers: Claude across every system: "We tried to make Claude handle all our moving systems ourselves, and the glue became the project."
The principle behind this: Answer it yourself: Look first. If the answer isn't there, assume it or decide it.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).