The team workspace for AI agents - an architecture walkthrough

Most AI agent setups have the same structural problem: the agent is stateless and the work is unstructured.

You give an agent a prompt. It does something useful. The conversation ends, and everything it learned — the decisions, the context, the intermediate state — disappears. Next time you start over. You re-explain. You re-paste. The agent is capable. The architecture around it isn't.

Worse, if you're on a team: nothing compounds across people. Your colleague's agent conversation yesterday doesn't inform your agent's conversation today. Everyone is using AI in ten private Claude tabs.

We spent two years building product tools with AI before we understood this clearly. The bottleneck was never the model. It was the absence of a shared, persistent workspace that both humans and agents could read from and write to over time.

So we built Maskin — an open-source team workspace where AI agents are first-class participants in structured product work.

How we got here

We've built Sindre three times.

Sindre 1.0 was a chatbot. Mid-2024. It plugged into HubSpot, read customer service emails, and drafted replies using past tickets as context. I didn't really know how to code back then — we built it in a low-code automation tool. The foundation was shaky. Sometimes it gave a great answer. Sometimes it hallucinated like crazy. After enough coin flips, we stopped trusting it even when it was right.

Sindre 2.0 was a pivot. Early 2025. Better foundation — I'd started learning to code, the models were better, and we had a real team. We turned it into a digital coworker, a kind of AI Product Manager with a notetaker, a text editor, and the insight-bet-task primitives that are still in Maskin today. We spent more than a year on it. It worked, sort of. Different people with different coding experience had built different parts, and the bugs piled up faster than we could kill them. But the real problem was deeper: Sindre 2.0 was the wrong shape. A single digital coworker, helping one person at a time.

The conversation that changed everything was a Friday afternoon. Around 3 PM. Seb and I were wrapping up a working meeting when he spent the last five minutes pitching an AI-native suite of apps — agent-first email, agent-first CRM, a whole stack built for the agent era. I thought it was crazy. We'd spent more than a year on Sindre 2.0.

I went back to my desk and tried to work. The idea wouldn't leave me alone.

Slowly, things started clicking. I wouldn't build a CRM first — I'd build the machine that could build the CRM. The insight-bet-task primitives we already had, structured as generic objects with relationships, could become anything. Insights, bets, tasks by default. Person, company, deal if you added them. Meeting notes, extensions, whatever. A workspace full of those objects, linked together, is a graph — which is exactly the right shape for agents to read from and write to.

Two days earlier, I'd figured out how to run Claude Code inside a container so it could run 24/7 in a clean environment. That slotted in as the agent runtime. Triggers — time-based and event-based — meant agents didn't need me awake to do anything. MCPs meant they could reach into the tools we already used.

Everything we'd circled around with Sindre 2.0 but couldn't quite do snapped into place.

I opened Claude Code and started a planning session. Three hours later it was 8 PM. I was the last guy in the office and I hadn't eaten. The three hours had felt like a few minutes. I went home, kicked off the build, and by the next morning the foundation was there.

I messaged Seb. He was surprised. To be honest, so was I. It didn't feel like a pivot. It felt like a convergence. No code survived. Every idea did.

We called it Maskin.

The shape of the work

A prompt is not a job. Work is a loop.

• Insights come from customers, meetings, data. The raw signal.
• Bets are what you choose to do about them. The judgment calls where taste decides.
• Tasks are how bets get executed. Where agents do the heavy lifting.

And the loop closes: outcomes from tasks become new insights, which sharpen the next bet. Humans own the bets. Agents own the tasks. Insights flow between them.

What it actually is

Maskin gives agents (and humans) a shared workspace built on typed objects — insights, bets, tasks, contacts — with explicit relationships between them. Think of it as a product operating system for Claude and other AI systems: shared memory, shared context, and shared work that any agent can plug into.

[VISUAL: architecture diagram — typed objects connected by relationship edges, with agent sessions reading/writing]

Agents connect via MCP (Model Context Protocol). They don't get a custom API or a plugin system — they use the same standardized tool interface that works with Claude, Cursor, or any MCP-compatible client. An agent interacting with the workspace looks like this:

// Agent reads the current state of a bet and its linked tasks
{
  "tool": "get_objects",
  "params": {
    "ids": ["bet-uuid-here"]
  }
}
// Returns: the bet object, all relationships, and connected objects
// — the agent sees what informed the bet, what tasks exist,
//   and what happened in previous sessions

Agents run in sandboxed sessions triggered by cron schedules or state changes. A session might fire every morning, or when a bet's status flips to active. Each session gets full access to the workspace graph — including what previous sessions wrote. Context compounds instead of resetting every session.

Here's what a cron trigger definition looks like:

{
  "type": "cron",
  "schedule": "0 8 * * 1-5",
  "actor_id": "insight-scout-uuid",
  "prompt": "Check sources, cluster new signals, link to active bets"
}

That's an agent that runs at 8 AM on weekdays, reads whatever is in the workspace, and writes back findings as typed objects with relationships to existing work. Monday's run builds on Friday's output. No re-briefing.

The stance

Two more principles behind the architecture:

Agents do the work. Humans make the calls. Agents monitor, cluster, propose, draft, schedule, execute. Humans decide which bet is worth making, which direction is wrong, what ships. Taste still decides — that's the part that doesn't delegate.

The workspace is the memory. No separate "memory layer." The structured work is the context. Every object, relationship, and status change is durable state that any agent or human can read. Agents get better at their job as the workspace fills up — not because of fine-tuning, but because the graph they operate on is richer.

Why open source

Code isn't a moat anymore. AI can write anything you need if you know what you want. What's worth something — the real work — is figuring out what to build.

We're builders by heart. Writing code was never the goal. The goal is solving problems, shipping products, running a business. Maskin takes the coding load off so we get to spend more time on the harder part: figuring out the right shape for teams and agents to work together.

We'd rather do that in public, with a community pulling on it, than in private.

Run it yourself

git clone https://github.com/sindre-ai/sindre-ai.github.io.git
cd sindre-ai.github.io
docker compose up

Bring your own LLM API key. No cloud dependencies. All data stays on your machine.

Maskin is Apache 2.0 licensed, self-hostable, and built with TypeScript, Hono.js, React, and PostgreSQL.

Repo: github.com/sindre-ai/sindre-ai.github.io

Star it, try it, tell us what breaks.