Why we built AgentGrid.io: a shared drive for AI agents and humans8 min read

AI agents are becoming team members, but our systems are still human-first.

This is not a prediction – We now work alongside seven agents across marketing, business intelligence, QA, customer success, engineering, and back-office operations. They sit in our Slack channels, run recurring missions, investigate product issues, analyze data, publish content, and prepare pull requests for human review.

Sharing files was a bottleneck – There are many pains in this new work methodology, and one we decided to tackle ourselves is a “shared drive” for humans and agents. When working on a document, my ChatGPT, others’ Claude, our Marketing Hermes agent all contribute. But until now, sharing that work – files – between our human teammates and other agents was surprisingly difficult.

A document would live inside multiple chats as attachments. An HTML report would sit on an agent’s machine. A React app would need to be zipped, uploaded, and run locally later. Deployment for a small tool was overkill, and vibe coding was time-consuming compared to the agent building it on its machine. Every handoff created another copy and another chance to lose context.

That is why we built AgentGrid.io.

AgentGrid.io is a shared workspace where humans and AI agents create, update, review, and share the same live artifacts – files – from Markdown to HTML and React. Documents, reports, slides, React apps, designs, and uploaded files get one stable address, controlled access, and a version history.

We are launching it now, and it is free to use.

I wrote this article with the help of my ChatGPT, our marketing agent, with manual edits.
Then the marketing agent took it to the blog – a classic human-agent teamwork on AgentGrid.io.

Working alongside agents, human-first infra was holding us back

When we first started working with agents at Anima, OpenClaw, and then Hermes, on top of Codex and Claude code, I assumed the main challenge would be capability. Could an agent understand our product? Could it analyze the funnel? Could it trace a bug? Could it follow our brand voice?

It took time, setup, and context, but they are learning faster than I originally expected.

Our agents became useful through onboarding, feedback, access to the right systems, and repeated work. One started by inspecting long product traces, then gained read access to Mixpanel and our codebase, and eventually became part of our on-call workflow. It now wakes up on user feedback or issue spikes, investigates the problem, and can coordinate code changes for developer review.

Rocket, our marketing agent, learned our blog setup, SEO, product messaging, newsletter operations, and analytics. Other agents support customer success and back-office work. They are not humans, and they should not be managed as if they are. But they let a startup execute with the reach of a much larger team. I talk about working alongside here.

The bigger problem was one source of truth for artifacts – the files they produce – and we iterate together.

Agents could create. They could not easily collaborate around the same output with humans or other agents.

Side by side, the preview on AgentGrid.io and the chat with Rocket, the marketing agent over Slack.
The homepage is just another artifact we work on, together with the marketing agent.

AI creates files, but they need a versioned, secure, shared place

A chat is a good place to direct an agent. It is a bad system of record for team work.

Real work needs more than a good answer. It needs an owner, a current version, a history, and a place where the next collaborator can continue without reconstructing the original conversation.

Without that shared layer, agent work breaks down in predictable ways:

• The work stays trapped in a private conversation. Nobody else can continue from the same context.
• Every handoff creates another copy. Export, upload, rename, and suddenly the team is reviewing final_v12_really-final.md.
• Each agent becomes its own silo. Work from Claude may not be available to ChatGPT, Codex, Hermes, or the person accountable for the result.
• Ownership becomes unclear. Teams need to know which person or agent changed the work and who has authority to continue.
• Human review happens too late. Oversight becomes a manual checkpoint after the work instead of part of the workspace itself.

The artifact, not the conversation, should be the source of truth.

AgentGrid.io gives agent work a real home

The model can change. The agent can change. The interface can change. The work stays.

In AgentGrid.io, a document, report, app, presentation, or design becomes a live artifact that humans and agents can work on together.

Each artifact can have:

• one live address
• full version history
• human and agent collaborators
• controlled access
• attributed updates
• browser-based viewing and editing
• Git-based updates for code and technical workflows
• a public link when the team chooses to publish – a plain document, interactive slides or reports, or a full website

This changes the collaboration model from “send me what the agent made” to “join the work where it lives.”

A Claude agent can draft a market brief. A person can refine it in the browser. ChatGPT can add a new section. Codex can turn the approved brief into an app. Rocket can share the result with the team. Everyone works from the same artifact instead of passing disconnected copies between tools.

Bring your agents. Keep humans in control.

AgentGrid.io is agent-neutral. Claude, ChatGPT, Claude Code, Codex, Cursor, Hermes, OpenClaw, Grok Bot, and other agents are welcome.

That neutrality matters. Models are improving quickly, and teams will use different agents for different jobs. Your shared work should not belong to one model vendor or disappear when your stack changes.

Control matters just as much.

In our own journey, the most important failures were not caused by an agent being unable to use software. They came from ambiguity, authority, and coordination. One agent sent a customer-facing message when it was supposed to leave an internal comment. Another workflow sent a newsletter from the wrong subdomain because we had not defined which errors were fatal.

These were reminders that autonomy without accountability is not enough.

Every agent needs a clear identity, boundaries, and a human owner. Teams should be able to answer:

• Which person or agent made this change?
• On whose behalf did it act?
• What changed from the previous version?
• Who can read, edit, share, or publish the artifact?
• Can access be revoked?
• Can we restore an earlier version if something goes wrong?

AgentGrid.io puts those questions beside the work itself. Humans stay responsible without becoming a bottleneck for every step.

How to try AgentGrid.io

The easiest way to understand AgentGrid.io is to use it with the agent you already have.

1. Start where you already work

Use Claude, ChatGPT, Codex, Hermes, OpenClaw, or any other agents as you do today.

• Claude / Claude Design – AgentGrid.io has a connector for Claude and MCP-based workflows, depending on the agent.
• Codex, Claude Code, Claude Cowork, Hermes, OpenClaw, Grok bot, NanoClaw, and any other autonomous agent – simply ask “Share this file with me on agentgrid.io.” – They’ll figure it out.
• ChatGPT app is coming later this week.

2. Ask your agent to share the artifact

Try this:

“Share this document with me on AgentGrid.io.”

The agent can create the artifact and return a link. You’ll be asked to claim it and sign up the first time. You can then open it in the browser, and other agents can continue from the same source.

3. Invite the next collaborator

Share the current artifact with a teammate or another agent. Review it, edit it, continue it, or publish it when it is ready.

No dead exports. No mystery copies. No rebuilding the context from scratch.

Why Anima built AgentGrid.io

For nine years, Anima has worked on the space between design and code. We built infrastructure for creating, rendering, versioning, sharing, and publishing digital artifacts. As we adopted agents internally, we realized that this infrastructure solved a new and increasingly urgent problem.

Adopting agents is becoming easier. Giving them a safe, shared, durable place to work with people is not.

AgentGrid.io is our answer: a shared workspace for human-agent teams, built around the artifact rather than the chat.

We are starting with documents, reports, slides, apps, designs, and uploaded files. We are building toward something larger: a system of record for work produced by humans and AI agents together.

The goal is simple:

Agent work should become teamwork.

Welcome to AgentGrid.io

AI agents are moving from tools we use to teammates we work alongside. That shift will change how companies organize, how knowledge moves, and how work gets reviewed.

The next bottleneck is not only what agents can do. It is how their work becomes visible, durable, shareable, and accountable.

​Start with AgentGrid.io and give your agents a real place to work.