One hand resting on the pages of a huge open book, the other reaching toward a laptop beside it, drawn in warm daylight. (light) One hand resting on the pages of a huge open book, the other reaching toward a laptop beside it, drawn in high-contrast teal and orange. (dark)

We're adopting a new way of organizing our teams at work. Vijoy Pandey, SVP at Outshift wrote about it in his latest post titled "Your teams are shrinking, the coordination surface is exploding". He states that as AI agents absorb more of the execution of tasks, the core productivity unit within a large team collapses to what he called a Tiny Team with Tokens (or T3 for short). A T3 is generally one to five people (plus their agents). The idea is to point them at a well-scoped problem and leave them to execute, experiment, and validate their work. We have found that with the power of AI agents at their side, these teams tend to move really, really fast and can whip out quality innovation work in a matter of weeks instead of months.

Moving this fast in wildly different directions doesn't add up to much in the grand scheme of things, though. I'm sure most folks can relate to an AI agent running rogue on a task and just veering totally off course in a matter of hours. While the speed afforded to us by being in these small, agile teams is liberating, we also have to make sure that we're continuously working towards our larger, organization-wide goals. At Outshift we call these goals Big Hairy Audacious Goals (BHAGs) and each of our projects lives underneath one of these core goals. Think things like our Quantum projects, our work with the AGNTCY, or the Internet of Cognition -- these are all BHAGs. Teams get real room to experiment inside the BHAG structure, as long as the work stays aligned towards the goals outlined above it.

As we started operating with this new T3 model, we ran into a problem: the information you needed to stay oriented was scattered everywhere. Engineering truth lived in GitHub, plans and specs in Confluence, tickets in Jira, and decisions were buried in Webex threads and chat, with none of it talking to each other. Finding out what another team was actually up to meant going digging or scheduling yet another meeting. If we wanted to break down bureaucracy and keep teams moving fast, we'd need a new system to facilitate the work. We wanted leaders to be able to stay up-to-date on everything that's going on within the organization, engineering teams to be able to see what other T3s are working on, and managers to be able to dive into the details of what their team is doing without bogging them down with endless meetings.

We built a tool called TOME to help us with this. TOME (short for Total Organization Memory Engine) is a context management platform that helps us organize all of the work that happens at Outshift. It's built roughly on the premise of Karpathy's LLM wiki concept: instead of pointing a model at a pile of documents and pulling out chunks on every query, you have agents maintain a set of interlinked pages that stay current with the authoritative sources underneath them. Put simply, TOME is a living, breathing wiki of everything happening across Outshift, written and kept current with extensive help of agents, and serves as a means to point you to where the real work lives.

Building an AI wiki that actually helps

We chose to build the wiki ourselves rather than adopting an off-the-shelf tool, because we wanted to own two things:

  • Authorization: creating a system where project owners can play the role of data stewards, taking inspiration from Zhamak Dehghani's data mesh, where each domain owns its data as a product instead of handing it off to a central team. Access mirrors the BHAG, Area, and project structure, and only a project's stewards can pin and curate its stable pages. Everyone else can read them, but they can't change them.
  • Agent flows: how agents actually work with the wiki, which is more than a single integration. An ingest agent runs on a schedule or on demand, sending a cheaper model out to do a wide sweep of the work in progress, summarize the latest state into the dynamic pages, and drop back out. It's built to run often and stay cheap. That same agent is available as a chat to every user, with the whole wiki in context, so you can ask it questions, have it audit a page, or suggest edits on the spot. And on top of that, teams can bring TOME into their own coding agents over MCP, so the synthesized context follows the work into the environment where it's actually happening.

We leveraged our CAIPE instance to make this real. CAIPE gave TOME three things out of the box: a multi-agent runtime, a single authenticated front door, and distribution to the whole organization from day one. We didn't have to rebuild identity, hosting, or agent orchestration. We built the wiki on top of it.

Who owns what

Agents write a lot of TOME, but people still own the parts that need to be correct.

