Skip to main content

Loading…

Skip to main content
HomeProjectsPostsContact
Justin Tsugranes LogoJustin Tsugranes Logo

Justin Tsugranes

HomeProjectsPostsContact

Stay in the loop

Occasional notes on what I'm building, lessons earned, and the studio behind it.

By subscribing, you agree to receive No spam. Unsubscribe in one click anytime. from Justin Tsugranes. No spam. Unsubscribe anytime. Privacy Policy

© 2026 Total Ventures LLC. All rights reserved.

Privacy PolicyTerms of ServiceCookie Policy
Building an AI Story App: Architecture and Lessons from Inky | Justin Tsugranes | Justin Tsugranes
Xinf
Building an AI Story App: Architecture and Lessons from Inky
←Posts

Building & Operating

Building an AI Story App: Architecture and Lessons from Inky

A look inside the architecture of Inky, a multi-agent storytelling app. No hype, just the systems and lessons learned from shipping today.

Justin Tsugranes·May 26, 2026·4 min read
On this page
  1. The Architecture of an Agentic Storytelling System
  2. Moving Beyond Simple Prompts
  3. The Stack: Choosing Instruments, Not Credentials
  4. VERA: The Orchestration Layer
  5. Lessons Learned the Hard Way
  6. Context Windows and State Management
  7. The Cost of Latency
  8. Shipping Today: The Reality of AI Operations
  9. Profit Before Scale

Building an AI story app is often framed as a prompt engineering exercise. It isn't. When I started building Inky, my goal wasn't to create a wrapper for a large language model. It was to architect a system where AI functions as the operating layer for narrative generation.

I am working in public on this project because the gap between AI hype and shipping software is widening. Most of what you read online is about what AI might do. This is about what it is doing in my studio today.

The Architecture of an Agentic Storytelling System

When you are building an ai story app, the first thing you realize is that a single prompt cannot maintain the coherence required for a long-form narrative. A story is a system of constraints—character arcs, world-building rules, and plot pacing. If you dump all of that into one context window, the model eventually drifts.

Inky uses what I call agentic engineering. Instead of one monolithic call, the system is broken down into specialized agents.

Moving Beyond Simple Prompts

In the Inky architecture, we have distinct agents for different layers of the craft:

  1. The Architect: Responsible for the structural integrity of the plot. It doesn't write prose; it manages the outline and ensures the narrative beats align with the user's intent.
  2. The Chronicler: This agent maintains the 'world state.' If a character loses a key in chapter two, the Chronicler ensures they don't magically use it in chapter five.
  3. The Stylist: This is the only agent that touches the final prose. It takes the instructions from the Architect and the constraints from the Chronicler to generate the text.

By separating these concerns, the system becomes more predictable. You can swap out the Stylist model (perhaps using Claude 3.5 Sonnet for its nuance) while keeping the Architect on a faster, cheaper model like Gemini 1.5 Flash.

Keep reading

Related posts

All posts→
Building an AI Story App: Systems Over Prompts
May 8, 2026

Building an AI Story App: Systems Over Prompts

Most AI apps are just wrappers. Building an AI story app like Inky requires a robust system for state, agentic orchestration, and long-term coherence.

aiarchitectureshippingsystems

The Stack: Choosing Instruments, Not Credentials

I don’t care about being an expert in a specific framework. I care about what allows me to ship today. For Inky, the stack is a reflection of utility.

We use a monorepo architecture. As a solo operator running a studio, I don't have time to manage the overhead of microservices. The backend is built on Node.js with a heavy reliance on the Claude API and Gemini for multimodal inputs.

VERA: The Orchestration Layer

To manage these agents, I built a custom orchestration layer called VERA. It handles the handoffs between the Architect and the Stylist. It isn't a complex framework you'd find on GitHub; it’s a set of lean feedback loops that monitor for hallucinations and state drift.

When building an ai story app, the orchestration is where the value lives. The models are commodities. The system that governs them is the product.

Lessons Learned the Hard Way

I’ve spent years running logistics in the Army and managing thousands of SKUs in e-commerce. Those roles taught me that systems fail at the seams. Software is no different.

Context Windows and State Management

One thing I learned the hard way is that 'infinite' context windows are a marketing term, not a technical reality. Even with 2M token limits, the model’s attention degrades.

In Inky, I stopped relying on the model to 'remember' the story. Instead, I implemented a vector database to store the world state. Before every generation, the system queries the database for relevant facts—character traits, past events, and setting details—and injects them into the prompt. This keeps the 'memory' sharp without bloating the context window.

The Cost of Latency

Users don't want to wait 30 seconds for a paragraph. I had to re-engineer the Stylist agent to stream responses. This sounds simple, but when you are coordinating multiple agents, streaming requires a robust state machine to ensure the UI doesn't break when an agent mid-stream needs to call a tool.

Shipping Today: The Reality of AI Operations

I run this studio with AI as the team. This means I use agents for research, monitoring, and infrastructure. When I’m building an ai story app, I’m not just writing code; I’m designing the workflows that allow the app to maintain itself.

Profit Before Scale

I build for durability. Inky isn't designed to 'disrupt' the publishing industry. It’s designed to be a well-run, profitable digital product that serves a specific creative need. I prioritize craft over scale. If the system can't produce a high-quality, coherent 50,000-word manuscript, it doesn't matter how many users we can onboard.

Building in the AI space requires a certain level of detachment from the noise. The tools change every week. The principles of systems architecture—feedback loops, state management, and separation of concerns—remain the same.

If you are currently building an ai story app or any agentic system, focus on the seams. That is where the product is won or lost.

Happy to talk.

—Justin

Recommended$79

The Builder’s Playbook

How I run a multi-brand studio with AI agents — the systems, not the hype.

  • •The agent-augmented operating model
  • •Real workflows you can copy
  • •From idea to shipped, repeatably
Get the playbook →
If this resonated

The studio is where the rest of it lives.

Total Ventures is the umbrella — the products, the resources, the strategy session.

totalventures.io
  • Resources

    Launch Checklist + the Builder’s Playbook bundle.

  • Strategy session

    A focused hour on your repo, stack, and monetization.

  • The brands

    The portfolio of products I’m building, end to end.

Studio Notes

How I’m building the studio.

The operator’s log — systems, decisions, and what’s working.

JT

Written by

Justin Tsugranes

Founder, Total Ventures

Solo-founder building a multi-brand product studio with AI agents. Writing about building, operating, and shipping.

ShareXLinkedInFacebook
#ai#architecture#shipping#systems

On this page

  1. The Architecture of an Agentic Storytelling System
  2. Moving Beyond Simple Prompts
  3. The Stack: Choosing Instruments, Not Credentials
  4. VERA: The Orchestration Layer
  5. Lessons Learned the Hard Way
  6. Context Windows and State Management
  7. The Cost of Latency
  8. Shipping Today: The Reality of AI Operations
  9. Profit Before Scale
Building an AI Story App: Lessons from Shipping Inky
Jun 7, 2026

Building an AI Story App: Lessons from Shipping Inky

I am building Inky, an AI storytelling app. Here is the architecture, the failures, and the systems required to ship a generative product that actually works.

aiarchitectureinkyshipping
Building an AI Story App: Lessons from the Studio Floor
Jun 6, 2026

Building an AI Story App: Lessons from the Studio Floor

Inside the architecture of Inky. A look at agentic engineering, narrative coherence, and the lessons learned the hard way while building an ai story app.

aiarchitectureagentic-engineeringinky