Essay ·

I Built a Superagent to Bring My Work as a CEO Together

AIAgentsWork

I was already using AI for a large part of my work.

Development, code review, algorithm research, customer proposals, fundraising materials—each had its own session. Several tasks would run at once. One agent was writing code, another was reading papers, a third was organizing meeting notes, and another was waiting for me to confirm the next step. As the CEO of an AI startup, I was used to working this way. It helped me get a great deal done.

But with a dozen windows open, I began to run out of attention.

When development finished, I had to hand the result to a reviewer. When the review found a problem, I had to take it back to the original session. While checks ran, I would switch to something else, then remember to return. A customer would add a requirement, and I had to pass it to the agent writing the proposal. Fundraising materials would change, and I had to remember which conversations needed the update.

Every agent was working. The handoffs and follow-ups still ran through me.

I spent a surprising amount of each day checking who had finished, who was waiting for me, and who could keep going. Even during meetings, I would wonder whether another task had stalled.

I started wondering whether I could delegate this part of the work too.

So I built a Superagent workbench for myself. I call it Renyi, or EnyAgentDesk.

My expectations were straightforward. Understand what matters to me now. Take on the goals I assign. Organize the work that follows. Keep track of unfinished matters. When I need to make a decision, bring me the context along with the question.

I am now bringing my work into this one place.

The personal Superagent workbench
The personal Superagent workbenchView full diagram ↗

When I open the workbench in the morning, there are a few things I want to know.

Which projects have moved forward? What was completed from yesterday's assignments? What is still waiting for an outside response? Which questions need an answer from me today?

Those updates arrive in many places. GitHub holds code, reviews, and check results. Feishu holds discussions, documents, tasks, and meetings. WeChat carries conversations with customers, partners, and investors. A single project often spans several of these channels.

The workbench brings this information in and uses the existing context to judge how it relates to work already underway.

A message may simply add background, or it may change a project's next step. If someone says the materials have arrived, the next step is to review them. If a meeting moves, preparation needs to move with it. If a check fails, the corresponding task needs to pick it up.

This takes an understanding of context. Who said it? What had already been discussed? Who is responsible? Which decisions have been made? What has actually changed?

I want the coordinating model to make these judgments. As models improve, they should become better at understanding these relationships. The workbench keeps the background, progress, and results available so that subsequent work has something to build on.

I use one main conversation to discuss, delegate, add context, and change priorities. Separate execution sessions carry out the individual tasks behind it.

I finally have somewhere to see both the work itself and the AI agents helping me move it forward.


Software delivery makes the change especially clear.

Getting AI to write code was already easy. What kept pulling me back was the long sequence of work that came afterward.

An implementation needs checks and review. Review findings need fixes, followed by another CI run. Sometimes the problem is in the environment. Sometimes the original design missed a case. When several repositories are moving at once and every transition waits for me, progress depends on when I can switch back to the right window.

Now I give the workbench the goal together with the delivery requirements.

For example, a repair may need implementation, checks, review, and a merge. Within the scope I have assigned, it should carry the task forward. A clear review finding should lead to a fix. A failed CI run should lead to reading the logs, investigating the cause, and checking again. While checks are running, it should remember what it is waiting for and resume when the results arrive.

A pull request that meets the repository's requirements and the authorization already given can proceed to merge.

There are many points in this sequence where I have no reason to say “continue” again.

I am more useful when a choice could change the direction of the work. Is the original approach still worth pursuing? Should the scope expand? Could a repair affect an active business process? Is it time to release? These decisions need my judgment and accountability.

When the system asks me, it should have the situation organized. How far has it got? What is blocking it? What are the workable options, and what would each affect? My answer goes back into the same task, and execution continues.

Delivery also needs to reach a result I can use. After code is merged, there may still be a release to publish, a running system to update, and a feature to verify. The expected endpoint belongs in the assignment.

In developing the workbench itself, we have already run real workflows covering automated review, fixes, checks, and merges. The change I can feel is that I am beginning to delegate a complete stretch of work.

Routine progress stays in the workbench, available when I want to inspect it. Important results come back to me, along with the decisions that require my responsibility.


During the day, I might be in meetings, or I might want two uninterrupted hours to think through a problem.

I want the other work to continue at its own pace.

Some tasks are executing, some are finished, some are waiting for a reply, and some have reached a scheduled time for another check. Waiting has a place in the workflow too. The system remembers who or what it is waiting for and when to look again. New information lets it continue with the existing context.

This matters in fundraising and customer work as well.

An investor meeting involves a good deal of preparation. Research the firm and the people attending. Review previous contact. Understand their interests and prepare the relevant materials. After the meeting, connect the discussion and agreed actions back to the project, prepare follow-up materials, and track responses.

I am gradually connecting these steps into the same ongoing workflow.

When I next review progress with a firm, I can see what we discussed, which materials are ready, and what still needs my judgment. A customer pilot follows a similar pattern, from requirements and proposals to pilot feedback and further work. The context should accumulate as the relationship develops.

I focus on important conversations, business judgment, and negotiation. The system handles the preparation, organization, and follow-up around them.

This is the working principle I have wanted to put into practice—automate routine work and organize major work as projects.

Recurring collection, checking, and preparation can become dependable workflows. Fundraising, customer pilots, and platform delivery can run for days, weeks, or longer around clear goals, with progress, decisions, and next steps retained.

When a conversation ends, the work still has somewhere to continue.


I decide which areas the workbench pays attention to.

At this stage, they include fundraising and customers, platform operations, model and strategy research, and improvements to AI tools and working methods. The priorities can change as the company moves into another stage. Some projects deserve more attention, some can wait, and work that no longer has value can end.

Those adjustments should flow from the same entry point I use every day.

I can also open an individual task whenever I want to see what it read, what it did, and how it reached a judgment. The workbench needs to make delegation practical while keeping the work understandable.

In the evening, I mainly look at what was delivered, what is blocked, and what is still waiting.

If a result needs revision, I add the request to the existing task. If the direction has changed, I adjust the goal. I answer the questions that need me. Work that has been happening separately during the day comes together in one place.

That is the most important reason I built this tool.

AI is already capable of carrying out a great deal of work, and that capability will keep growing. As more work can be delegated, human attention will increasingly concentrate on goals, trade-offs, and judgment. Tools need to support that way of working and recognize when it is worth asking a person to step in.

Renyi builds on DeepSeek Harness and Superagent. I try to reuse existing models, tools, and execution capabilities, and put my development effort into the workflows I actually use.

The workbench is still growing, and daily use keeps shaping it. I am already getting used to assigning work in one place and receiving progress, questions, and results there too.

Next, I will keep connecting more routine work and helping important projects move forward over time. When I open the workbench each day, I want to get straight to the work most worth doing.

The project is open source. It is called Renyi, EnyAgentDesk.

GitHub · EnyAgentDesk