In the TOME wiki, we have three core page types: stable, dynamic, and hidden. Stable pages are pinned by a person and agents are told to leave them alone. They're the human-curated and truthful state of the project. Think things like "who is our target persona?" or "what is our team's charter?" or "who are the members of the team?" These are things that we don't want the agents fiddling around with. Dynamic pages, on the other hand, are the agent's raw synthesis, rewritten on every ingest as work gets done. This doesn't only include the agents' interpretation of project state, but also links out to real context like GitHub PRs and Confluence docs. Finally, Hidden pages are the agent's working memory where it can save information about what folks often ask about and what updates have occurred recently.

Pages are useful on their own, but the real payoff is in how they link together. TOME draws typed links between them, an edge that says this project depends on that one, or that a decision over here blocks work over there. The ingest agent proposes each connection and cites the source it read to justify it, so what you end up with is a navigable graph of how the work actually fits together, across teams and BHAGs. It's a small, almost old-fashioned semantic web idea, but it's what lets you start on any page and follow the real dependencies instead of guessing at them.

Similar ideas carry over to our glossary, where complex terms, acronyms, and internal jargon (e.g. MCP) can be defined once inside TOME and then surfaced everywhere else, giving in-app cues about what a term means and how it relates to others.

A single place for the scraps

In working with agents, we noticed that there is often a lot of useful context that can be found in the scrap documents one generates during a long agentic coding session. That could be a prompt, skill, RCA, a deploy note, a piece of an agent's memory, anything. It's valuable, but it's often unreviewed and probably wrong or stale in a lot of places.

Paper airplanes folded from handwritten notes drifting across a bright daytime sky. (light) Paper airplanes folded from handwritten notes drifting across a dark teal night sky. (dark)

We wanted to capture this within the TOME system, though, to make sure this context doesn't get lost. Users (or coding agents) can leave each other little breadcrumbs, pullable over MCP, and it never enters the wiki unless someone promotes it. All anyone has to say to their agent is "Julia shared a gist, grab it from TOME," and your agent has the important shared context in seconds. We've found this quite helpful for sharing notes internally.

How has it actually changed how we work?

The power of TOME isn't in the tool. It's in what happens to people's attention. Leadership reads TOME as a brief before a meeting, catching up on what's happening without anyone stopping to prepare it. It reminds me of the way Amazon runs meetings. In his 2017 letter to shareholders, Jeff Bezos describes banning slide decks in favor of narratively structured six-page memos that everyone reads silently at the start of a meeting, in a kind of study hall. TOME is our version of that pre-read, except the memo assembles itself.

Engineers can grab organizational context before they dive into code, not just the architecture but who depends on this project and how it's perceived. I've personally found that this helps me easily communicate goals to my coding agents and will often say "I want to build a new piece of software X which integrates with team Y, use TOME and figure out where these pieces are and who works on them." Before TOME this would have required manual research, but now TOME can derive the thousand foot view before I start getting into the details.

It isn't just my own projects, either. Building the Internet of Cognition, I've picked up how other teams structured their protocols from TOME, and I've seen what the quantum team was working on days after it happened instead of waiting for the next all-hands to hear about it. Being able to see what my teammates are working on keeps me feeling grounded and connected to the work around me, and it's given me a real respect for the scale of everything happening at Outshift.

I use it to keep people posted on what's landed on my own projects. I frequently ask my agent to update TOME with my recent pull requests. I used to do a lot of this by hand and a lot of my job revolved around having to code-switch in order to communicate my work for different audience types. Now my work is always visible to leadership and my teammates, and I don't have to translate it three different ways for three different audiences. They can have their agents translate it into more or less complex language depending on what they need.

The agents get a lot out of it too. A coding agent can split its context load between TOME and the primary sources, reading the synthesis to find where the relevant thing lives, then going to read the real thing itself. And honestly, the quiet wins are the ones I feel the most. We're spread across timezones, so being able to see what shipped overnight before my day starts, or catch what moved across the org this week before I plan mine, has been worth a lot.

A lighthouse over a harbor dotted with small boats, drawn in warm daylight. (light) A lighthouse casting a wide beam over a dark harbor dotted with small boats, drawn in high-contrast teal and orange. (dark)

The faster we move in small teams, the more staying aligned becomes its own kind of work. TOME is how we keep everyone on the same page.

We're taking a lot of our learnings from TOME and incorporating some of that thinking into Mycelium, which we just released as v3.0.0. Check that out if you get a chance!

And if you're curious how we built TOME, come find me on LinkedIn, I'm always happy to talk context.