The emergence of AI coding agents has changed my perspective on software development.

A few years ago, when I thought about using AI in development, I mainly imagined a process where you ask the model a question, receive an answer, copy the code, and then proceed with the work yourself.

This approach is rapidly changing now.

Current AI agents can check repositories, modify files, execute tools, investigate errors, and proceed with work toward the goal when given a task.

When a developer starts an agent for a task, can another developer add background information? Can someone convey a change in direction to an agent that is working on a task?

Can another person review the results and take over the task? Can work be passed from a human to an agent and back to a human without losing context?

As development teams start to operate multiple AI agents alongside human developers, the importance of these questions is increasing.

The challenge is not just to assign tasks to AI agents.

It's about considering how humans and agents can collaborate without the conversation, prompts, terminal, and progress reports becoming scattered.

What does collaboration between humans and agents specifically entail?

I believe there is an important difference between using AI and working with AI agents. Asking ChatGPT for API explanations is AI support.

Receiving function proposals from an AI coding tool is also support. However, agents can act differently. Rather than waiting for individual instructions from me, agents can take on larger goals and execute multiple steps toward achieving them. This changes the workflow. For example, suppose a developer creates a task like the following. Add authentication to a new API endpoint, update the tests, and ensure that existing endpoints continue to work. Agents can investigate the repository, make changes, run tests, and report the results. However, developers may not necessarily step away from the process. At some point, they might realize that the authentication requirements need to be implemented in a different way. Another developer might also notice edge cases. A reviewer might ask for additional tests. A product manager might change the acceptance criteria. Agents need to be able to adapt to such changes. What I mean by "collaboration between people and agents" is this. People don't just give an agent a prompt once and wait for the final answer. People and agents are both involved in an ongoing task. Can multiple people participate in the same AI agent session that is currently running? This is one of the particularly interesting questions in agent-assisted development. Suppose one developer starts an AI agent to implement a feature. The agent is in the middle of the implementation. Another developer looks at the task and realizes that there are constraints in another part of the system, so the original approach won't work. In a traditional workflow, that developer might send a message to the first developer, who would then return to the terminal and give instructions to the agent. This would involve too much unnecessary handoff. A better approach is to share the task itself as a shared context. Rather than treating the session with an agent as a personal conversation, we keep requirements, discussions, execution history, and reviews tied to the same task. This is one of the core ideas behind Sharkly. Sharkly presents a work management system for people and agents. It consolidates requirements, task status, discussions, execution records, and reviews into one place, rather than dispersing them across individual prompts or terminal sessions. That doesn't mean everyone will input into the exact same chat screen at the same time. In fact, Sharkly's documentation clearly distinguishes between independent Agent Chat and collaborative work centered around tasks. Independent Agent Chat belongs to the person who created the session. On the other hand, in a task-based workflow, the Task becomes a shared record for people to collaborate on work.

This difference is important.

The goal is not necessarily to gather everyone into one large chat.

The goal is the following.

Everyone proceeds with work based on a common trusted information source.

The flow of collaboration between people and agents.

A realistic development workflow would take the following form.

Product requirements → Human planning → Agent execution → Human feedback → Agent adjustment → Human review → Completion.

Let's look at it more specifically.

Step 1: A person defines a task.

Developers or product managers create tasks that describe the necessary work.

Tasks can include goals, descriptions, acceptance criteria, priority, status, and other project information.

In Sharkly, you can also set a person as the work owner for a Task and assign Agents or Crews to execute it.

Step 2: Agents start the work.

Agents receive the task context and begin execution.

Execution related to the task includes the task description, current status, project and sprint information, recent comments, instructions for the Agent, skills, repositories, environment settings, and Runtime configurations.

This is an important point. Agents do not act based on isolated sentences.

They have a structured context about the work.

Step 3: A person adds context.

During the work process, a developer might notice something important.

"Please do not change the existing authentication middleware. The mobile client still depends on it."

This information needs to be incorporated as part of the work.

Sharkly's task comments are designed precisely for such discussions. Comments can include new requirements, constraints, points raised during reviews, decisions, files, screenshots, and instructions for the Agent assigned to the task.

Step 4: Agents continue the work.

