Liu Qi

Inspiration

AI agents can now write code, execute commands, modify files, use tools, and collaborate with other agents. As their autonomy grows, so does a critical problem: how do we understand and control what they are doing?

We were inspired to build a middleware layer that makes autonomous agents not only capable, but also observable, controllable, and governable. The challenge specifically highlighted areas such as authorization, tracing, safety, recovery, and multi-agent coordination as meaningful middleware directions.

What it does

Liu Qi is an agent middleware platform for creating, running, and coordinating autonomous AI agents.

Users can create specialized agents, interact with them individually, or bring multiple agents together within a shared project. Behind the scenes, the platform provides multi-agent orchestration, role-based access control, sandboxed execution, lifecycle management, observability, and execution safeguards.

Instead of treating an AI agent as a black-box chatbot, Liu Qi treats each agent as a software actor whose actions can be tracked, restricted, coordinated and stopped.

How we built it

We extended the provided Agent Launchpad while preserving its existing Agent lifecycle, Playground, persistent workspaces and model execution capabilities.

Our architecture follows a layered approach:

User → Web UI → Control Plane → Middleware → Agent Runtime → Sandbox / Tools / Files

The frontend provides the workspace for creating agents, managing projects, chatting with agents, and inspecting their activity.

The backend acts as the control plane. It manages agent lifecycle, permissions, orchestration, execution state, and middleware evidence before actions reach the runtime.

Agents execute real tasks through Codex CLI, with BytePlus ModelArk providing model inference. Containerized execution provides isolation, while persistent workspaces allow agents to continue working across multiple interactions.

For multi-agent projects, specialized agents can collaborate on shared artifacts while retaining their own identities, instructions, and conversation context.

Challenges we ran into

One of our biggest challenges was determining where control should actually be enforced. A disabled button in the frontend does not prevent an autonomous agent from performing an action, so important policies had to be enforced at trusted backend and runtime boundaries.

Multi-agent collaboration was another challenge. Multiple agents needed to work on the same project without losing their individual identities or interfering with one another's execution.

We also had to balance agent autonomy and safety. Agents require access to files, tools, models, and execution environments to be useful, while the platform still needs to observe, restrict, and terminate those actions when necessary.

Finally, hackathon time forced us to prioritize coherent, functional middleware over simply adding as many features as possible, which is also consistent with the challenge's focus on depth rather than breadth.

Accomplishments that we're proud of

We're proud that Liu Qi evolved beyond a single-agent Playground into a functioning multi-agent control platform.

Rather than presenting middleware concepts through static UI, we integrated them into real execution paths. Agents can perform actual work, collaborate through projects, modify shared artifacts, execute inside controlled environments, and produce observable evidence of their activity.

We're especially proud that the system remains human-controllable even as agent autonomy increases. Users can understand which agent is acting, inspect execution, manage permissions and lifecycle state, and intervene when necessary.

What we learned

The biggest lesson was that building an AI agent and building an agent platform are very different problems.

Once an agent can take real actions, traditional infrastructure concerns such as authorization, isolation, observability, lifecycle management, failure handling, and auditability become critical.

We also learned that multi-agent systems are more than several LLMs talking to each other. They require explicit orchestration, shared-state management, execution boundaries, and clear rules governing who can do what, when, and why.

Ultimately, greater agent autonomy needs to be accompanied by stronger infrastructure for human control.

What's next for Liu Qi

Our long-term vision is to turn Liu Qi into a control plane for teams of autonomous agents.

We want to expand the platform with richer agent permissions and delegation, stronger sandbox isolation, more sophisticated multi-agent planning, improved trace and cost analytics, additional model and tool providers, and more robust recovery mechanisms.

We also envision a visual workspace where users can watch agents collaborate in real time, understand what each agent is doing, intervene when necessary, and manage an entire digital workforce from one place.

The goal is simple: give AI agents greater autonomy without giving up human control.