What Would an Agent-Native Workspace Add to GitHub?

[lucdev01234-png]

🏷️ Discussion Type

Question

💬 Feature/Topic Area

API

Body

GitHub is already making AI agents part of the development workflow, with coding agents, agent sessions, and agentic workflows becoming more integrated into repositories.

But as teams start using multiple agents, I wonder if the next challenge is having a proper agent-native project workspace.

For example:

Shared context across different agents
Tasks that can be assigned to specific agents
Multiple agents working in parallel
A clear history of what each agent did
Human review before changes are accepted
Context that follows the work instead of staying inside one agent's session

I've been looking at Sharkly.ai, which takes an interesting approach by putting human teammates and AI agents into the same project workspace.

For developers using GitHub with Claude, Codex, Copilot, or other coding agents, do you think GitHub already provides enough coordination?

Or is there still a need for an agent-native project workspace that sits above individual coding agents?

[nirav-gajera]

Hi @lucdev01234-png ,
Good question — GitHub is definitely building out agent capabilities (agent sessions, task delegation, workflow automation), but there's still a coordination gap for multiple agents working together.

What GitHub currently has:

• Single-agent sessions (Copilot Agent can handle a task in one go)
• Individual agent access to a repo (read/write at the repo level)
• Audit logs showing what changes were made
• PR review (humans can gate changes)

What's missing for multi-agent workflows:

1. No cross-agent context hand-off. If Agent A starts analyzing a problem and Agent B needs to continue, there's no standardized way to pass context. Agent B either re-reads everything or starts fresh.

2. No task queue/assignment system. Currently you manually invoke an agent for a task. There's no "break down this epic into subtasks and assign to Agent X, Agent Y, etc."

3. No inter-agent communication. Agents can't ask each other questions or validate each other's work before a human sees it. It's agent → repo → human, not agent → agent → human.

4. No persistent agent identity. You can't track "this refactoring was done by the linting agent, this feature by the feature-dev agent" — it's all just changes in the PR.

5. No shared reasoning/planning. Each agent session is isolated. If two agents are working on related tasks, they don't see each other's plans and can work at cross-purposes.

What an agent-native workspace would add:

• Shared memory/context store — agents read/write to a shared knowledge base (not just code, but "we decided this API would work like X" or "this bug is caused by Y")
• Task graph — break work into DAG of dependent tasks, assign agents, track dependencies
• Inter-agent validation — Agent A does a change, Agent B reviews it for compatibility before it hits a PR
• Agent personas — track which agent did what for better understanding/rollback
• Async orchestration — queue up work for agents to pick up, not just synchronous "run agent now"

Reality check though:

GitHub could layer this on top of their existing structure (PRs stay as the final gate, agents coordinate within the repo's branches/workflows). But it's also a fundamentally different problem than "make coding easier" — it's "coordinate multiple AI workers on complex software projects." That's closer to a project management tool than a code host.

Sharkly's approach of a dedicated "agent workspace" makes sense if you're specifically optimizing for multi-agent collaboration. GitHub's approach (adding agents to existing PR/branch workflows) is more conservative — keeps the human-facing UX stable, agents are just another tool.

My take:

GitHub will probably continue adding agent capabilities piecemeal (better context, task delegation, agent-to-agent communication as layers). But if you need true agent orchestration today, a dedicated tool probably gives you faster results. Once GitHub's agent capabilities mature, it'll likely absorb most of this functionality into the platform.

For now, if you're running multiple agents, the gaps aren't unfillable — they're just manual. You orchestrate: tell Agent A to do X, review the code, tell Agent B to do Y. Slower than automated orchestration, but it works.

[v-coder247]

Hi @lucdev01234-png, thanks for sharing with the community!

Unfortunately, we currently do not allow self-promotion, advertising, or solicitation in Community Discussions. We want to make sure there is space for users to ask questions without overwhelming them with other conversations. Thank you for helping us maintain a productive and tidy community for all our members.