Hello, world. Meet Markbase.

Hello, world. We’re Markbase.

We’re building an AI software factory for development teams: a repeatable way to build and maintain software with coding agents, built on what the team already knows. We’d like to tell you why.

Teams learn by doing

Think about a software product you know well. You probably know a few things about it that would be hard to discover by reading the code alone.

You know why the team chose that database. You remember the incident that led to a particular limit. You know which customer depends on an old feature, and why it needs to stay around a little longer.

That understanding grows through the work. People investigate problems, discuss tradeoffs, review changes, and see what happens when their decisions meet the real world. Over time, the team builds a shared body of knowledge about its product and business.

In management talk, this is usually called “institutional knowledge”. It helps teams make better decisions, avoid repeating mistakes, and understand what to do next.

As we bring coding agents into our teams, we need to keep that process working.

Agents need the team’s context

We’re excited about what coding agents make possible. They can explore an idea, investigate a problem, write a change, and test it. It’s a wonderful time to be building software.

They also create a new challenge for the team.

An agent can finish a task while the reasoning behind its work stays inside a session. The change reaches the repository, but what happened, what was tried, and what was learned may never reach the next contributor. The next person or agent has to work it out again.

The opposite happens too. An agent starts a task without the team’s decisions, conventions or history, and makes a choice the team ruled out months ago.

We call that knowledge the team’s context: the decisions, the history and the way the team works. We think it belongs outside any single agent, where people can read and steer it and every agent can start from it.

What we mean by a software factory

A software factory is a repeatable process for building and maintaining software with AI agents. The team defines how the work should be done, gives agents the project knowledge they need, and decides which checks and reviews are required along the way.

Markbase is that factory, built around the team’s context. It has three parts.

Shared context. The team’s decisions, conventions and history live in one hosted workspace of Markdown documents. Claude Code, Codex, Cursor, Antigravity CLI, Pi and any other MCP client read and write it. When a change merges or an investigation finds a problem, an agent records what changed, the cause and the fix, so the next task starts from what the team has already learned.

Shared skills. The team writes skills for the work it does again and again, such as reviewing a change, writing tests or investigating an alert. Every agent uses the same version, and when someone improves a skill, everyone gets the improvement.

Agent jobs. An alert, a ticket, an email or a schedule can start an agent with the context it needs. The agents run on machines the team chooses, with only the access it gives them. Work that has to wait, such as a feature in customer testing, keeps its plan and a due date, so it can be picked up again when the time comes.

Put together, they make a loop. A production alert starts an investigation, the agent reads earlier incidents and the relevant decisions, and a tested change goes up for review. What it found becomes part of the incident history, and the next investigation starts from a better place.

It follows the way your team works

A factory shouldn’t make a team change how it gets work done. Take branches and pull requests: when an agent writes the design for a feature on a branch, that design stays with the pull request. Agents working from main don’t see it until it merges, so they don’t build on plans that might still change.

People still set the direction, review the changes and make the calls that need judgement. Agents take on more of the work around them.

Inside the Factory

Our mission at Markbase is to make sure the growth of AI doesn’t come at the cost of our collective ability to learn. Every task should leave something behind for the next one, whether a person or an agent did it.

This blog is where we’ll share how we’re building Markbase, the decisions behind it, and what we’re learning about running coding agents as a team.

If this sounds like something your team needs, come meet Markbase or book a demo. We’d love to hear how you’re bringing agents into your work, what’s going well, and where keeping everyone on the same page still takes effort.

Thanks for being here. We’re looking forward to building this with you.