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 system. No hype, just the systems and lessons learned from shipping agentic engineering.

Justin Tsugranes·May 19, 2026·4 min read
On this page
  1. The Problem with Single-Prompt Narratives
  2. Agentic Engineering: The Inky Architecture
  3. 1. The Plot Architect
  4. 2. The Character Lead
  5. 3. The Prose Engine
  6. Technical Trade-offs and Lessons Learned
  7. The Money Layer: Profit Before Scale
  8. Shipping Today

I am currently building Inky. It is a digital product designed to generate long-form, coherent narratives using a multi-agent system. Most people think building an ai story app is about writing a better prompt. It isn't. It is about architecting a system that manages state, maintains character consistency, and handles the inevitable drift that occurs when an LLM tries to remember what happened in chapter one while writing chapter ten.

I have spent the last few months working in public on this project. Here is the architecture, the trade-offs, and what I have learned the hard way.

The Problem with Single-Prompt Narratives

If you send a 5,000-word prompt to Claude or GPT-4 asking for a story, you get a generic arc. The prose is often purple, the pacing is rushed, and the logic breaks by page five. This happens because the model is trying to be the architect, the writer, and the editor simultaneously. It fails at all three because it lacks a feedback loop.

When building an ai story app that actually works, you have to decouple these roles. In my studio, I use a framework I built called VERA to orchestrate these tasks. Instead of one prompt, Inky uses a sequence of specialized agents that pass artifacts between one another.

Agentic Engineering: The Inky Architecture

Inky does not function as a chatbot. It functions as a production line. The system is built on a monorepo architecture, allowing me to share types and logic between the orchestration layer and the frontend without friction.

1. The Plot Architect

This agent does not write prose. Its only job is to generate a structural outline—beats, conflict points, and resolution arcs. It outputs JSON. By forcing the output into a schema, I can validate the logic before a single word of the story is written. If the plot doesn't close its loops, the system catches it here.

2. The Character Lead

This agent maintains the 'source of truth' for every entity in the story. When building an ai story app, character drift is the primary killer of immersion. The Character Lead manages a vector database of traits, backstories, and physical descriptions. Before a scene is written, this agent injects the relevant context into the writer's buffer.

3. The Prose Engine

This is where the actual writing happens. By the time the Prose Engine receives a task, it has a specific beat to cover and a specific set of character constraints to follow. It isn't 'imagining' a story; it is executing a brief. This reduces the cognitive load on the model and results in significantly higher-quality output.

Keep reading

Related posts

All posts→
Building an AI Story App: Architecture and Lessons from Inky
May 27, 2026

Building an AI Story App: Architecture and Lessons from Inky

A look inside the architecture of Inky. I'm sharing what I learned the hard way about building an AI story app using agentic engineering and a multi-product studio model.

AIArchitectureInkyAgentic Engineering

Technical Trade-offs and Lessons Learned

I learned the hard way that long-context windows are not a silver bullet. Just because a model can 'see' 200k tokens doesn't mean it weights them equally. In the early builds of Inky, the model would frequently forget a character's eye color or a pivotal plot point from three scenes prior, despite that information being in the context window.

To solve this, I moved to an agentic engineering approach using Model Context Protocol (MCP) servers. Instead of stuffing the context window, the agents query a dedicated 'World State' server. This server acts as the long-term memory, providing only the specific facts needed for the current scene. This reduced my token costs by 40% and increased narrative consistency across the board.

Another specific lesson: avoid 'creative' temperature settings. When building an ai story app, there is a temptation to crank the temperature to 0.9 or 1.0 to get 'interesting' writing. This usually just leads to hallucinations and broken JSON. I keep Inky at a steady 0.7 for prose and 0.2 for structural tasks. Reliability beats novelty every time.

The Money Layer: Profit Before Scale

I run a multi-product studio, not a VC-backed moonshot. This means Inky has to be profitable from day one. I am not interested in 'disrupting' the publishing industry; I am interested in building a durable tool for creators.

By using AI as the team, I can maintain a high shipping velocity without the overhead of a traditional engineering department. The system handles the research, the initial drafts, and the formatting. I handle the architecture and the final polish. This is the operating model for the modern builder.

Shipping Today

Inky is currently in a closed beta. I am refining the orchestration layer to handle more complex genre constraints and improving the speed of the 'World State' queries. The goal is a system that can produce a 50,000-word manuscript that requires minimal human intervention to be market-ready.

Building an ai story app has taught me more about system design than any CRUD app ever could. It is a constant battle against entropy and the limitations of current models. But the systems are getting better, and the feedback loops are getting tighter.

If you are building something similar or want to look at the specific MCP implementations I am using, I am happy to talk.

Work through this in a 1:1 strategy session through Total Ventures — totalventures.io/booking

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#Inky#Agentic Engineering#Shipping

On this page

  1. The Problem with Single-Prompt Narratives
  2. Agentic Engineering: The Inky Architecture
  3. 1. The Plot Architect
  4. 2. The Character Lead
  5. 3. The Prose Engine
  6. Technical Trade-offs and Lessons Learned
  7. The Money Layer: Profit Before Scale
  8. Shipping Today
Building an AI Story App: Architecture and Lessons from Inky
Jun 3, 2026

Building an AI Story App: Architecture and Lessons from Inky

A look inside the architecture of Inky. No hype, just the systems and agentic engineering used to ship a multi-modal storytelling platform as a solo operator.

AIArchitectureInkyEngineering
Building an AI Story App: Architecture and Lessons from Inky
May 21, 2026

Building an AI Story App: Architecture and Lessons from Inky

A look inside the architecture of Inky. I’m sharing how I’m building an AI story app using agentic engineering and a multi-product studio mindset.

AIArchitectureEngineeringInky