Based on comments, you can start additional execution for the Agent responsible for the Task.

In Sharkly's execution model, comments from members who meet the conditions can add additional work to the queue even if another execution is in progress. Furthermore, even if comments are made in a short period, pending tasks are aggregated to prevent duplicate executions for the same Agent and Task.

This is significantly different from the method of starting a new conversation with an AI each time requirements change.

Step 5: Another person reviews the results

The agent completes the task.

Next, someone needs to verify the content.

Was the implementation correct?

Did the tests pass?

Did the agent misunderstand the requirements?

Are there any points that need correction?

The agent can leave the result as a Task comment linked to its execution. More detailed execution information can be confirmed from the execution log.

In this way, people become reviewers rather than just waiting for AI outputs.

Why is context a challenge in project management?

I believe this is the most significant change that AI agents bring to the development workflow.

Software development involves multiple people, tasks, dependencies, priorities, and decisions, so project management has always been necessary.

When agents are added, another challenge arises.

Continuity of context.

AI agents may fail even if they perform excellent work, due to lacking the necessary context.

Requirements may have changed.

Another developer may have made related architectural decisions.

An edge case may have been found.

Previous attempts may have failed.

If such information exists only in individual chats or terminal sessions, other team members may not be aware.

Here, project management goes beyond a simple task list.

Tasks can become shared memory about the work.

Sharkly's Task retains the goal, status, owner, comments, attached files, activities, and execution information of the agent.

A place for both people and agents to backtrack is created.

Features required for an agent-oriented project management tool

From this point on, I think the definition of an agent-oriented project management tool differs from traditional project management software.

It's not necessary to replace all the functionalities of tools like Jira.

However, it is necessary to assume as a premise that the agent is an entity capable of actually performing tasks.

If I were to focus on such features, I would pay attention to the following.

1. Tasks can be assigned to both people and agents.

The system should not be bound by the premise that the task executor is always a person.

It is necessary for the system to clearly express that people take responsibility and agents perform tasks.

Sharkly's task model supports People, Agents, and Crews as task owners.

2. Maintain context.

Agents should not receive separate prompts each time but should be able to access relevant task information.

This includes requirements, comments, repositories, skills, and other execution settings.

3. Record execution history.

When an agent makes a change, the team must be able to understand what happened.

Sharkly separates the workflow status of a Task from the execution status of an Agent, maintaining real-time information such as queued, in progress, completed, failed, and canceled.

4. Allow people to intervene.

The agent's actions should not be a black box.

People should be able to add context, answer questions, convey corrections, review results, stop execution, retry tasks, and reassign tasks.

Sharkly's workflow supports adding comments, states requiring human intervention, cancellation, retrying, and reassigning tasks.

5. Enable handover.

The person who started the task does not necessarily have to be responsible until the end.

Additionally, the agent that started the work does not necessarily have to handle the next stage.

The project management system must make these transitions visible, not hiding them in personal conversations.

From a single agent to an agent team.

Once we stop considering only a single agent, the next steps become even more interesting.

Imagine a software project where agents with different roles participate.

One agent is responsible for implementation.

Another agent specializes in testing.

A third agent handles documentation.

There is also an agent for investigating issues in the production environment.

Then, the question changes to:

How should we coordinate all of them?

Sharkly uses the concept of Crew for this purpose.

Crew is composed of a leader Agent and a combination of other Agents and People. This allows complex Tasks to be assigned to reusable teams rather than individual performers.

In this way, it approaches more closely a development team composed of members with specialized skills, rather than "AI-driven auto-completion."

For example, the following process:

Feature Request

↓

Plan

↓

Implementation Agent

↓

Test Agent

↓

Review

↓

Documentation Creation Agent

↓

Human Approval

Humans do not need to manually oversee all transitions in the process.

What's important is that the workflow remains connected.

Agents are not project managers

Another important distinction is that agents should not be considered as managers of the entire project just because they perform tasks.

The responsibility for deciding the following remains with humans.

What should be created?

Why create it?
What constraints are important?
What should be prioritized?
What criteria define acceptability?
When can it be released?
• Agents can perform the execution.

The project management mechanism can coordinate the work.

