Agent Scrivener: AI Research Automation with Kiro

A multi-agent AI that autonomously writes research reports. We used Kiro's spec-driven development to manage the extreme complexity, turning a chaotic concept into a robust, working application.

Comment

1. About the project (Project Story)

Copy everything in the box below and paste it into the "About the project" text area.

Inspiration

The dream of multi-agent AI systems—where specialized agents collaborate to solve complex problems—is incredible. However, the reality of building them is a nightmare of tangled logic, fragile data contracts, and chaotic debugging. We were inspired to build Agent Scrivener not just to create a powerful research tool, but to prove that there is a better way to build these complex systems. We wanted to find a workflow that could tame the chaos.

What It Does

Agent Scrivener is a fully autonomous, multi-agent research system. You give it a single topic, and its specialized agents collaborate to produce a comprehensive, cited report.

  • A Researcher agent scours sources for relevant information.
  • A Summarizer agent synthesizes the key findings.
  • An Editor agent formats everything into a polished, readable document.

The result is a workflow that transforms a high-level idea into a detailed, structured output, fully automated.

How We Built It

This project would have been impossible without a complete shift in our development process, centered around the Kiro IDE.

The Power of Spec-Driven Development

From day one, we abandoned traditional coding in favor of Kiro's spec-driven paradigm. Instead of ambiguous comments, we defined iron-clad rules for our agents in plain English. This single feature saved us from countless integration bugs.

For example, this simple spec defined the critical data handoff between two agents:

spec: The Researcher agent MUST pass a JSON object to the Summarizer containing a 'citations' array of URLs and a 'raw_text' string.

This wasn't just documentation; it was a rule that Kiro actively used to guide and validate our implementation, ensuring our agents could always communicate perfectly.

Automation with Agent Hooks

The boilerplate for creating new agents was immense. We automated this entirely with a Kiro Agent Hook.

@kiro.hook.on_file_create("agents/agent_*.py")
def generate_agent_boilerplate(ctx):
    # This hook automatically generates the entire class
    # structure, logging, error handling, and test files
    # for any new agent we create.
    ...

This single automation saved us dozens of hours and enforced a consistent, high-quality architecture across the entire project. Our workflow became less about tedious repetition and more about creative problem-solving.

Challenges We Ran Into

Debugging asynchronous communication between agents is notoriously difficult. At one point, our Summarizer was failing due to a malformed data packet from the Researcher. Instead of manual debugging, our Kiro specs became our primary tool. The spec provided a clear "source of truth" for the data contract, allowing us to instantly pinpoint the discrepancy and fix it in minutes, not hours.

What We Learned

We learned that an agentic IDE like Kiro is more than just a tool—it's a partner in the development process. By allowing us to define behavior in natural language and automate our workflows, we could focus on high-level architecture instead of getting lost in the weeds. This is the future of building complex software.

What's Next for Agent Scrivener

We plan to add more specialized agents, such as a "Fact-Checker" and a "Data Visualizer." We also aim to build a simple web interface to make the tool accessible to non-developers.

Built With

Share this project:

Updates