Humans can make important decisions.

In reality, this division of roles is one of the reasons I believe project management based on agents has meaning.

Our goal is not to replace teams with AI.

Rather, it is to enable AI systems with higher capabilities to work alongside teams.

Practical workflow where humans and Agents collaborate

Suppose a team adds a new payment method to an application. I imagine a workflow like the following. 1. Create a requirement The developer creates a task describing the content of the payment integration and the acceptance conditions. 2. Assign the implementation The task is assigned to an appropriate coding agent. 3. The agent investigates The agent examines the repository and understands the existing payment architecture. 4. The agent implements The agent makes necessary changes and runs related tests. 5. The developer intervenes The developer notices that the implementation does not consider the existing mobile workflow. The developer adds this information to the task. 6. The agent adjusts The agent receives the additional context and continues the work. 7. QA reviews Another person reviews the implementation and requests expanded test coverage. 8. The agent makes additional adjustments The agent performs the work again based on the new requirements. 9. A person approves The developer reviews the final result and decides whether it is ready to be merged. Now, let's look back at what happened. There was not just one huge prompt. It was not a fully autonomous AI process. It was not that a person manually copied all the context between tools. Instead, the work progressed through shared tasks. This is the model I find most interesting. Making the agent's work part of the team's work AI agents beginning to take on actual development tasks mean that we need to think beyond the scope of the agents themselves. We need a place to maintain requirements, the context behind them, conversations, execution history, and the final deliverables. Otherwise, the work would simply become something tied to a single terminal or private AI session. In this regard, Sharkly.ai takes an interesting approach.

Instead of placing all sessions around agents, Task becomes a shared workspace for that work. People add context and make decisions, while the assigned agent handles the execution.

Each element in the workflow has its own role. Agent defines how to handle specific types of work. Computer provides the environment to run that work. Runtime handles the actual execution. And Task connects that work to a shared context that other team members can follow.

This separation is useful. It eliminates the need to create agents from scratch for each task.

The team can prepare agents for backend development, testing, and documentation creation. Each agent can have its own set of instructions, Skills, repositories, environments, and runtime configurations, allowing specific requirements and contextual work details to be provided for individual Tasks.

This creates a different workflow compared to simply opening a new AI chat for each task.

Agents become reusable capabilities.

Task represents a single piece of work.

And team members continue to be involved in the process.

For teams attempting to utilize multiple agents, this distinction will become increasingly important. Challenges are not merely about agents completing tasks; they are about ensuring that other team members can understand, review, adjust, and take over the work. The work should be made accessible for other team members to understand, review, adjust, and take over.

What to do when an agent gets stuck?

This is also a scenario where human-agent collaboration becomes crucial.

Agents can also get stuck.

They may face situations such as test failures, insufficient credentials, ambiguous requirements, dependency issues, or situations requiring human judgment.

A helpful system should not hide such situations.

It should visibly indicate when human intervention is needed.

At Sharkly, agents can put tasks on hold for waiting human responses or reviews. Failed or stalled tasks can also be displayed as items requiring attention in the Inbox. The responsible person can then open the task, respond, review the results, retry, or decide to reassign the work.

This is an essential part of the workflow.

Autonomy is not about people disappearing.

It is about directing people's attention to where it is genuinely needed.

From AI assistants to AI team members

I think that the time is approaching when calling all AI development tools "assistants" will no longer adequately represent their actual nature.

Traditional assistants wait for human instructions.

Agents can be entrusted with executing clearly defined tasks.

This leads to the emergence of a completely different collaboration model.

In the future, teams may have members such as:

human developer

AI coding agent

test agent

research agent

document creation agent

operations agent

And all of them may contribute to the same product.

The challenge is not necessarily finding an agent that can write code.

There are already many excellent options.

Who assigned the task?

What context did the agent receive?

What was changed?

What needs to be reviewed?

What should be done next?

What's interesting about AI agents is not just whether they can write more code.

It's whether the development workflow is prepared to have agents as actual participants in the work.

People set the goals.

Agents execute the tasks.

Another person adds context.

Agents respond to that context.

Reviewers confirm the results.

The next step can be taken over by another agent.

And the team maintains a connection with the entire process.